Input:
public void scheduleRepeatingJobForOutBoxCall(Patient patient) {
    if (patient.getPatientPreferences().getCallPreference().equals(CallPreference.DailyPillReminder)) {
        Map<String, Object> eventParams = new SchedulerPayloadBuilder().withJobId(patient.getId()).withExternalId(patient.getId()).payload();
        eventParams.put(IS_RETRY, "String_Node_Str");
        MotechEvent outboxCallEvent = new MotechEvent(TAMAConstants.OUTBOX_CALL_SCHEDULER_SUBJECT, eventParams);
        Integer maxOutboundRetries = Integer.valueOf(properties.getProperty(TAMAConstants.OUT_BOX_CALL_RETRIES_PER_DAY));
        int repeatIntervalInMinutes = Integer.valueOf(properties.getProperty(TAMAConstants.OUT_BOX_CALL_RETRY_INTERVAL));
        RepeatingSchedulableJob outboxCallJob = new RepeatingSchedulableJob(outboxCallEvent, DateUtil.now().plusMinutes(repeatIntervalInMinutes).toDate(), DateUtil.today().plusDays(1).toDate(), maxOutboundRetries, repeatIntervalInMinutes * 60 * 1000);
        motechSchedulerService.scheduleRepeatingJob(outboxCallJob);
    }
}

Output:
         MotechEvent outboxCallEvent = new MotechEvent(TAMAConstants.OUTBOX_CALL_SCHEDULER_SUBJECT, eventParams);
-        Integer maxOutboundRetries = Integer.valueOf(properties.getProperty(TAMAConstants.OUT_BOX_CALL_RETRIES_PER_DAY));
+        Integer maxOutboundRetries = Integer.valueOf(properties.getProperty(TAMAConstants.OUT_BOX_CALL_RETRIES_PER_DAY)) - 1;
         int repeatIntervalInMinutes = Integer.valueOf(properties.getProperty(TAMAConstants.OUT_BOX_CALL_RETRY_INTERVAL));


Input:
private void parseSign(Sign sign, Minecart cart, Direction direction) {
    if (SignParser.checkStorageCart(cart)) {
        StorageMinecart storageCart = (StorageMinecart) cart;
        HashMap<SignParser.Action, IntMap> dataMap = SignParser.parseSign(sign, storageCart);
        List<Chest> chests;
        for (Map.Entry<SignParser.Action, IntMap> entry : dataMap.entrySet()) {
            if (entry.getValue() == null)
                continue;
            switch(entry.getKey()) {
                case COLLECT:
                    chests = ChestUtil.getChestsAroundBlock(sign.getBlock(), 1);
                    for (Chest c : chests) {
                        c.getInventory().setContents(ChestUtil.putItems(c.getInventory().getContents(), (ContainerBlock) storageCart, entry.getValue()));
                    }
                    break;
                case DEPOSIT:
                    chests = ChestUtil.getChestsAroundBlock(sign.getBlock(), 1);
                    for (Chest c : chests) {
                        storageCart.getInventory().setContents(ChestUtil.putItems(storageCart.getInventory().getContents(), (ContainerBlock) c, entry.getValue()));
                    }
                    break;
            }
        }
    }
}

Output:
                     for (Chest c : chests) {
-                        c.getInventory().setContents(ChestUtil.putItems(c.getInventory().getContents(), (ContainerBlock) storageCart, entry.getValue()));
+                        ChestUtil.moveItems(c.getInventory(), storageCart.getInventory(), entry.getValue());
                     }


Input:
public void clearSelected() {
    setSelected(-1);
}

Output:
 public void clearSelected() {
-    setSelected(-1);
+    setSelected(NO_VALUE_SELECTED);
 }


Input:
public void run() {
    synchronized (speechRecognizerLock) {
        if (recognitionActive) {
            if (speechRecognizer != null) {
                speechRecognizer.cancel();
            }
            recognitionActive = false;
        }
    }
}

Output:
             }
-            recognitionActive = false;
+            onListeningCancelled();
         }


Input:
public static BytesReference encodeSettings(Settings settings) throws IOException {
    BytesStreamOutput bso = new BytesStreamOutput();
    ImmutableSettings.writeSettingsToStream(settings, bso);
    return bso.bytes();
}

Output:
     BytesStreamOutput bso = new BytesStreamOutput();
-    ImmutableSettings.writeSettingsToStream(settings, bso);
+    XContentBuilder builder = XContentFactory.jsonBuilder(bso);
+    builder.startObject();
+    for (Map.Entry<String, String> entry : settings.getAsMap().entrySet()) {
+        builder.field(entry.getKey(), entry.getValue());
+    }
+    builder.endObject();
+    builder.flush();
     return bso.bytes();


Input:
public void testGetTasks() {
    JobSpecT spec = getTestJobSpec();
    jobService.launch(spec);
    UUID id = simpleJdbcTemplate.queryForObject("String_Node_Str", UUID.class);
    List<TaskT> task = thriftTaskDao.getTasks(id);
    assertTrue(task.size() > 0);
}

Output:
     JobSpecT spec = getTestJobSpec();
-    jobService.launch(spec);
-    UUID id = simpleJdbcTemplate.queryForObject("String_Node_Str", UUID.class);
-    List<TaskT> task = thriftTaskDao.getTasks(id);
+    JobLaunchEvent event = jobService.launch(spec);
+    TaskFilterT filter = new TaskFilterT();
+    filter.jobId = event.getJob().getJobId().toString();
+    List<TaskT> task = thriftTaskDao.getTasks(filter);
     assertTrue(task.size() > 0);


Input:
public HashMap<String, UnresolvedRowHint> getUnresolvedRowHints() {
    return lastPageUnresolvedRowHints;
}

Output:
 public HashMap<String, UnresolvedRowHint> getUnresolvedRowHints() {
-    return lastPageUnresolvedRowHints;
+    return pageRowHint;
 }


Input:
public static Controller defineModulesWithOneLoader(Configuration cf, List<Layer> parentLayers, ClassLoader parentLoader) {
    List<Layer> parents = new ArrayList<>(parentLayers);
    checkConfiguration(cf, parents);
    checkCreateClassLoaderPermission();
    checkGetClassLoaderPermission();
    try {
        Loader loader = new Loader(cf.modules(), parentLoader);
        loader.initRemotePackageMap(cf, parents);
        Layer layer = new Layer(cf, parents, mn -> loader);
        return new Controller(layer);
    } catch (IllegalArgumentException e) {
        throw new LayerInstantiationException(e.getMessage());
    }
}

Output:
         return new Controller(layer);
-    } catch (IllegalArgumentException e) {
+    } catch (IllegalArgumentException | IllegalStateException e) {
         throw new LayerInstantiationException(e.getMessage());


Input:
private void doUpdateAssessmentBySum(UserCourseEnvironment userCourseEnv, Identity assessedIdentity) {
    OLATResourceable courseOres = OresHelper.createOLATResourceableInstance("String_Node_Str", userCourseEnv.getCourseEnvironment().getCourseResourceableId());
    ModuleConfiguration config = getModuleConfiguration();
    CheckboxManager checkboxManager = CoreSpringFactory.getImpl(CheckboxManager.class);
    int checkedBox = checkboxManager.countChecked(assessedIdentity, courseOres, getIdent());
    CheckboxList checkboxList = (CheckboxList) config.get(CONFIG_KEY_CHECKBOX);
    Integer cut = (Integer) config.get(CheckListCourseNode.CONFIG_KEY_PASSED_SUM_CUTVALUE);
    int minNumOfCheckbox = cut == null ? checkboxList.getNumOfCheckbox() : cut.intValue();
    boolean passed = checkedBox >= minNumOfCheckbox;
    Float score = null;
    if (passed) {
        Boolean scoreGrantedBool = (Boolean) config.get(MSCourseNode.CONFIG_KEY_HAS_SCORE_FIELD);
        if (scoreGrantedBool != null && scoreGrantedBool.booleanValue()) {
            score = (Float) config.get(MSCourseNode.CONFIG_KEY_SCORE_MAX);
        }
    }
    ScoreEvaluation sceval = new ScoreEvaluation(score, new Boolean(passed));
    AssessmentManager am = userCourseEnv.getCourseEnvironment().getAssessmentManager();
    Identity mySelf = userCourseEnv.getIdentityEnvironment().getIdentity();
    am.saveScoreEvaluation(this, mySelf, assessedIdentity, sceval, userCourseEnv, false);
    userCourseEnv.getScoreAccounting().scoreInfoChanged(this, sceval);
}

Output:
         if (scoreGrantedBool != null && scoreGrantedBool.booleanValue()) {
-            score = (Float) config.get(MSCourseNode.CONFIG_KEY_SCORE_MAX);
+            score = checkboxManager.calculateScore(assessedIdentity, courseOres, getIdent());
+            Float maxScore = (Float) config.get(MSCourseNode.CONFIG_KEY_SCORE_MAX);
+            if (maxScore != null && maxScore.floatValue() < score) {
+                score = maxScore.floatValue();
+            }
         }


Input:
public List<KieTask> getHumanTaskList(String groups, Map<String, String> opt) throws ApsSystemException {
    Map<String, String> headersMap = new HashMap<>();
    List<KieTask> list = new ArrayList<>();
    if (!config.getActive()) {
        return list;
    }
    try {
        Endpoint ep = KieEndpointDictionary.create().get(API_GET_HUMAN_TASK_LIST);
        KieClient client = getCurrentClient();
        headersMap.put(HEADER_KEY_ACCEPT, HEADER_VALUE_JSON);
        KieTaskQueryResult result = (KieTaskQueryResult) new KieRequestBuilder(client).setEndpoint(ep).setHeaders(headersMap).setRequestParams(opt).setDebug(config.getDebug()).doRequest(KieTaskQueryResult.class);
        if (null != result && null != result.getList() && !result.getList().isEmpty()) {
            list = result.getList();
        }
    } catch (Throwable t) {
        throw new ApsSystemException("String_Node_Str", t);
    }
    return list;
}

Output:
         headersMap.put(HEADER_KEY_ACCEPT, HEADER_VALUE_JSON);
-        KieTaskQueryResult result = (KieTaskQueryResult) new KieRequestBuilder(client).setEndpoint(ep).setHeaders(headersMap).setRequestParams(opt).setDebug(config.getDebug()).doRequest(KieTaskQueryResult.class);
+        RequestBuilder requestBuilder = new KieRequestBuilder(client).setEndpoint(ep).setHeaders(headersMap).setRequestParams(opt).setDebug(config.getDebug());
+        if (groups != null && !"String_Node_Str".equalsIgnoreCase(groups)) {
+            Map<String, String> recurringParameters = new HashMap<String, String>();
+            recurringParameters.put("String_Node_Str", groups);
+            ((KieRequestBuilder) requestBuilder).setRecurringParameters(recurringParameters);
+        }
+        KieTaskQueryResult result = (KieTaskQueryResult) requestBuilder.doRequest(KieTaskQueryResult.class);
         if (null != result && null != result.getList() && !result.getList().isEmpty()) {


Input:
private static void boundsCheck(final byte[] buffer, final int index, final int length) {
    if (SHOULD_BOUNDS_CHECK) {
        final int capacity = buffer.length;
        if (index < 0 || length < 0 || (index + length) > capacity) {
            throw new IndexOutOfBoundsException(String.format("String_Node_Str", index, length, capacity));
        }
    }
}

Output:
     if (SHOULD_BOUNDS_CHECK) {
-        final int capacity = buffer.length;
-        if (index < 0 || length < 0 || (index + length) > capacity) {
-            throw new IndexOutOfBoundsException(String.format("String_Node_Str", index, length, capacity));
-        }
+        ArrayUtils.boundsCheck(buffer.length, index, length);
     }


Input:
public void cancel() throws OseeCoreException {
    try {
        if (preparedStatement != null) {
            preparedStatement.cancel();
        }
        if (callableStatement != null) {
            callableStatement.cancel();
        }
    } catch (SQLException ex) {
        OseeExceptions.wrapAndThrow(ex);
    }
}

Output:
     try {
-        if (preparedStatement != null) {
+        if (preparedStatement != null && !preparedStatement.isClosed()) {
             preparedStatement.cancel();


Input:
protected void reduce(final ComparisonCellData key, final Iterable<LongWritable> values, final Context context) throws IOException, InterruptedException {
    for (final LongWritable v : values) {
        final long cellIndex = v.get() / numLevels;
        final Point2d[] bbox = fromIndexToLL_UR(cellIndex);
        builder.add(GeometryUtils.GEOMETRY_FACTORY.toGeometry(new Envelope(bbox[0].x, bbox[1].x, bbox[0].y, bbox[1].y)));
        builder.add(key.getSummerPercentile());
        builder.add(key.getWinterPercentile());
        builder.add(key.getCombinedPercentile());
        inc += (1.0 / totalKeys);
        builder.add(inc);
        final SimpleFeature feature = builder.buildFeature(new Long(cellIndex).toString());
        dataStore.ingest(adapter, index, feature);
    }
}

Output:
         builder.add(inc);
-        final SimpleFeature feature = builder.buildFeature(new Long(cellIndex).toString());
+        final SimpleFeature feature = builder.buildFeature(Long.toString(cellIndex));
         dataStore.ingest(adapter, index, feature);


Input:
private void fixTitle() {
    toolbar.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        public void onGlobalLayout() {
            findActionMenuView(toolbar).getViewTreeObserver().removeGlobalOnLayoutListener(this);
            fixTitleWidth();
            tvTitel.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
                public void onGlobalLayout() {
                    tvTitel.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                    if (tvTitel.getLayout().getLineCount() > 1) {
                        toolbar.setMinimumHeight((int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 84f, getResources().getDisplayMetrics()));
                    }
                }
            });
            onScrollChanged(0, 0);
        }
    });
}

Output:
                 }
-            });
-            onScrollChanged(0, 0);
-        }
-    });
+            }
+        });
+    }
+    onScrollChanged(0, 0);
 }


Input:
public void process(Node externs, Node root) {
    Preconditions.checkState(compiler.getLifeCycleStage() == LifeCycleStage.NORMALIZED);
    this.ancestorInterfaces = new HashMap<>();
    this.gtwpCache = new HashMap<>();
    for (TypeMismatch mis : compiler.getTypeMismatches()) {
        recordInvalidatingType(mis.typeA, mis.src);
        recordInvalidatingType(mis.typeB, mis.src);
    }
    for (TypeMismatch mis : compiler.getImplicitInterfaceUses()) {
        recordInvalidatingType(mis.typeA, mis.src);
        recordInvalidatingType(mis.typeB, mis.src);
    }
    NodeTraversal.traverseEs6(compiler, externs, new FindExternProperties());
    NodeTraversal.traverseEs6(compiler, root, new FindRenameableProperties());
    renameProperties();
}

Output:
     for (TypeMismatch mis : compiler.getTypeMismatches()) {
-        recordInvalidatingType(mis.typeA, mis.src);
-        recordInvalidatingType(mis.typeB, mis.src);
+        recordInvalidatingType(mis.typeA, mis);
+        recordInvalidatingType(mis.typeB, mis);
     }


Input:
private static void saveCurrentInstalationToLocal() {
    try {
        writeInstallationFile(currentInstallation);
    } catch (Exception e) {
        LogUtil.log.e(LOGTAG, e);
    }
}

Output:
     try {
-        writeInstallationFile(currentInstallation);
+        writeInstallationFile(ctx, currentInstallation);
     } catch (Exception e) {


Input:
public void onVehicleMove(VehicleMoveEvent event) {
    if (event.getVehicle().getPassenger() instanceof Player) {
        System.out.print("String_Node_Str");
        Vehicle v = event.getVehicle();
        Player p = (Player) v.getPassenger();
        teleportVehicle(v, p);
    }
}

Output:
         Player p = (Player) v.getPassenger();
-        teleportVehicle(v, p);
+        PortalPlayerSession ps = this.plugin.getPortalSession(p);
+        ps.setStaleLocation(v.getLocation(), Type.VEHICLE_MOVE);
+        if (ps.isStaleLocation()) {
+            return;
+        }
+        teleportVehicle(p, v, event.getTo());
     }


Input:
public void handleClient(Session session, AddEntityMessage message) {
    if (!session.hasPlayer()) {
        return;
    }
    System.out.println("String_Node_Str" + message.getEntityId() + "String_Node_Str" + message.getType().getName());
    Player player = session.getPlayer();
    Entity newEntity;
    if (message.getEntityId() == session.getDataMap().get(SpoutProtocol.PLAYER_ENTITY_ID)) {
        newEntity = player;
    } else {
        newEntity = session.getEngine().getDefaultWorld().createEntity(message.getTransform().getPosition(), null);
    }
    Controller controller = message.getType().createController();
    if (controller == null) {
        throw new IllegalArgumentException("String_Node_Str" + message.getType().getName() + "String_Node_Str");
    }
    newEntity.setController(controller);
    newEntity.setTransform(message.getTransform());
    ((Client) session.getEngine()).getDefaultWorld().spawnEntity(newEntity);
}

Output:
     } else {
-        newEntity = session.getEngine().getDefaultWorld().createEntity(message.getTransform().getPosition(), null);
+        newEntity = session.getEngine().getDefaultWorld().createEntity(message.getTransform().getPosition());
     }


Input:
public static String createSessionTempDir(String tempRootDir) throws DataException {
    final String prefix = "String_Node_Str";
    File sessionFile = null;
    synchronized (cacheCounter2) {
        String sessionTempDir = tempRootDir + File.separator + prefix + System.currentTimeMillis() + cacheCounter2.intValue();
        cacheCounter2 = new Integer(cacheCounter2.intValue() + 1);
        sessionFile = new File(sessionTempDir);
        int i = 0;
        while (sessionFile.exists() || !sessionFile.mkdirs()) {
            i++;
            sessionTempDir = sessionTempDir + "String_Node_Str" + i;
            sessionFile = new File(sessionTempDir);
            if (i > MAX_DIR_CREATION_ATTEMPT)
                throw new DataException(ResourceConstants.FAIL_TO_CREATE_TEMP_DIR, sessionFile.getAbsolutePath());
        }
        sessionFile.deleteOnExit();
    }
    return getCanonicalPath(sessionFile);
}

Output:
     File sessionFile = null;
-    synchronized (cacheCounter2) {
-        String sessionTempDir = tempRootDir + File.separator + prefix + System.currentTimeMillis() + cacheCounter2.intValue();
-        cacheCounter2 = new Integer(cacheCounter2.intValue() + 1);
+    String sessionTempDir = tempRootDir + File.separator + prefix + System.currentTimeMillis() + cacheCounter2.intValue();
+    cacheCounter2.add(1);
+    sessionFile = new File(sessionTempDir);
+    int i = 0;
+    String tempDir = sessionTempDir;
+    while (sessionFile.exists()) {
+        i++;
+        sessionTempDir = tempDir + "String_Node_Str" + i;
         sessionFile = new File(sessionTempDir);


Input:
public void runOperation(VariableMap variableMap, IProgressMonitor monitor) throws Exception {
    IOseeBranch branch = variableMap.getBranch("String_Node_Str");
    AttributeType attributeType = variableMap.getAttributeType("String_Node_Str");
    List<Artifact> artifacts = ArtifactQuery.getArtifactListFromAttribute(attributeType, AttributeId.UNSPECIFIED, branch);
    SkynetTransaction transaction = TransactionManager.createTransaction(branch, "String_Node_Str");
    for (Artifact artifact : artifacts) {
        Collection<Attribute<String>> attributes = artifact.getAttributes(attributeType);
        for (Attribute<String> attribute1 : attributes) {
            if (!attribute1.getValue().equals(AttributeId.UNSPECIFIED)) {
                for (Attribute<String> attribute : attributes) {
                    if (attribute.getValue().equals(AttributeId.UNSPECIFIED)) {
                        attribute.delete();
                    }
                }
                artifact.persist(transaction);
                break;
            }
        }
    }
    transaction.execute();
}

Output:
 public void runOperation(VariableMap variableMap, IProgressMonitor monitor) throws Exception {
-    IOseeBranch branch = variableMap.getBranch("String_Node_Str");
+    BranchId branch = variableMap.getBranch("String_Node_Str");
     AttributeType attributeType = variableMap.getAttributeType("String_Node_Str");


Input:
protected void startUp() throws Exception {
    File tempDir = createTempDirectory();
    cleanupTask = createCleanupTask(tempDir);
    try {
        Job job = createJob(new File(tempDir, "String_Node_Str"));
        Configuration mapredConf = job.getConfiguration();
        classLoader = new MapReduceClassLoader(injector, cConf, mapredConf, context.getProgram().getClassLoader(), context.getPlugins(), context.getPluginInstantiator());
        cleanupTask = createCleanupTask(cleanupTask, classLoader);
        mapredConf.setClassLoader(new WeakReferenceDelegatorClassLoader(classLoader));
        ClassLoaders.setContextClassLoader(mapredConf.getClassLoader());
        context.setJob(job);
        beforeSubmit(job);
        Map<String, String> localizedUserResources = localizeUserResources(job, tempDir);
        String jobName = job.getJobName();
        if (!jobName.isEmpty()) {
            LOG.warn("String_Node_Str", jobName);
        }
        job.setJobName(getJobName(context));
        Location tempLocation = createTempLocationDirectory();
        cleanupTask = createCleanupTask(cleanupTask, tempLocation);
        if (!MapReduceTaskContextProvider.isLocal(mapredConf)) {
            File pluginArchive = context.getPluginArchive();
            if (pluginArchive != null) {
                job.addCacheArchive(pluginArchive.toURI());
                mapredConf.set(Constants.Plugin.ARCHIVE, pluginArchive.getName());
            }
        }
        setOutputClassesIfNeeded(job);
        setMapOutputClassesIfNeeded(job);
        TaskType.MAP.setResources(mapredConf, context.getMapperResources());
        TaskType.REDUCE.setResources(mapredConf, context.getReducerResources());
        MapperWrapper.wrap(job);
        ReducerWrapper.wrap(job);
        File jobJar = buildJobJar(job, tempDir);
        job.setJar(jobJar.toURI().toString());
        Location programJar = programJarLocation;
        if (!MapReduceTaskContextProvider.isLocal(mapredConf)) {
            programJar = copyProgramJar(tempLocation);
            job.addCacheFile(programJar.toURI());
            List<String> paths = new ArrayList<>();
            paths.add("String_Node_Str");
            paths.add("String_Node_Str");
            Location launcherJar = createLauncherJar(Joiner.on("String_Node_Str").join(MapReduceContainerHelper.getMapReduceClassPath(mapredConf, paths)), tempLocation);
            job.addCacheFile(launcherJar.toURI());
            URI frameworkURI = MapReduceContainerHelper.getFrameworkURI(mapredConf);
            if (frameworkURI != null) {
                job.addCacheArchive(frameworkURI);
            }
            mapredConf.unset(MRJobConfig.MAPREDUCE_APPLICATION_FRAMEWORK_PATH);
            mapredConf.set(MRJobConfig.MAPREDUCE_APPLICATION_CLASSPATH, launcherJar.getName());
            mapredConf.set(YarnConfiguration.YARN_APPLICATION_CLASSPATH, launcherJar.getName());
        }
        MapReduceContextConfig contextConfig = new MapReduceContextConfig(mapredConf);
        Transaction tx = txClient.startLong();
        try {
            CConfiguration cConfCopy = cConf;
            contextConfig.set(context, cConfCopy, tx, programJar.toURI(), localizedUserResources);
            LOG.info("String_Node_Str", context);
            job.submit();
            this.job = job;
            this.transaction = tx;
        } catch (Throwable t) {
            Transactions.invalidateQuietly(txClient, tx);
            throw t;
        }
    } catch (Throwable t) {
        LOG.error("String_Node_Str", context, t);
        cleanupTask.run();
        throw t;
    }
}

Output:
         if (!MapReduceTaskContextProvider.isLocal(mapredConf)) {
-            File pluginArchive = context.getPluginArchive();
+            Location pluginArchive = createPluginArchive(tempLocation);
             if (pluginArchive != null) {


Input:
public Element mapSubjectErrorConfirmation(String message) throws Exception {
    DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
    DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
    Document document = docBuilder.newDocument();
    Element responseElement = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
    Element indicator = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
    Attr typeAttr = document.createAttributeNS(XSL_NAMESPACE, "String_Node_Str");
    typeAttr.setNodeValue("String_Node_Str");
    indicator.setAttributeNode(typeAttr);
    indicator.setAttribute("String_Node_Str", "String_Node_Str");
    responseElement.appendChild(indicator);
    Element errormessage = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
    Element code = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
    code.setTextContent("String_Node_Str");
    errormessage.appendChild(code);
    Element reason = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
    reason.setTextContent(message);
    errormessage.appendChild(reason);
    responseElement.appendChild(errormessage);
    return responseElement;
}

Output:
 public Element mapSubjectErrorConfirmation(String message) throws Exception {
-    DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
-    DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
-    Document document = docBuilder.newDocument();
-    Element responseElement = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
-    Element indicator = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
-    Attr typeAttr = document.createAttributeNS(XSL_NAMESPACE, "String_Node_Str");
-    typeAttr.setNodeValue("String_Node_Str");
-    indicator.setAttributeNode(typeAttr);
-    indicator.setAttribute("String_Node_Str", "String_Node_Str");
-    responseElement.appendChild(indicator);
-    Element errormessage = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
-    Element code = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
-    code.setTextContent("String_Node_Str");
-    errormessage.appendChild(code);
-    Element reason = document.createElementNS(CONNECTOR_NAMESPACE_V1, "String_Node_Str");
-    reason.setTextContent(message);
-    errormessage.appendChild(reason);
-    responseElement.appendChild(errormessage);
-    return responseElement;
+    return mapGenericErrorConfirmation(message, new CCSystemFaultException("String_Node_Str"), new HashMap<String, String>());
 }


Input:
public void setOccurrenceIndex(int occurrenceIndex) {
    if (occurrenceIndex < 1) {
        throw new IllegalArgumentException(Strings.OccurrenceIndexMustBeGreaterThanZero);
    }
    this.occurrenceIndex = occurrenceIndex;
}

Output:
     if (occurrenceIndex < 1) {
-        throw new IllegalArgumentException(Strings.OccurrenceIndexMustBeGreaterThanZero);
+        throw new IllegalArgumentException("String_Node_Str");
     }


Input:
private void setDefaultSettings() {
    setLanguage(this.getDefaultLanguage(), getDefaultLanguage(), getDefaultLocVariant());
    setSpeechRate(getDefaultRate());
}

Output:
 private void setDefaultSettings() {
-    setLanguage(this.getDefaultLanguage(), getDefaultLanguage(), getDefaultLocVariant());
+    setLanguage(this.getDefaultLanguage(), getDefaultCountry(), getDefaultLocVariant());
     setSpeechRate(getDefaultRate());


Input:
private void friendRequestMessageReceived(QBChatMessage chatMessage) {
    MessageCache messageCache = parseReceivedMessage(chatMessage);
    messageCache.setFriendsNotificationType(FriendsNotificationType.REQUEST);
    saveMessageToCache(messageCache);
}

Output:
     MessageCache messageCache = parseReceivedMessage(chatMessage);
-    messageCache.setFriendsNotificationType(FriendsNotificationType.REQUEST);
+    messageCache.setFriendsNotificationType(type);
     saveMessageToCache(messageCache);


Input:
ArrayList<Prediction> classify(int sequenceType, float[] vector) {
    ArrayList<Prediction> predictions = new ArrayList<Prediction>();
    ArrayList<Instance> instances = getInstances();
    int count = instances.size();
    TreeMap<String, Double> label2score = new TreeMap<String, Double>();
    for (int i = 0; i < count; i++) {
        Instance sample = instances.get(i);
        if (sample.vector.length != vector.length) {
            continue;
        }
        double distance;
        if (sequenceType == GestureLibrary.SEQUENCE_SENSITIVE) {
            distance = GestureUtilities.cosineDistance(sample.vector, vector);
        } else {
            distance = GestureUtilities.squaredEuclideanDistance(sample.vector, vector);
        }
        double weight;
        if (distance == 0) {
            weight = Double.MAX_VALUE;
        } else {
            weight = 1 / distance;
        }
        Double score = label2score.get(sample.label);
        if (score == null || weight > score) {
            label2score.put(sample.label, weight);
        }
    }
    double sum = 0;
    for (String name : label2score.keySet()) {
        double score = label2score.get(name);
        sum += score;
        predictions.add(new Prediction(name, score));
    }
    for (Prediction prediction : predictions) {
        prediction.score /= sum;
    }
    Collections.sort(predictions, new Comparator<Prediction>() {
        public int compare(Prediction object1, Prediction object2) {
            double score1 = object1.score;
            double score2 = object2.score;
            if (score1 > score2) {
                return -1;
            } else if (score1 < score2) {
                return 1;
            } else {
                return 0;
            }
        }
    });
    return predictions;
}

Output:
         double distance;
-        if (sequenceType == GestureLibrary.SEQUENCE_SENSITIVE) {
+        if (gestureType == GestureLibrary.SEQUENCE_SENSITIVE) {
             distance = GestureUtilities.cosineDistance(sample.vector, vector);


Input:
public void testMakeCQLforDelete() throws CQLGenerationException, CObjectParseException, IOException {
    Subject s = new Subject();
    s.testMakeCQLforDelete();
}

Output:
 public void testMakeCQLforDelete() throws CQLGenerationException, CObjectParseException, IOException {
-    Subject s = new Subject();
+    Subject s = new Subject(0);
     s.testMakeCQLforDelete();


Input:
private static Repository createRepository(MongoConnection connection) {
    DocumentNodeStore store = new DocumentMK.Builder().setClusterId(1).memoryCacheSize(64 * 1024 * 1024).setPersistentCache("String_Node_Str").setMongoDB(connection.getDB()).getNodeStore();
    QueryEngineSettings qs = new QueryEngineSettings();
    qs.setFullTextComparisonWithoutIndex(true);
    return new Jcr(store).with(qs).createRepository();
}

Output:
 private static Repository createRepository(MongoConnection connection) {
-    DocumentNodeStore store = new DocumentMK.Builder().setClusterId(1).memoryCacheSize(64 * 1024 * 1024).setPersistentCache("String_Node_Str").setMongoDB(connection.getDB()).getNodeStore();
+    DocumentNodeStore store = new DocumentMK.Builder().memoryCacheSize(64 * 1024 * 1024).setPersistentCache("String_Node_Str").setMongoDB(connection.getDB()).getNodeStore();
     QueryEngineSettings qs = new QueryEngineSettings();


Input:
private void processAttachAction(Node action, TaxonStore target, String targetRootStr, String targetPrefixStr) {
    List<String> columns = (List<String>) Collections.EMPTY_LIST;
    Map<Integer, String> synPrefixes = new HashMap<Integer, String>();
    final String formatStr = getAttribute(action, ATTACHFORMATSTR);
    final String cladeRootStr = getAttribute(action, ATTACHROOTSTR);
    final String sourceParentStr = getAttribute(action, ATTACHPARENTSTR);
    final String sourcePrefixStr = getAttribute(action, ATTACHPREFIXSTR);
    NodeList childNodes = action.getChildNodes();
    if (childNodes.getLength() > 0) {
        columns = processChildNodesOfAttach(childNodes, synPrefixes);
    }
    Merger m = getMerger(formatStr, columns, synPrefixes);
    if (!m.canAttach()) {
        throw new RuntimeException("String_Node_Str" + formatStr + "String_Node_Str");
    }
    if (!m.canPreserveID() && (sourcePrefixStr != null) && (!sourcePrefixStr.equals(targetPrefixStr))) {
        throw new RuntimeException("String_Node_Str" + formatStr + "String_Node_Str");
    }
    String sourceURLStr = action.getAttributes().getNamedItem("String_Node_Str").getNodeValue();
    File sourceFile = getSourceFile(sourceURLStr);
    logger.info("String_Node_Str" + sourceURLStr);
    if (targetPrefixStr == null) {
        logger.warn("String_Node_Str");
        targetPrefixStr = sourceFile.getName();
    }
    m.setSource(sourceFile);
    m.setTarget(target);
    if (sourceParentStr != null) {
        if (cladeRootStr != null)
            m.attach(sourceParentStr, cladeRootStr, targetPrefixStr);
        else
            m.attach(sourceParentStr, sourceParentStr, targetPrefixStr);
    } else {
        if (cladeRootStr != null)
            m.attach(targetRootStr, cladeRootStr, targetPrefixStr);
        else
            m.attach(targetRootStr, targetRootStr, targetPrefixStr);
    }
}

Output:
         if (cladeRootStr != null)
-            m.attach(sourceParentStr, cladeRootStr, targetPrefixStr);
+            m.attach(sourceParentStr, cladeRootStr, sourcePrefixStr);
         else


Input:
public final PostAggItem postAggJavascriptDef() throws RecognitionException {
    PostAggItem postAggItem = null;
    Token str = null;
    postAggItem = new PostAggItem("String_Node_Str");
    try {
        {
            match(input, JAVASCRIPT, FOLLOW_JAVASCRIPT_in_postAggJavascriptDef2355);
            int alt133 = 2;
            int LA133_0 = input.LA(1);
            if ((LA133_0 == WS)) {
                alt133 = 1;
            }
            switch(alt133) {
                case 1:
                    {
                        match(input, WS, FOLLOW_WS_in_postAggJavascriptDef2357);
                    }
                    break;
            }
            str = (Token) match(input, SINGLE_QUOTE_STRING, FOLLOW_SINGLE_QUOTE_STRING_in_postAggJavascriptDef2362);
            postAggItem.parseToJs((str != null ? str.getText() : null));
        }
    } catch (RecognitionException re) {
        reportError(re);
        recover(input, re);
    } finally {
    }
    return postAggItem;
}

Output:
         {
-            match(input, JAVASCRIPT, FOLLOW_JAVASCRIPT_in_postAggJavascriptDef2355);
-            int alt133 = 2;
-            int LA133_0 = input.LA(1);
-            if ((LA133_0 == WS)) {
-                alt133 = 1;
+            match(input, JAVASCRIPT, FOLLOW_JAVASCRIPT_in_postAggJavascriptDef2386);
+            int alt134 = 2;
+            int LA134_0 = input.LA(1);
+            if ((LA134_0 == WS)) {
+                alt134 = 1;
             }


Input:
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || getClass() != o.getClass())
        return false;
    ImmutableBlockLocation that = (ImmutableBlockLocation) o;
    if (x != that.x)
        return false;
    if (y != that.y)
        return false;
    if (z != that.z)
        return false;
    return true;
}

Output:
 public boolean equals(Object o) {
-    if (this == o)
+    if (this == o) {
         return true;


Input:
public List<Integer> getModelNumbers() {
    List<Integer> models = new ArrayList<Integer>(clusterIds.size());
    for (int c = 0; c < clusters.size(); c++) {
        for (int s = 0; s < clusters.get(c).size(); s++) {
            Atom[] atoms = clusters.get(c).getAlignedAtomsSubunit(s);
            Chain chain = atoms[0].getGroup().getChain();
            int model = 0;
            for (int m = 0; m < chain.getStructure().nrModels(); m++) {
                if (chain.getStructure().getModel(m).contains(chain)) {
                    model = m;
                    break;
                }
            }
            models.add(model);
        }
    }
    return models;
}

Output:
 public List<Integer> getModelNumbers() {
-    List<Integer> models = new ArrayList<Integer>(clusterIds.size());
+    List<Integer> models = new ArrayList<Integer>(getSubunitCount());
     for (int c = 0; c < clusters.size(); c++) {


Input:
public boolean apply(Game game, Ability source) {
    Permanent permanent = game.getPermanent(source.getSourceId());
    if (permanent != null) {
        if (counter != null) {
            Counter newCounter = counter.copy();
            newCounter.add(amount.calculate(game, source));
            permanent.addCounters(counter.copy(), game);
            if (informPlayers) {
                Player player = game.getPlayer(source.getControllerId());
                if (player != null) {
                    game.informPlayers(player.getName() + "String_Node_Str" + newCounter.getCount() + "String_Node_Str" + newCounter.getName() + "String_Node_Str" + permanent.getName());
                }
            }
        }
    }
    return true;
}

Output:
             newCounter.add(amount.calculate(game, source));
-            permanent.addCounters(counter.copy(), game);
+            permanent.addCounters(newCounter, game);
             if (informPlayers) {


Input:
public static void checkValidAndMinMaxDate(String dateString, Date minValue, Date maxValue, String fieldName, ValidationResult validationResult) {
    if (StringUtils.isEmpty(dateString)) {
        return;
    }
    Date dateValue = DateUtil.parseUTC(dateString);
    if (null == dateValue) {
        validationResult.addError(UpdateValidationError.build4008Error(fieldName));
        return;
    }
    checkMinMaxDate(dateValue, minValue, maxValue, fieldName, validationResult);
}

Output:
     if (null == dateValue) {
-        validationResult.addError(UpdateValidationError.build4008Error(fieldName));
+        validationResult.addError(UpdateValidationError.build4007Error(fieldName));
         return;


Input:
protected double calculateAverageThroughput() {
    int throughputSum = 0;
    double mean;
    for (Integer tp : throughputCollection) {
        throughputSum += tp;
    }
    if (throughputCollection.size() == 0)
        mean = 0;
    else
        mean = throughputSum / throughputCollection.size();
    throughputCollection.clear();
    return mean;
}

Output:
     if (throughputCollection.size() == 0)
-        mean = 0;
+        return previousTP;
     else


Input:
private void createIndexObjectMemoryEfficient() {
    StopWatch global = new StopWatch();
    StopWatch st = new StopWatch();
    SequenceLog64 objectCount = new SequenceLog64(BitUtil.log2(seqZ.getNumberOfElements()));
    long maxCount = 0;
    for (long i = 0; i < seqZ.getNumberOfElements(); i++) {
        long val = seqZ.get(i);
        if (val == 0) {
            throw new RuntimeException("String_Node_Str");
        }
        if (objectCount.getNumberOfElements() < val) {
            objectCount.resize(val);
        }
        long count = objectCount.get(val - 1) + 1;
        maxCount = count > maxCount ? count : maxCount;
        objectCount.set(val - 1, count);
    }
    System.out.println("String_Node_Str" + st.stopAndShow() + "String_Node_Str" + maxCount);
    st.reset();
    Bitmap375 bitmapIndex = new Bitmap375(seqZ.getNumberOfElements());
    long tmpCount = 0;
    for (long i = 0; i < objectCount.getNumberOfElements(); i++) {
        tmpCount += objectCount.get(i);
        bitmapIndex.set(tmpCount - 1, true);
    }
    bitmapIndex.set(seqZ.getNumberOfElements() - 1, true);
    System.out.println("String_Node_Str" + st.stopAndShow());
    objectCount = null;
    st.reset();
    SequenceLog64 objectInsertedCount = new SequenceLog64(BitUtil.log2(maxCount), bitmapIndex.countOnes());
    objectInsertedCount.resize(bitmapIndex.countOnes());
    SequenceLog64 objectArray = new SequenceLog64(BitUtil.log2(seqY.getNumberOfElements()), seqZ.getNumberOfElements());
    objectArray.resize(seqZ.getNumberOfElements());
    for (long i = 0; i < seqZ.getNumberOfElements(); i++) {
        long objectValue = seqZ.get(i);
        long posY = i > 0 ? bitmapZ.rank1(i - 1) : 0;
        long insertBase = objectValue == 1 ? 0 : bitmapIndex.select1(objectValue - 1) + 1;
        long insertOffset = objectInsertedCount.get(objectValue - 1);
        objectInsertedCount.set(objectValue - 1, insertOffset + 1);
        objectArray.set(insertBase + insertOffset, posY);
    }
    System.out.println("String_Node_Str" + st.stopAndShow());
    objectInsertedCount = null;
    st.reset();
    long object = 1;
    long first = 0;
    long last = bitmapIndex.select1(object) + 1;
    do {
        long listLen = last - first;
        if (listLen == 2) {
            long aPos = objectArray.get(first);
            long a = seqY.get(aPos);
            long bPos = objectArray.get(last);
            long b = seqY.get(bPos);
            if (a > b) {
                objectArray.set(first, bPos);
                objectArray.set(last, aPos);
            }
        } else if (listLen > 2) {
            class Pair {
                int valueY;
                int positionY;
            }
            ;
            ArrayList<Pair> list = new ArrayList<Pair>((int) listLen);
            for (long i = first; i < last; i++) {
                Pair p = new Pair();
                p.positionY = (int) objectArray.get(i);
                p.valueY = (int) seqY.get(p.positionY);
                list.add(p);
            }
            Collections.sort(list, new Comparator<Pair>() {
                public int compare(Pair o1, Pair o2) {
                    if (o1.valueY == o2.valueY) {
                        return o1.positionY - o2.positionY;
                    }
                    return o1.valueY - o2.valueY;
                }
            });
            for (long i = first; i < last; i++) {
                objectArray.set(i, list.get((int) (i - first)).positionY);
            }
        }
        first = last;
        last = bitmapIndex.select1(object) + 1;
        object++;
    } while (object <= bitmapIndex.countOnes());
    System.out.println("String_Node_Str" + st.stopAndShow());
    st.reset();
    SequenceLog64 predCount = new SequenceLog64(BitUtil.log2(seqY.getNumberOfElements()));
    for (long i = 0; i < seqY.getNumberOfElements(); i++) {
        long val = seqY.get(i);
        if (predCount.getNumberOfElements() < val) {
            predCount.resize(val);
        }
        predCount.set(val - 1, predCount.get(val - 1) + 1);
    }
    predCount.trimToSize();
    System.out.println("String_Node_Str" + st.stopAndShow());
    this.predicateCount = predCount;
    st.reset();
    this.indexZ = objectArray;
    this.bitmapIndexZ = bitmapIndex;
    this.adjIndex = new AdjacencyList(this.indexZ, this.bitmapIndexZ);
    System.out.println("String_Node_Str" + global.stopAndShow());
}

Output:
             long a = seqY.get(aPos);
-            long bPos = objectArray.get(last);
+            long bPos = objectArray.get(first + 1);
             long b = seqY.get(bPos);


Input:
public void testTopoSortWithBadInputs() {
    SimpleGraph deps = new SimpleGraph();
    try {
        Toposort.toposort(QLists.getList("String_Node_Str", "String_Node_Str"), "String_Node_Str", deps);
        fail();
    } catch (IllegalStateException e) {
    }
    try {
        Toposort.toposort(QLists.getList("String_Node_Str", "String_Node_Str", "String_Node_Str"), "String_Node_Str", deps);
        fail();
    } catch (IllegalStateException e) {
    }
}

Output:
     try {
-        Toposort.toposort(QLists.getList("String_Node_Str", "String_Node_Str"), "String_Node_Str", deps);
+        Toposort.toposort(QLists.getList("String_Node_Str", "String_Node_Str"), "String_Node_Str", deps, true);
         fail();


Input:
public void setEntryTextOpenDetailsPage(final StatsPostModel currentItem) {
    if (entryTextView == null) {
        return;
    }
    String name = StringEscapeUtils.unescapeHtml(currentItem.getTitle());
    entryTextView.setText(name);
    rowContent.setOnClickListener(new View.OnClickListener() {
        public void onClick(View view) {
            ActivityLauncher.viewStatsSinglePostDetails(view.getContext(), currentItem);
        }
    });
    entryTextView.setTextColor(entryTextView.getContext().getResources().getColor(R.color.stats_link_text_color));
}

Output:
     }
-    String name = StringEscapeUtils.unescapeHtml(currentItem.getTitle());
+    String name = StringEscapeUtils.unescapeHtml4(currentItem.getTitle());
     entryTextView.setText(name);


Input:
public void run(ProgressStatus progressStatus) {
    if (progressStatus == null) {
        progressStatus = EmptyProgressStatus.getDefault();
    }
    progressStatus.setDescription("String_Node_Str");
    progressStatus.setIndeterminate(true);
    if (clientElements == null) {
        clientElements = new LinkedList<>();
    }
    Map<String, Pair<Element, ObjectNode>> clientElementMap = clientElements.stream().collect(Collectors.toMap(pair -> Converters.getElementToIdConverter().apply(pair.getKey()), Function.identity()));
    Set<String> processedElementIds = new HashSet<>();
    JsonToken current = null;
    for (File responseFile : serverElementFiles) {
        try (JsonParser jsonParser = JacksonUtils.getJsonFactory().createParser(responseFile)) {
            current = (jsonParser.getCurrentToken() == null ? jsonParser.nextToken() : jsonParser.getCurrentToken());
            if (current != JsonToken.START_OBJECT) {
                throw new IOException("String_Node_Str");
            }
            while (current != JsonToken.END_OBJECT) {
                current = jsonParser.nextToken();
                String keyName;
                if (current != null && (keyName = jsonParser.getCurrentName()) != null && keyName.equals("String_Node_Str") && (current = jsonParser.nextToken()) == JsonToken.START_ARRAY) {
                    current = jsonParser.nextToken();
                    JsonNode value;
                    while (current != JsonToken.END_ARRAY) {
                        if (current == JsonToken.START_OBJECT) {
                            String id;
                            ObjectNode currentServerElement = JacksonUtils.parseJsonObject(jsonParser);
                            if ((value = currentServerElement.get(MDKConstants.ID_KEY)) != null && value.isTextual() && !processedElementIds.contains(id = value.asText())) {
                                processedElementIds.add(id);
                                Pair<Element, ObjectNode> currentClientElement = clientElementMap.remove(id);
                                if (currentClientElement == null) {
                                    addMissingInClientViolation(currentServerElement);
                                } else {
                                    addElementEquivalenceViolation(currentClientElement, currentServerElement);
                                }
                            }
                        }
                    }
                }
            }
        } catch (IOException e) {
        }
    }
    if (serverElements == null) {
        serverElements = new LinkedList<>();
    }
    Map<String, ObjectNode> serverElementMap = serverElements.stream().filter(json -> json.has(MDKConstants.ID_KEY) && json.get(MDKConstants.ID_KEY).isTextual()).filter(json -> !processedElementIds.contains(json.get(MDKConstants.ID_KEY).asText())).collect(Collectors.toMap(json -> json.get(MDKConstants.ID_KEY).asText(), Function.identity()));
    LinkedHashSet<String> elementKeySet = new LinkedHashSet<>();
    elementKeySet.addAll(clientElementMap.keySet());
    elementKeySet.addAll(serverElementMap.keySet());
    progressStatus.setDescription("String_Node_Str" + elementKeySet.size() + "String_Node_Str" + (elementKeySet.size() != 1 ? "String_Node_Str" : "String_Node_Str"));
    progressStatus.setIndeterminate(false);
    progressStatus.setMax(elementKeySet.size());
    progressStatus.setCurrent(0);
    for (String id : elementKeySet) {
        Pair<Element, ObjectNode> clientElement = clientElementMap.get(id);
        ObjectNode serverElement = serverElementMap.get(id);
        if ((clientElement == null || clientElement.getKey() == null) && serverElement == null) {
            continue;
        } else if (clientElement == null) {
            addMissingInClientViolation(serverElement);
        } else if (serverElement == null) {
            addMissingOnMmsViolation(clientElement);
        } else {
            addElementEquivalenceViolation(clientElement, serverElement);
        }
        progressStatus.increase();
    }
    Application.getInstance().getGUILog().log("String_Node_Str" + validationSuite.getName() + "String_Node_Str");
    Application.getInstance().getGUILog().log("String_Node_Str" + NumberFormat.getInstance().format(missingInClientCount) + "String_Node_Str" + (missingInClientCount != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    Application.getInstance().getGUILog().log("String_Node_Str" + NumberFormat.getInstance().format(missingOnMmsCount) + "String_Node_Str" + (missingOnMmsCount != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    Application.getInstance().getGUILog().log("String_Node_Str" + NumberFormat.getInstance().format(notEquivalentCount) + "String_Node_Str" + (notEquivalentCount != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    Application.getInstance().getGUILog().log("String_Node_Str" + validationSuite.getName() + "String_Node_Str");
}

Output:
     }
-    Map<String, Pair<Element, ObjectNode>> clientElementMap = clientElements.stream().collect(Collectors.toMap(pair -> Converters.getElementToIdConverter().apply(pair.getKey()), Function.identity()));
+    Map<String, Pair<Element, ObjectNode>> clientElementMap = clientElements.stream().collect(Collectors.toMap(pair -> Converters.getElementToIdConverter().apply(pair.getKey()), Function.identity(), (s, a) -> a));
     Set<String> processedElementIds = new HashSet<>();


Input:
private String getFileFromClassPath(String filename) {
    InputStream in = null;
    try {
        in = getClass().getClassLoader().getResourceAsStream(filename);
        try {
            if (in == null) {
                err.println("String_Node_Str" + filename);
                System.exit(-1);
            }
            StringWriter sw = new StringWriter();
            int ch;
            while ((ch = in.read()) != -1) {
                sw.write(ch);
            }
            return sw.toString();
        } finally {
            if (in != null) {
                in.close();
            }
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

Output:
             if (in == null) {
-                err.println("String_Node_Str" + filename);
-                System.exit(-1);
+                throw new RuntimeException("String_Node_Str" + filename);
             }


Input:
private void relabelGraphs2MultisetLabels(List<DirectedMultigraphWithRoot<Vertex<StringBuffer>, Edge<StringBuffer>>> graphs, int startLabel, int currentLabel) {
    Map<String, Bucket<Vertex<StringBuffer>>> bucketsV = new HashMap<String, Bucket<Vertex<StringBuffer>>>();
    Map<String, Bucket<Edge<StringBuffer>>> bucketsE = new HashMap<String, Bucket<Edge<StringBuffer>>>();
    for (int i = startLabel; i < currentLabel; i++) {
        bucketsV.put(Integer.toString(i), new Bucket<Vertex<StringBuffer>>(Integer.toString(i)));
        bucketsE.put(Integer.toString(i), new Bucket<Edge<StringBuffer>>(Integer.toString(i)));
    }
    for (DirectedGraph<Vertex<StringBuffer>, Edge<StringBuffer>> graph : graphs) {
        for (Edge<StringBuffer> edge : graph.getEdges()) {
            bucketsV.get(edge.getLabel()).getContents().add(graph.getDest(edge));
        }
        for (Vertex<StringBuffer> vertex : graph.getVertices()) {
            Collection<Edge<StringBuffer>> v2 = graph.getOutEdges(vertex);
            bucketsE.get(vertex.getLabel()).getContents().addAll(v2);
        }
    }
    for (DirectedGraph<Vertex<StringBuffer>, Edge<StringBuffer>> graph : graphs) {
        for (Edge<StringBuffer> edge : graph.getEdges()) {
            edge.setLabel(edge.getLabel().append("String_Node_Str"));
        }
        for (Vertex<StringBuffer> vertex : graph.getVertices()) {
            vertex.setLabel(vertex.getLabel().append("String_Node_Str"));
        }
    }
    for (int i = startLabel; i < currentLabel; i++) {
        Bucket<Vertex<StringBuffer>> bucketV = bucketsV.get(Integer.toString(i));
        for (Vertex<StringBuffer> vertex : bucketV.getContents()) {
            vertex.getLabel().append(bucketV.getLabel());
        }
        Bucket<Edge<StringBuffer>> bucketE = bucketsE.get(Integer.toString(i));
        for (Edge<StringBuffer> edge : bucketE.getContents()) {
            edge.getLabel().append(bucketE.getLabel());
        }
    }
}

Output:
     }
-    for (DirectedGraph<Vertex<StringBuffer>, Edge<StringBuffer>> graph : graphs) {
+    for (DirectedMultigraphWithRoot<Vertex<StringBuffer>, Edge<StringBuffer>> graph : graphs) {
         for (Edge<StringBuffer> edge : graph.getEdges()) {


Input:
private void findPerfHolePoints(RenderedImage img) {
    perfBorderX = new int[img.getHeight()];
    Rectangle perfArea = new Rectangle(0, 0, img.getWidth() / 4, img.getHeight());
    RectIter iter = RectIterFactory.create(img, perfArea);
    SampleModel sm = img.getSampleModel();
    int nbands = sm.getNumBands();
    int[] pixel = new int[nbands];
    int perfPixelCount = 0;
    int x = 0, y = -1;
    int perfStartY = -1;
    int perfEndY = -1;
    boolean isPerforation = false;
    int linesToDecide = -1;
    int[] lastLines = new int[MEDIAN_WINDOW];
    int n = 0;
    System.out.println("String_Node_Str");
    while (!iter.nextLineDone()) {
        y++;
        int pixelsInLine = 0;
        perfBorderX[y] = 0;
        x = 0;
        iter.startPixels();
        while (!iter.nextPixelDone()) {
            iter.getPixel(pixel);
            if (pixel[0] > 0) {
                perfPixelCount++;
                pixelsInLine++;
            } else if (pixelsInLine > PERF_HOLE_THRESHOLD) {
                perfBorderX[y] = x;
                break;
            }
            x++;
        }
        lastLines[n] = pixelsInLine;
        n++;
        if (n >= MEDIAN_WINDOW) {
            n = 0;
        }
        int medianPixels = median(lastLines);
        if (y < MEDIAN_WINDOW) {
            continue;
        }
        if (isPerforation) {
            if (medianPixels < PERF_HOLE_THRESHOLD) {
                perfEndY = y - (MEDIAN_WINDOW >> 1);
                int perfCenterY = (perfEndY + perfStartY) >> 1;
                int perfCenterX = getFrameLeft(perfStartY, perfEndY);
                if (perfCenterX > 0) {
                    System.out.println(String.format("String_Node_Str", perfCenterX, perfCenterY));
                    perfY.add(perfCenterY);
                    perfX.add(perfCenterX);
                    int imageY = perfCenterY - 200;
                    imageY = Math.max(0, imageY);
                    saveDebugImage(maskImage, "String_Node_Str", 0, imageY, 300, Math.min(400, maskImage.getHeight() - imageY));
                }
                isPerforation = false;
            }
        } else {
            if (medianPixels > PERF_HOLE_THRESHOLD) {
                perfStartY = y - (MEDIAN_WINDOW >> 1);
                isPerforation = true;
            }
        }
    }
}

Output:
         if (isPerforation) {
-            if (medianPixels < PERF_HOLE_THRESHOLD) {
+            if (medianPixels <= PERF_HOLE_THRESHOLD) {
                 perfEndY = y - (MEDIAN_WINDOW >> 1);


Input:
public void projectClosed(Project project) {
    projectOpened(project);
}

Output:
 public void projectClosed(Project project) {
-    projectOpened(project);
+    updateSyncStatus();
 }


Input:
private IExecTestCasePO performExtraction(final String newTcName, final INodePO node, final IStructuredSelection selection) {
    final List<INodePO> modNodes = new ArrayList<INodePO>(selection.size());
    Iterator it = selection.iterator();
    while (it.hasNext()) {
        Object next = it.next();
        if (next instanceof INodePO) {
            modNodes.add((INodePO) next);
        }
    }
    if (modNodes.isEmpty()) {
        return null;
    }
    IExecTestCasePO exec = persistExtraction(node, newTcName, modNodes);
    DataEventDispatcher.getInstance().fireDataChangedListener(node, DataState.StructureModified, UpdateState.all);
    DataEventDispatcher.getInstance().fireDataChangedListener(exec, DataState.Added, UpdateState.all);
    final ISpecTestCasePO newSpecTc = exec.getSpecTestCase();
    DataEventDispatcher.getInstance().fireDataChangedListener(newSpecTc, DataState.Added, UpdateState.all);
    TestCaseBrowser tcb = MultipleTCBTracker.getInstance().getMainTCB();
    if (tcb != null) {
        tcb.getTreeViewer().setSelection(new StructuredSelection(exec), true);
    }
    return exec;
}

Output:
     DataEventDispatcher.getInstance().fireDataChangedListener(exec, DataState.Added, UpdateState.all);
-    final ISpecTestCasePO newSpecTc = exec.getSpecTestCase();
-    DataEventDispatcher.getInstance().fireDataChangedListener(newSpecTc, DataState.Added, UpdateState.all);
+    ISpecTestCasePO newSpecTC = exec.getSpecTestCase();
+    newSpecTC = GeneralStorage.getInstance().getMasterSession().find(newSpecTC.getClass(), newSpecTC.getId());
+    DataEventDispatcher.getInstance().fireDataChangedListener(newSpecTC, DataState.Added, UpdateState.all);
     TestCaseBrowser tcb = MultipleTCBTracker.getInstance().getMainTCB();


Input:
protected boolean canContain(Object target, Object transfer) {
    if (transfer instanceof DataSetHandle || transfer instanceof DataSourceHandle || transfer instanceof ParameterHandle || transfer instanceof ParameterGroupHandle || transfer instanceof CascadingParameterGroupHandle || transfer instanceof CubeHandle)
        return true;
    if (DNDUtil.handleValidateTargetCanContainMore(target, DNDUtil.getObjectLength(transfer))) {
        canContain = DNDUtil.handleValidateTargetCanContain(target, transfer, true);
        return canContain == DNDUtil.CONTAIN_THIS;
    }
    return false;
}

Output:
 protected boolean canContain(Object target, Object transfer) {
-    if (transfer instanceof DataSetHandle || transfer instanceof DataSourceHandle || transfer instanceof ParameterHandle || transfer instanceof ParameterGroupHandle || transfer instanceof CascadingParameterGroupHandle || transfer instanceof CubeHandle)
+    if (transfer instanceof DataSetHandle || transfer instanceof DataSourceHandle || transfer instanceof ParameterHandle || transfer instanceof ParameterGroupHandle || transfer instanceof CascadingParameterGroupHandle || transfer instanceof CubeHandle || transfer instanceof MasterPageHandle)
         return true;


Input:
public void render(Object glContext) {
    OpenGLContext context = (OpenGLContext) glContext;
    if (activeGir != null) {
        if (torescale) {
            torescale = false;
            tcm.clear();
        }
        GL2 gl = context.getGL().getGL2();
        updateFutures(gl);
        float zoom = context.getZoom();
        int width = context.getWidth();
        int height = context.getHeight();
        int x = context.getX();
        int y = context.getY();
        int xx = (int) (x + xpadding);
        int yy = (int) (y + ypadding);
        int max = maxnumberoftiles;
        Cache c = CacheManager.getCacheInstance(activeGir.getDisplayName(activeBand));
        gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE);
        if (zoom >= 1) {
            curlevel = (int) Math.sqrt(zoom + 1);
            for (int lll = maxlevels; (lll > curlevel - 1); lll--) {
                if (lll > maxlevels) {
                    break;
                }
                lll += increaseLevel;
                if (lll < 0) {
                    continue;
                }
                if (this.mylevel != curlevel) {
                    this.mylevel = curlevel;
                    poolExcutorService.shutdown();
                    poolExcutorService = new ThreadPoolExecutor(1, poolSize, 100, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
                }
                int w0 = xx / ((1 << lll) << 8);
                int h0 = yy / ((1 << lll) << 8);
                final String initfile = new StringBuffer("String_Node_Str").append((int) lll).append("String_Node_Str").append((activeGir instanceof TiledBufferedImage ? ((TiledBufferedImage) activeGir).getDescription() + "String_Node_Str" : "String_Node_Str")).toString();
                for (int k = 0; k < max; k++) {
                    for (int j = 0; j < max; j++) {
                        if (j + h0 < 0) {
                            continue;
                        }
                        for (int i = 0; i < max; i++) {
                            if (i + w0 < 0) {
                                continue;
                            }
                            if (arrayReadTilesOrder[i][j] == k) {
                                float ymin = (float) (((j + h0) * Constant.TILE_SIZE_DOUBLE * (1 << lll) - yy) / (height * zoom));
                                float ymax = (float) (((j + h0 + 1) * Constant.TILE_SIZE_DOUBLE * (1 << lll) - yy) / (height * zoom));
                                float xmin = (float) (((i + w0) * Constant.TILE_SIZE_DOUBLE * (1 << lll) - xx) / (1d * width * zoom));
                                float xmax = (float) (((i + w0 + 1) * Constant.TILE_SIZE_DOUBLE * (1 << lll) - xx) / (1d * width * zoom));
                                if (ymin > 1 || ymax < 0) {
                                    continue;
                                }
                                if (xmin > 1 || xmax < 0) {
                                    continue;
                                }
                                final String file = new StringBuffer("String_Node_Str" + lll + "String_Node_Str").append(getBandFolder(activeBand)).append("String_Node_Str").append((i + w0)).append("String_Node_Str").append((j + h0)).append("String_Node_Str").toString();
                                final File f = c.newFile(file);
                                if (!tryMemoryCache(gl, f.getAbsolutePath(), lll, (i + w0), (j + h0), xmin, xmax, ymin, ymax)) {
                                    if (!tryFileCache(gl, f, lll, (i + w0), (j + h0), xmin, xmax, ymin, ymax)) {
                                        if (curlevel == 0 && lll == 0) {
                                            addTileToQueue(f, lll, (i + w0), (j + h0));
                                        } else if (curlevel == lll) {
                                            addTileToQueue(f, lll, (i + w0), (j + h0));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } else if (zoom > 0) {
            curlevel = 0;
            int w0 = xx / Constant.TILE_SIZE_IMG_LAYER;
            int h0 = yy / Constant.TILE_SIZE_IMG_LAYER;
            final String initfile = new StringBuilder(c.getPath().toString()).append("String_Node_Str").append((activeGir instanceof TiledBufferedImage ? ((TiledBufferedImage) activeGir).getDescription() + "String_Node_Str" : "String_Node_Str")).toString();
            for (int j = 0; j < max; j++) {
                if (j + h0 < 0) {
                    continue;
                }
                for (int i = 0; i < max; i++) {
                    if (i + w0 < 0) {
                        continue;
                    }
                    float ymin = (float) (((j + h0) * Constant.OVERVIEW_SIZE_DOUBLE - yy) / (height * zoom));
                    float ymax = (float) (((j + h0 + 1) * Constant.OVERVIEW_SIZE_DOUBLE - yy) / (height * zoom));
                    float xmin = (float) (((i + w0) * Constant.OVERVIEW_SIZE_DOUBLE - xx) / (1d * width * zoom));
                    float xmax = (float) (((i + w0 + 1) * Constant.OVERVIEW_SIZE_DOUBLE - xx) / (1d * width * zoom));
                    if (ymin > 1 || ymax < 0) {
                        continue;
                    }
                    if (xmin > 1 || xmax < 0) {
                        continue;
                    }
                    String file = new StringBuilder("String_Node_Str").append(getBandFolder(activeBand)).append("String_Node_Str").append((i + w0)).append("String_Node_Str").append((j + h0)).append("String_Node_Str").toString();
                    final File f = c.newFile(file);
                    if (!tryMemoryCache(gl, f.getAbsolutePath(), 0, (i + w0), (j + h0), xmin, xmax, ymin, ymax)) {
                        if (!tryFileCache(gl, f, 0, (i + w0), (j + h0), xmin, xmax, ymin, ymax)) {
                            addTileToQueue(f, 0, (i + w0), (j + h0));
                        }
                    }
                }
            }
        }
        displayDownloading(futures.size());
        SumoPlatform.getApplication().refresh();
        if (this.disposed) {
            disposeSync();
        }
    }
}

Output:
         }
-        GL2 gl = context.getGL().getGL2();
+        GL gl = context.getGL();
         updateFutures(gl);


Input:
public boolean applies(GameEvent event, Ability source, Game game) {
    if (event.getType() == GameEvent.EventType.ENTERS_THE_BATTLEFIELD) {
        Permanent p = game.getPermanent(event.getTargetId());
        if (p != null && p.getCardType().contains(CardType.CREATURE)) {
            return true;
        }
    }
    return false;
}

Output:
     if (event.getType() == GameEvent.EventType.ENTERS_THE_BATTLEFIELD) {
-        Permanent p = game.getPermanent(event.getTargetId());
-        if (p != null && p.getCardType().contains(CardType.CREATURE)) {
+        Permanent permanent = ((EntersTheBattlefieldEvent) event).getTarget();
+        if (permanent != null && permanent.getCardType().contains(CardType.CREATURE)) {
+            game.getContinuousEffects().replaceEvent(event, game);
             return true;


Input:
public Event save(Event entity) {
    if (entity.getTypeSelect() == EventRepository.TYPE_MEETING) {
        super.save(entity);
        Beans.get(EventService.class).manageFollowers(entity);
    }
    User creator = entity.getCreatedBy();
    if (creator == null) {
        creator = AuthUtils.getUser();
    }
    if (entity.getOrganizer() == null && creator != null) {
        if (creator.getPartner() != null && creator.getPartner().getEmailAddress() != null) {
            String email = creator.getPartner().getEmailAddress().getAddress();
            ICalendarUser organizer = Beans.get(ICalendarUserRepository.class).all().filter("String_Node_Str", email, creator.getId()).fetchOne();
            if (organizer == null) {
                organizer = new ICalendarUser();
                organizer.setEmail(email);
                organizer.setName(creator.getFullName());
                organizer.setUser(creator);
            }
            entity.setOrganizer(organizer);
        }
    }
    entity.setSubjectTeam(entity.getSubject());
    if (entity.getVisibilitySelect() == ICalendarEventRepository.VISIBILITY_PRIVATE) {
        entity.setSubjectTeam(I18n.get("String_Node_Str"));
        if (entity.getDisponibilitySelect() == ICalendarEventRepository.DISPONIBILITY_BUSY) {
            entity.setSubjectTeam(I18n.get("String_Node_Str"));
        }
    }
    return super.save(entity);
}

Output:
             String email = creator.getPartner().getEmailAddress().getAddress();
-            ICalendarUser organizer = Beans.get(ICalendarUserRepository.class).all().filter("String_Node_Str", email, creator.getId()).fetchOne();
-            if (organizer == null) {
-                organizer = new ICalendarUser();
-                organizer.setEmail(email);
-                organizer.setName(creator.getFullName());
-                organizer.setUser(creator);
+            if (!Strings.isNullOrEmpty(email)) {
+                ICalendarUser organizer = Beans.get(ICalendarUserRepository.class).all().filter("String_Node_Str", email, creator.getId()).fetchOne();
+                if (organizer == null) {
+                    organizer = new ICalendarUser();
+                    organizer.setEmail(email);
+                    organizer.setName(creator.getFullName());
+                    organizer.setUser(creator);
+                }
+                entity.setOrganizer(organizer);
             }


Input:
public Site getTailSite() {
    if ((_tailPort == null) || !_tailPort.isMultiport()) {
        return super.getTailSite();
    }
    Site result = super.getTailSite();
    if (result instanceof PortConnectSite) {
        PortTerminal terminal = ((PortConnectSite) result).getTerminal();
        int orderIndex = terminal.getOrderIndex(this);
        if (orderIndex >= 0) {
            return new PortConnectSite(result.getFigure(), terminal, orderIndex + 1, result.getNormal());
        }
    }
    return result;
}

Output:
     if ((_tailPort == null) || !_tailPort.isMultiport()) {
-        return super.getTailSite();
+        return result;
     }


Input:
public IMap getStorageMap(String queueName) {
    QueueConfig config = node.factory.getConfig().getQueueConfig(queueName);
    return node.factory.getMap(config.getBackingMapName());
}

Output:
 public IMap getStorageMap(String queueName) {
-    QueueConfig config = node.factory.getConfig().getQueueConfig(queueName);
-    return node.factory.getMap(config.getBackingMapName());
+    return node.factory.getMap(queueName);
 }


Input:
public void checkFileSet(String fileSet, String browserId, PrintWriter writer) {
    Collection<FileInfo> clientFileSet = gson.fromJson(fileSet, new TypeToken<Collection<FileInfo>>() {
    }.getType());
    SlaveBrowser browser = capturedBrowsers.getBrowser(browserId);
    Set<FileInfo> browserFileSet = browser.getFileSet();
    Set<FileInfo> filesToRequest = new LinkedHashSet<FileInfo>();
    if (browserFileSet.isEmpty() || !clientFileSet.containsAll(browserFileSet)) {
        for (FileInfo info : clientFileSet) {
            filesToRequest.add(info);
        }
    } else {
        Set<FileInfo> diff = new LinkedHashSet<FileInfo>(clientFileSet);
        diff.removeAll(browserFileSet);
        for (FileInfo info : diff) {
            filesToRequest.add(info);
        }
        for (FileInfo browserFileInfo : browserFileSet) {
            for (FileInfo clientFileInfo : clientFileSet) {
                if (clientFileInfo.equals(browserFileInfo) && clientFileInfo.getTimestamp() > browserFileInfo.getTimestamp()) {
                    filesToRequest.add(clientFileInfo);
                    break;
                }
            }
        }
    }
    if (!filesToRequest.isEmpty()) {
        if (browser.getBrowserInfo().getName().contains("String_Node_Str") || browser.getBrowserInfo().getName().contains("String_Node_Str") || browser.getBrowserInfo().getName().contains("String_Node_Str")) {
            filesToRequest.clear();
            for (FileInfo info : clientFileSet) {
                filesToRequest.add(info);
            }
        }
        Set<FileInfo> filteredFilesToRequest = filterServeOnlyFiles(clientFileSet, filesToRequest);
        writer.write(gson.toJson(filteredFilesToRequest));
    }
    writer.flush();
}

Output:
         }
-        Set<FileInfo> filteredFilesToRequest = filterServeOnlyFiles(clientFileSet, filesToRequest);
+        Set<FileInfo> filteredFilesToRequest = filterServeOnlyFiles(filesToRequest);
         writer.write(gson.toJson(filteredFilesToRequest));


Input:
public boolean shouldUpdateFragmentOnErrorEvent(StatsEvents.SectionUpdateError errorEvent) {
    StatsEvents.SectionUpdatedAbstract abstractEvent = errorEvent;
    if (!shouldUpdateFragmentOnUpdateEvent(abstractEvent)) {
        return false;
    }
    StatsService.StatsEndpointsEnum sectionToUpdate = errorEvent.mEndPointName;
    StatsService.StatsEndpointsEnum[] sectionsToUpdate = getSectionsToUpdate();
    int indexOfDatamodelMatch = -1;
    for (int i = 0; i < getSectionsToUpdate().length; i++) {
        if (sectionToUpdate == sectionsToUpdate[i]) {
            indexOfDatamodelMatch = i;
            break;
        }
    }
    if (-1 == indexOfDatamodelMatch) {
        return false;
    }
    return true;
}

Output:
 public boolean shouldUpdateFragmentOnErrorEvent(StatsEvents.SectionUpdateError errorEvent) {
-    StatsEvents.SectionUpdatedAbstract abstractEvent = errorEvent;
-    if (!shouldUpdateFragmentOnUpdateEvent(abstractEvent)) {
+    if (!shouldUpdateFragmentOnUpdateEvent(errorEvent)) {
         return false;


Input:
public void onDisguiseEvent(DisguiseEvent e) {
    if (e.isCancelled()) {
        return;
    }
    FPlayer fplayer = FPlayers.i.get(e.getPlayer());
    if (Config._extras._disguise.unDisguiseIfInEnemyTerritory._) {
        if (fplayer.isInEnemyTerritory()) {
            MobDisguiseAPI.undisguisePlayer(e.getPlayer());
            e.getPlayer().sendMessage("String_Node_Str");
            e.setCancelled(true);
        }
    }
    if (Config._extras._disguise.unDisguiseIfInOwnTerritory._) {
        if (fplayer.isInOwnTerritory()) {
            MobDisguiseAPI.undisguisePlayer(e.getPlayer());
            e.getPlayer().sendMessage("String_Node_Str");
            e.setCancelled(true);
        }
    }
}

Output:
             MobDisguiseAPI.undisguisePlayer(e.getPlayer());
-            e.getPlayer().sendMessage("String_Node_Str");
+            e.getPlayer().sendMessage(ChatColor.RED + "String_Node_Str");
             e.setCancelled(true);


Input:
private void modifySourceMemberAccessesInTargetClass(MethodDeclaration newMethodDeclaration) {
    ExpressionExtractor extractor = new ExpressionExtractor();
    List<Expression> sourceMethodInvocations = extractor.getMethodInvocations(sourceMethod.getBody());
    List<Expression> newMethodInvocations = extractor.getMethodInvocations(newMethodDeclaration.getBody());
    List<Expression> expressionsToBeRemoved = new ArrayList<Expression>();
    for (MethodInvocation methodInvocation : additionalMethodsToBeMoved.keySet()) {
        for (Expression expression : sourceMethodInvocations) {
            if (expression instanceof MethodInvocation) {
                MethodInvocation sourceMethodInvocation = (MethodInvocation) expression;
                if (methodInvocation.equals(sourceMethodInvocation)) {
                    expressionsToBeRemoved.add(methodInvocation);
                }
            }
        }
    }
    for (Expression expression : expressionsToBeRemoved) {
        int index = sourceMethodInvocations.indexOf(expression);
        sourceMethodInvocations.remove(index);
        newMethodInvocations.remove(index);
    }
    expressionsToBeRemoved.clear();
    int k = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            ITypeBinding methodInvocationDeclaringClassTypeBinding = methodInvocation.resolveMethodBinding().getDeclaringClass();
            if (methodInvocationDeclaringClassTypeBinding.isEqualTo(sourceTypeDeclaration.resolveBinding()) && (methodInvocation.getExpression() == null || methodInvocation.getExpression() instanceof ThisExpression)) {
                MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                    if (sourceMethodDeclaration.resolveBinding().isEqualTo(methodInvocation.resolveMethodBinding())) {
                        MethodInvocation delegation = isDelegate(sourceMethodDeclaration);
                        if (delegation != null) {
                            ITypeBinding delegationDeclaringClassTypeBinding = delegation.resolveMethodBinding().getDeclaringClass();
                            if (delegationDeclaringClassTypeBinding.isEqualTo(targetTypeDeclaration.resolveBinding())) {
                                if (delegation.getExpression() != null) {
                                    MethodInvocation newMethodInvocation = (MethodInvocation) ASTNode.copySubtree(newMethodDeclaration.getAST(), delegation);
                                    targetRewriter.remove(newMethodInvocation.getExpression(), null);
                                    targetRewriter.replace(newMethodInvocations.get(k), newMethodInvocation, null);
                                }
                                expressionsToBeRemoved.add(methodInvocation);
                            }
                        }
                    }
                }
            } else if (methodInvocationDeclaringClassTypeBinding.isEqualTo(targetTypeDeclaration.resolveBinding()) && methodInvocation.getExpression() != null) {
                Expression methodInvocationExpression = methodInvocation.getExpression();
                if (methodInvocationExpression instanceof MethodInvocation) {
                    MethodInvocation invoker = (MethodInvocation) methodInvocationExpression;
                    if (invoker.getExpression() == null || invoker.getExpression() instanceof ThisExpression) {
                        MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                        for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                            if (sourceMethodDeclaration.resolveBinding().isEqualTo(invoker.resolveMethodBinding())) {
                                SimpleName fieldInstruction = isGetter(sourceMethodDeclaration);
                                if (fieldInstruction != null && fieldInstruction.resolveTypeBinding().isEqualTo(targetTypeDeclaration.resolveBinding())) {
                                    int index = sourceMethodInvocations.indexOf(invoker);
                                    targetRewriter.remove(newMethodInvocations.get(index), null);
                                    expressionsToBeRemoved.add(invoker);
                                    expressionsToBeRemoved.add(methodInvocation);
                                }
                            }
                        }
                    }
                }
            }
        }
        k++;
    }
    for (Expression expression : expressionsToBeRemoved) {
        int index = sourceMethodInvocations.indexOf(expression);
        sourceMethodInvocations.remove(index);
        newMethodInvocations.remove(index);
    }
    List<Expression> sourceFieldInstructions = extractor.getVariableInstructions(sourceMethod.getBody());
    List<Expression> newFieldInstructions = extractor.getVariableInstructions(newMethodDeclaration.getBody());
    int i = 0;
    for (Expression expression : sourceFieldInstructions) {
        SimpleName simpleName = (SimpleName) expression;
        IBinding binding = simpleName.resolveBinding();
        if (binding.getKind() == IBinding.VARIABLE) {
            IVariableBinding variableBinding = (IVariableBinding) binding;
            if (variableBinding.isField() && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
                if (sourceTypeDeclaration.resolveBinding().isEqualTo(variableBinding.getDeclaringClass())) {
                    SimpleName expressionName = (SimpleName) newFieldInstructions.get(i);
                    if (expressionName.getParent() instanceof FieldAccess) {
                        FieldAccess fieldAccess = (FieldAccess) expressionName.getParent();
                        if (fieldAccess.getExpression() instanceof ThisExpression && !expressionName.getIdentifier().equals(targetClassVariableName)) {
                            targetRewriter.replace(expressionName.getParent(), expressionName, null);
                            if (!additionalArgumentsAddedToMovedMethod.contains(expressionName.getIdentifier()))
                                addParameterToMovedMethod(newMethodDeclaration, expressionName);
                        }
                    } else if (!expressionName.getIdentifier().equals(targetClassVariableName) && !additionalArgumentsAddedToMovedMethod.contains(expressionName.getIdentifier()))
                        addParameterToMovedMethod(newMethodDeclaration, expressionName);
                } else {
                    Type superclassType = sourceTypeDeclaration.getSuperclassType();
                    ITypeBinding superclassTypeBinding = null;
                    if (superclassType != null)
                        superclassTypeBinding = superclassType.resolveBinding();
                    while (superclassTypeBinding != null && !variableBinding.getDeclaringClass().isEqualTo(superclassTypeBinding)) {
                        superclassTypeBinding = superclassTypeBinding.getSuperclass();
                    }
                    if (superclassTypeBinding != null) {
                        IVariableBinding[] superclassFieldBindings = superclassTypeBinding.getDeclaredFields();
                        for (IVariableBinding superclassFieldBinding : superclassFieldBindings) {
                            if (superclassFieldBinding.isEqualTo(variableBinding)) {
                                SimpleName expressionName = (SimpleName) newFieldInstructions.get(i);
                                if (!expressionName.getIdentifier().equals(targetClassVariableName) && !additionalArgumentsAddedToMovedMethod.contains(expressionName.getIdentifier()))
                                    addParameterToMovedMethod(newMethodDeclaration, variableBinding);
                            }
                        }
                    }
                }
            }
        }
        i++;
    }
    SimpleName parameterName = null;
    Set<String> sourceMethodsWithPublicModifier = new LinkedHashSet<String>();
    int j = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            if (methodInvocation.getExpression() == null || methodInvocation.getExpression() instanceof ThisExpression) {
                IMethodBinding methodBinding = methodInvocation.resolveMethodBinding();
                if (methodBinding.getDeclaringClass().isEqualTo(sourceTypeDeclaration.resolveBinding())) {
                    MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
                    for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                        if (sourceMethodDeclaration.resolveBinding().isEqualTo(methodInvocation.resolveMethodBinding()) && !sourceMethod.resolveBinding().isEqualTo(methodInvocation.resolveMethodBinding())) {
                            SimpleName fieldName = isGetter(sourceMethodDeclaration);
                            MethodInvocation newMethodInvocation = (MethodInvocation) newMethodInvocations.get(j);
                            if (fieldName != null) {
                                AST ast = newMethodDeclaration.getAST();
                                targetRewriter.replace(newMethodInvocation, ast.newSimpleName(fieldName.getIdentifier()), null);
                                if (!fieldName.getIdentifier().equals(targetClassVariableName) && !additionalArgumentsAddedToMovedMethod.contains(fieldName.getIdentifier()))
                                    addParameterToMovedMethod(newMethodDeclaration, fieldName);
                            } else {
                                if (!additionalArgumentsAddedToMovedMethod.contains("String_Node_Str")) {
                                    parameterName = addSourceClassParameterToMovedMethod(newMethodDeclaration);
                                }
                                targetRewriter.set(newMethodInvocation, MethodInvocation.EXPRESSION_PROPERTY, parameterName, null);
                                if (!sourceMethodsWithPublicModifier.contains(methodInvocation.resolveMethodBinding().toString())) {
                                    setPublicModifierToSourceMethod(methodInvocation);
                                    sourceMethodsWithPublicModifier.add(methodInvocation.resolveMethodBinding().toString());
                                }
                            }
                        }
                    }
                } else {
                    Type superclassType = sourceTypeDeclaration.getSuperclassType();
                    ITypeBinding superclassTypeBinding = null;
                    if (superclassType != null)
                        superclassTypeBinding = superclassType.resolveBinding();
                    while (superclassTypeBinding != null && !methodBinding.getDeclaringClass().isEqualTo(superclassTypeBinding)) {
                        superclassTypeBinding = superclassTypeBinding.getSuperclass();
                    }
                    if (superclassTypeBinding != null) {
                        IMethodBinding[] superclassMethodBindings = superclassTypeBinding.getDeclaredMethods();
                        for (IMethodBinding superclassMethodBinding : superclassMethodBindings) {
                            if (superclassMethodBinding.isEqualTo(methodBinding)) {
                                MethodInvocation newMethodInvocation = (MethodInvocation) newMethodInvocations.get(j);
                                if (!additionalArgumentsAddedToMovedMethod.contains("String_Node_Str")) {
                                    parameterName = addSourceClassParameterToMovedMethod(newMethodDeclaration);
                                }
                                targetRewriter.set(newMethodInvocation, MethodInvocation.EXPRESSION_PROPERTY, parameterName, null);
                            }
                        }
                    }
                }
            }
        }
        j++;
    }
}

Output:
                         superclassTypeBinding = superclassType.resolveBinding();
-                    while (superclassTypeBinding != null && !variableBinding.getDeclaringClass().isEqualTo(superclassTypeBinding)) {
+                    while (superclassTypeBinding != null && !superclassTypeBinding.isEqualTo(variableBinding.getDeclaringClass())) {
                         superclassTypeBinding = superclassTypeBinding.getSuperclass();


Input:
public ImportHistory run() throws AxelorException, IOException {
    File bind = MetaFiles.getPath(configuration.getBindMetaFile()).toFile(), data = MetaFiles.getPath(configuration.getDataMetaFile()).toFile();
    if (!bind.exists() || !data.exists()) {
        throw new AxelorException(I18n.get(IExceptionMessage.IMPORTER_1), IException.CONFIGURATION_ERROR);
    }
    File workspace = createFinalWorkspace(data);
    ImportHistory importHistory = process(bind.getAbsolutePath(), workspace.getAbsolutePath());
    deleteFinalWorkspace(workspace);
    log.debug("String_Node_Str", importHistory.getLog());
    return importHistory;
}

Output:
     File bind = MetaFiles.getPath(configuration.getBindMetaFile()).toFile(), data = MetaFiles.getPath(configuration.getDataMetaFile()).toFile();
-    if (!bind.exists() || !data.exists()) {
+    if (!bind.exists()) {
         throw new AxelorException(I18n.get(IExceptionMessage.IMPORTER_1), IException.CONFIGURATION_ERROR);


Input:
public void finish(ManufOrder manufOrder) throws AxelorException {
    if (manufOrder.getInStockMove() != null && manufOrder.getInStockMove().getStatusSelect() == IStockMove.STATUS_PLANNED) {
        stockMoveService.realize(manufOrder.getInStockMove());
    }
    if (manufOrder.getOutStockMove() != null && manufOrder.getOutStockMove().getStatusSelect() == IStockMove.STATUS_PLANNED) {
        stockMoveService.realize(manufOrder.getOutStockMove());
    }
}

Output:
 public void finish(ManufOrder manufOrder) throws AxelorException {
-    if (manufOrder.getInStockMove() != null && manufOrder.getInStockMove().getStatusSelect() == IStockMove.STATUS_PLANNED) {
-        stockMoveService.realize(manufOrder.getInStockMove());
-    }
-    if (manufOrder.getOutStockMove() != null && manufOrder.getOutStockMove().getStatusSelect() == IStockMove.STATUS_PLANNED) {
-        stockMoveService.realize(manufOrder.getOutStockMove());
-    }
+    this.finishStockMove(manufOrder.getInStockMove());
+    this.finishStockMove(manufOrder.getOutStockMove());
 }


Input:
public Iterable<? extends ResponseObject> getResponse(final Query query, Iterable<? extends ResponseObject> result) {
    result = filterPlaceholdersDecorator.decorate(query, result);
    result = dummify(result);
    result = groupRelatedObjects(query, result);
    result = filterTagsDecorator.decorate(query, result);
    result = filterPersonalDecorator.decorate(query, result);
    result = applyAbuseC(query, result);
    result = applySyntaxFilter(query, result);
    result = filterEmail(query, result);
    result = filterAuth(result);
    result = applyOutputFilters(query, result);
    return result;
}

Output:
 public Iterable<? extends ResponseObject> getResponse(final Query query, Iterable<? extends ResponseObject> result) {
-    result = filterPlaceholdersDecorator.decorate(query, result);
-    result = dummify(result);
-    result = groupRelatedObjects(query, result);
-    result = filterTagsDecorator.decorate(query, result);
-    result = filterPersonalDecorator.decorate(query, result);
-    result = applyAbuseC(query, result);
-    result = applySyntaxFilter(query, result);
-    result = filterEmail(query, result);
-    result = filterAuth(result);
-    result = applyOutputFilters(query, result);
-    return result;
+    Iterable<? extends ResponseObject> decoratedResult = filterPlaceholdersDecorator.decorate(query, result);
+    decoratedResult = filterPlaceholdersDecorator.decorate(query, decoratedResult);
+    decoratedResult = dummify(decoratedResult);
+    decoratedResult = groupRelatedObjects(query, decoratedResult);
+    decoratedResult = filterTagsDecorator.decorate(query, decoratedResult);
+    decoratedResult = filterPersonalDecorator.decorate(query, decoratedResult);
+    decoratedResult = applyAbuseC(query, decoratedResult);
+    decoratedResult = applySyntaxFilter(query, decoratedResult);
+    decoratedResult = filterEmail(query, decoratedResult);
+    decoratedResult = filterAuth(decoratedResult);
+    decoratedResult = applyOutputFilters(query, decoratedResult);
+    return decoratedResult;
 }


Input:
public LogBuffer putInt(int i) throws IOException {
    if (byteBuffer == null || (BUFFER_SIZE - byteBuffer.position()) < 4) {
        getNewMappedBuffer();
    }
    byteBuffer.putInt(i);
    return this;
}

Output:
     if (byteBuffer == null || (BUFFER_SIZE - byteBuffer.position()) < 4) {
-        getNewMappedBuffer();
+        getNewDirectBuffer();
     }


Input:
public void action(Action action) {
    if (action.getActionType() == EActionType.SELECT_POINT) {
        System.out.println("String_Node_Str" + ((SelectAction) action).getPosition());
    }
}

Output:
     if (action.getActionType() == EActionType.SELECT_POINT) {
-        System.out.println("String_Node_Str" + ((SelectAction) action).getPosition());
+        System.out.println("String_Node_Str" + ((PointAction) action).getPosition());
     }


Input:
public void onEntityDamageByEntityDamageMonitor(final EntityDamageByEntityEvent event) {
    if (!event.isCancelled() && MyPetExperience.DAMAGE_WEIGHTED_EXPERIENCE_DISTRIBUTION && event.getEntity() instanceof LivingEntity && !(event.getEntity() instanceof Player)) {
        LivingEntity damager = null;
        if (event.getDamager() instanceof Projectile) {
            Projectile projectile = (Projectile) event.getDamager();
            damager = projectile.getShooter();
        } else if (event.getDamager() instanceof LivingEntity) {
            damager = (LivingEntity) event.getDamager();
        } else if (event.getDamager() instanceof LightningStrike) {
            LightningStrike lightning = (LightningStrike) event.getDamager();
            if (Lightning.isSkillLightning(lightning)) {
                MyPet lightningMyPet = Lightning.lightningList.get(lightning);
                damager = lightningMyPet.getCraftPet();
            }
        }
        if (damager != null) {
            MyPetExperience.addDamageToEntity(damager, (LivingEntity) event.getEntity(), event.getDamage());
        }
    }
}

Output:
 public void onEntityDamageByEntityDamageMonitor(final EntityDamageByEntityEvent event) {
-    if (!event.isCancelled() && MyPetExperience.DAMAGE_WEIGHTED_EXPERIENCE_DISTRIBUTION && event.getEntity() instanceof LivingEntity && !(event.getEntity() instanceof Player)) {
+    if (!event.isCancelled() && MyPetExperience.DAMAGE_WEIGHTED_EXPERIENCE_DISTRIBUTION && event.getEntity() instanceof LivingEntity && !(event.getEntity() instanceof Player) && !(event.getEntity() instanceof CraftMyPet)) {
         LivingEntity damager = null;


Input:
public Object get(String name, Scriptable start) {
    logger.entering(JSRowObject.class.getName(), "String_Node_Str", name);
    if (name.equals(DATA_SET)) {
        if (logger.isLoggable(Level.FINER))
            logger.exiting(JSRowObject.class.getName(), "String_Node_Str");
        return dataSet.getJSDataSetObject();
    } else if (name.equals(COLUMN_MD)) {
        if (logger.isLoggable(Level.FINER))
            logger.exiting(JSRowObject.class.getName(), "String_Node_Str", getColumnMetadataScriptable());
        return getColumnMetadataScriptable();
    } else if (name.equals(ROW_POSITION)) {
        try {
            return new Integer(dataSet.getCurrentRowIndex());
        } catch (DataException e) {
            logger.logp(Level.FINER, JSColumnDefn.class.getName(), "String_Node_Str", e.getMessage(), e);
        }
    }
    try {
        return dataSet.getDataRow().getColumnValue(name);
    } catch (BirtException e) {
        logger.logp(Level.FINER, JSColumnDefn.class.getName(), "String_Node_Str", e.getMessage(), e);
        return new DataExceptionMocker(e);
    }
}

Output:
     try {
-        return dataSet.getDataRow().getColumnValue(name);
+        Object value = dataSet.getDataRow().getColumnValue(name);
+        return JavascriptEvalUtil.convertToJavascriptValue(value, dataSet.getDataEngine().getSharedScope());
     } catch (BirtException e) {


Input:
public ReturnValue do_verify_parameters() {
    ReturnValue ret = new ReturnValue();
    ret.setExitStatus(ReturnValue.SUCCESS);
    try {
        OptionParser parser = getOptionParser();
        options = parser.parse(this.getParameters().toArray(new String[0]));
    } catch (OptionException e) {
        ret.setStderr(e.getMessage() + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        e.printStackTrace();
        return ret;
    }
    if (!options.has("String_Node_Str") && !options.has("String_Node_Str")) {
        ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        return ret;
    }
    if (!options.has("String_Node_Str") && !options.has("String_Node_Str")) {
        ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        return ret;
    }
    if (options.has("String_Node_Str") && options.valueOf("String_Node_Str") != null && options.valueOf("String_Node_Str").toString().length() > 0) {
        algorithmName = (String) options.valueOf("String_Node_Str");
    }
    if (options.has("String_Node_Str") && !options.has("String_Node_Str")) {
        ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        return ret;
    }
    if (options.has("String_Node_Str") && options.has("String_Node_Str")) {
        ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        return ret;
    }
    if (options.has("String_Node_Str") && (options.has("String_Node_Str") || options.has("String_Node_Str")) && (options.valuesOf("String_Node_Str").size() > 1 || options.valuesOf("String_Node_Str").size() > 1 || options.valuesOf("String_Node_Str").size() > 1)) {
        ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());
        ret.setExitStatus(ReturnValue.INVALIDPARAMETERS);
        return ret;
    }
    return (ret);
}

Output:
     }
-    if (options.has("String_Node_Str") && !options.has("String_Node_Str")) {
+    if (options.has("String_Node_Str") && !(options.has("String_Node_Str") || options.has("String_Node_Str"))) {
         ret.setStderr("String_Node_Str" + System.getProperty("String_Node_Str") + this.get_syntax());


Input:
public void visitMethodDeclaration(MethodDeclaration m) {
    javadocs.put(m.getSimpleName() + "String_Node_Str", m.getDocComment());
}

Output:
 public void visitMethodDeclaration(MethodDeclaration m) {
-    javadocs.put(m.getSimpleName() + "String_Node_Str", m.getDocComment());
+    String javadoc = m.getDocComment();
+    if (javadoc != null)
+        javadocs.put(m.getSimpleName() + "String_Node_Str", javadoc);
 }


Input:
public static ClassLoader getCustomScriptClassLoader(ClassLoader parent) {
    String classPath = System.getProperty("String_Node_Str");
    if (classPath == null || classPath.length() == 0)
        return parent;
    String[] classPathArray = classPath.split(File.pathSeparator, -1);
    int count = classPathArray.length;
    URL[] urls = new URL[count];
    for (int i = 0; i < count; i++) {
        File file = new File(classPathArray[i]);
        try {
            urls[i] = file.toURL();
        } catch (MalformedURLException e) {
            urls[i] = null;
        }
    }
    return new URLClassLoader(urls, parent);
}

Output:
 public static ClassLoader getCustomScriptClassLoader(ClassLoader parent) {
-    String classPath = System.getProperty("String_Node_Str");
-    if (classPath == null || classPath.length() == 0)
+    List<URL> urls = getClassPathURLs();
+    if (urls.size() == 0)
         return parent;