Input:
public void run() {
    MasterServerClient api = new MasterServerClient(app.getConfig().getMasterServerConfig());
    try {
        LeoObject result = api.getServerListings(null);
        if (LeoObject.isTrue(result)) {
            showServersLabel.set(false);
            if (result.isArray()) {
                LeoArray array = result.as();
                servers.add(array);
            }
        } else {
            showServersLabel.set(true);
        }
        update.set(true);
    } catch (Exception e) {
        Cons.println("String_Node_Str" + e);
    }
}

Output:
     try {
-        LeoObject result = api.getServerListings(null);
+        String gameType = gameTypeIndex >= 0 && gameTypeIndex < GameType.Type.values().length ? GameType.Type.values()[gameTypeIndex].name() : null;
+        LeoObject result = api.getServerListings(gameType);
         if (LeoObject.isTrue(result)) {


Input:
private void updateVisibleAnnotations() {
    System.out.println("String_Node_Str");
    final float marginFactor = 2.0f;
    final float bucketSize = 60.0f;
    MKMapRect visibleMapRect = mapView.getVisibleMapRect();
    MKMapRect adjustedVisibleMapRect = visibleMapRect.inset(-marginFactor * visibleMapRect.getSize().getWidth(), -marginFactor * visibleMapRect.getSize().getHeight());
    CLLocationCoordinate2D leftCoordinate = mapView.convertPointToCoordinateFromView(CGPoint.Zero(), getView());
    CLLocationCoordinate2D rightCoordinate = mapView.convertPointToCoordinateFromView(new CGPoint(bucketSize, 0), getView());
    double gridSize = MKMapPoint.create(rightCoordinate).getX() - MKMapPoint.create(leftCoordinate).getX();
    MKMapRect gridMapRect = new MKMapRect();
    gridMapRect.setSize(new MKMapSize(gridSize, gridSize));
    double startX = Math.floor(adjustedVisibleMapRect.getOrigin().getX() / gridSize) * gridSize;
    double startY = Math.floor(adjustedVisibleMapRect.getOrigin().getY() / gridSize) * gridSize;
    double endX = Math.floor((adjustedVisibleMapRect.getOrigin().getX() + adjustedVisibleMapRect.getSize().getWidth()) / gridSize) * gridSize;
    double endY = Math.floor((adjustedVisibleMapRect.getOrigin().getY() + adjustedVisibleMapRect.getSize().getHeight()) / gridSize) * gridSize;
    gridMapRect.getOrigin().setY(startY);
    while (gridMapRect.getOrigin().getY() <= endY) {
        gridMapRect.getOrigin().setX(startX);
        while (gridMapRect.getOrigin().getX() <= endX) {
            NSSet<NSObject> allAnnotationsInBucket = allAnnotationsMapView.getAnnotations(gridMapRect);
            NSSet<NSObject> visibleAnnotationsInBucket = mapView.getAnnotations(gridMapRect);
            if (allAnnotationsInBucket == null || visibleAnnotationsInBucket == null)
                continue;
            List<PhotoAnnotation> filteredAnnotationsInBucket = new ArrayList<>();
            for (NSObject annotation : allAnnotationsInBucket) {
                if (annotation instanceof PhotoAnnotation) {
                    filteredAnnotationsInBucket.add((PhotoAnnotation) annotation);
                }
            }
            if (filteredAnnotationsInBucket.size() > 0) {
                PhotoAnnotation annotationForGrid = getAnnotationInGrid(gridMapRect, filteredAnnotationsInBucket);
                filteredAnnotationsInBucket.remove(annotationForGrid);
                annotationForGrid.setContainedAnnotations(filteredAnnotationsInBucket);
                mapView.addAnnotation(annotationForGrid);
                for (final PhotoAnnotation annotation : filteredAnnotationsInBucket) {
                    annotation.setClusterAnnotation(annotationForGrid);
                    annotation.setContainedAnnotations(null);
                    if (visibleAnnotationsInBucket.contains(annotation)) {
                        final CLLocationCoordinate2D actualCoordinate = annotation.getCoordinate();
                        UIView.animate(0.3, new Runnable() {
                            public void run() {
                                annotation.setCoordinate(annotation.getClusterAnnotation().getCoordinate());
                            }
                        }, new VoidBooleanBlock() {
                            public void invoke(boolean v) {
                                annotation.setCoordinate(actualCoordinate);
                                mapView.removeAnnotation(annotation);
                            }
                        });
                    }
                }
            }
            gridMapRect.getOrigin().setX(gridMapRect.getOrigin().getX() + gridSize);
        }
        gridMapRect.getOrigin().setY(gridMapRect.getOrigin().getY() + gridSize);
    }
    System.out.println("String_Node_Str");
}

Output:
         while (gridMapRect.getOrigin().getX() <= endX) {
-            NSSet<NSObject> allAnnotationsInBucket = allAnnotationsMapView.getAnnotations(gridMapRect);
-            NSSet<NSObject> visibleAnnotationsInBucket = mapView.getAnnotations(gridMapRect);
+            Set<MKAnnotation> allAnnotationsInBucket = allAnnotationsMapView.getAnnotations(gridMapRect);
+            Set<MKAnnotation> visibleAnnotationsInBucket = mapView.getAnnotations(gridMapRect);
             if (allAnnotationsInBucket == null || visibleAnnotationsInBucket == null)


Input:
private void handlePropertiesFile(File propFile, Map<File, File> folderMap, File parentFolder) throws PersistenceException, IOException {
    URI uri = URI.createFileURI(propFile.getAbsolutePath());
    Resource resource = resourceSet.getResource(uri, true);
    Property property = (Property) EcoreUtil.getObjectByType(resource.getContents(), PropertiesPackage.eINSTANCE.getProperty());
    if (property != null) {
        File targetFolder = folderMap.get(parentFolder);
        Item item = property.getItem();
        String connNameBofore = null;
        String connNameAfter = null;
        IPath path = new Path(item.getState().getPath());
        if (ProxyRepositoryFactory.getInstance().getFolderItem(ProjectManager.getInstance().getCurrentProject(), ERepositoryObjectType.getItemType(item), path) == null) {
            ProxyRepositoryFactory.getInstance().createFolder(ERepositoryObjectType.getItemType(item), path.removeLastSegments(1), path.lastSegment());
        }
        String connName = null;
        if (item instanceof ConnectionItem) {
            Connection conn = ((ConnectionItem) item).getConnection();
            connNameBofore = conn.eResource().getURI().trimFileExtension().lastSegment();
            String version = property.getVersion();
            if (version == null) {
                version = "String_Node_Str";
            }
            String label = conn.getName() + "String_Node_Str" + version;
            connNameAfter = label;
            File destItemFile = new Path(targetFolder.getAbsolutePath()).append(path).append(connNameAfter).addFileExtension(FactoriesUtil.ITEM_EXTENSION).toFile();
            File destPropFile = new Path(targetFolder.getAbsolutePath()).append(path).append(connNameAfter).addFileExtension(FactoriesUtil.PROPERTIES_EXTENSION).toFile();
            if (destItemFile.exists()) {
                int num = 0;
                while (destItemFile.exists() || destPropFile.exists()) {
                    connName = conn.getName() + String.valueOf(++num);
                    connNameAfter = connName + "String_Node_Str" + version;
                    destItemFile = new Path(destItemFile.getPath()).removeLastSegments(1).append(connNameAfter).addFileExtension(FactoriesUtil.ITEM_EXTENSION).toFile();
                    destPropFile = new Path(destPropFile.getPath()).removeLastSegments(1).append(connNameAfter).addFileExtension(FactoriesUtil.PROPERTIES_EXTENSION).toFile();
                }
                conn.setName(connName);
                conn.setLabel(connName);
                property.setLabel(connName);
            }
            String relationPropPath = ReponsitoryContextBridge.getRootProject().getFullPath().append(new Path(destPropFile.getPath()).makeRelativeTo(this.getWorkspacePath())).toOSString();
            MetadataHelper.setPropertyPath(relationPropPath, conn);
        }
        if (isWorksapcePath()) {
            ProxyRepositoryFactory.getInstance().create(item, path, true);
        } else {
            connNameAfter = copyFile(targetFolder, propFile, property, path, connNameAfter, folderMap);
        }
        if (connNameBofore != null && connNameAfter != null) {
            getReplaceStringMap().put(connNameBofore, connNameAfter);
        }
    }
}

Output:
         } else {
-            connNameAfter = copyFile(targetFolder, propFile, property, path, connNameAfter, folderMap);
+            connNameAfter = copyFile(targetFolder, propFile, property, path, connNameAfter, connName, folderMap);
         }


Input:
public List<SchemaValidationError> debugByContent(String content) throws Exception {
    String schemaText = getSchema();
    JsonNode schemaObject = MAPPER.readTree(schemaText);
    JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
    JsonSchema schema = factory.getJsonSchema(schemaObject);
    ProcessingReport report = schema.validate(JsonLoader.fromString(content));
    ListProcessingReport lp = new ListProcessingReport();
    lp.mergeWith(report);
    List<SchemaValidationError> output = new ArrayList<SchemaValidationError>();
    java.util.Iterator<ProcessingMessage> it = lp.iterator();
    while (it.hasNext()) {
        ProcessingMessage pm = it.next();
        output.add(new SchemaValidationError(pm.asJson()));
    }
    return output;
}

Output:
     List<SchemaValidationError> output = new ArrayList<SchemaValidationError>();
-    java.util.Iterator<ProcessingMessage> it = lp.iterator();
-    while (it.hasNext()) {
-        ProcessingMessage pm = it.next();
+    for (ProcessingMessage pm : lp) {
         output.add(new SchemaValidationError(pm.asJson()));


Input:
private Set<String> getArgsFromSteps(List<SpecStep> steps) {
    Set<String> staticArgs = new HashSet<String>();
    for (SpecStep step : steps) {
        List<SpecStaticArg> args = step.getStaticArgList();
        for (SpecStaticArg arg : args) {
            if (arg.getText() != null)
                staticArgs.add(arg.getText());
        }
    }
    return staticArgs;
}

Output:
 private Set<String> getArgsFromSteps(List<SpecStep> steps) {
-    Set<String> staticArgs = new HashSet<String>();
+    Set<String> staticArgs = new HashSet<>();
     for (SpecStep step : steps) {


Input:
public void startConnectorServer(int rmiRegistryPort, int rmiConnectorPort) throws IOException {
    boolean rmiSSL = false;
    boolean authenticate = true;
    String passwordFile = null;
    String accessFile = null;
    System.setProperty("String_Node_Str", "String_Node_Str");
    String rmiSSLValue = System.getProperty("String_Node_Str", "String_Node_Str");
    rmiSSL = Boolean.parseBoolean(rmiSSLValue);
    String authenticateValue = System.getProperty("String_Node_Str", "String_Node_Str");
    authenticate = Boolean.parseBoolean(authenticateValue);
    passwordFile = System.getProperty("String_Node_Str");
    accessFile = System.getProperty("String_Node_Str");
    LOG.info("String_Node_Str" + rmiSSLValue + "String_Node_Str" + authenticateValue + "String_Node_Str" + passwordFile + "String_Node_Str" + accessFile);
    HashMap<String, Object> jmxEnv = new HashMap<String, Object>();
    RMIClientSocketFactory csf = null;
    RMIServerSocketFactory ssf = null;
    if (rmiSSL) {
        if (rmiRegistryPort == rmiConnectorPort) {
            throw new IOException("String_Node_Str" + "String_Node_Str");
        }
        csf = new SslRMIClientSocketFactory();
        ssf = new SslRMIServerSocketFactory();
    }
    if (csf != null) {
        jmxEnv.put(RMIConnectorServer.RMI_CLIENT_SOCKET_FACTORY_ATTRIBUTE, csf);
    }
    if (ssf != null) {
        jmxEnv.put(RMIConnectorServer.RMI_SERVER_SOCKET_FACTORY_ATTRIBUTE, ssf);
    }
    if (authenticate) {
        jmxEnv.put("String_Node_Str", passwordFile);
        jmxEnv.put("String_Node_Str", accessFile);
    }
    LocateRegistry.createRegistry(rmiRegistryPort);
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    JMXServiceURL serviceUrl = buildJMXServiceURL(rmiRegistryPort, rmiConnectorPort);
    try {
        jmxCS = JMXConnectorServerFactory.newJMXConnectorServer(serviceUrl, jmxEnv, mbs);
        jmxCS.start();
        LOG.info("String_Node_Str");
    } catch (IOException e) {
        LOG.error("String_Node_Str", e);
    }
}

Output:
     try {
-        jmxCS = JMXConnectorServerFactory.newJMXConnectorServer(serviceUrl, jmxEnv, mbs);
-        jmxCS.start();
+        synchronized (JMXListener.class) {
+            if (JMX_CS != null) {
+                throw new RuntimeException("String_Node_Str");
+            }
+            JMX_CS = JMXConnectorServerFactory.newJMXConnectorServer(serviceUrl, jmxEnv, mbs);
+            JMX_CS.start();
+        }
         LOG.info("String_Node_Str");


Input:
public void memberRemoved(final String uuid) {
    iAmCleanUpNode = lockServiceLock.tryLock();
    if (iAmCleanUpNode) {
        executorService.submit(new Runnable() {

            public void run() {
                releaseLocks(uuid);
            }
        });
    }
}

Output:
 public void memberRemoved(final String uuid) {
-    iAmCleanUpNode = lockServiceLock.tryLock();
-    if (iAmCleanUpNode) {
-        executorService.submit(new Runnable() {
+    if (lockServiceLock.tryLock()) {
+        try {
+            executorService.submit(new Runnable() {


Input:
protected void processAccessorFields(boolean processingInverse) {
    for (Field field : MetadataHelper.getFields(getJavaClass())) {
        MetadataField metadataField = new MetadataField(field, getLogger());
        if (metadataField.isAnnotationPresent(Transient.class)) {
            if (metadataField.hasMoreThanOneDeclaredAnnotation(getDescriptor())) {
                throw ValidationException.mappingAnnotationsAppliedToTransientAttribute(field);
            }
        } else {
            if (metadataField.isValidPersistenceField(processingInverse, getDescriptor())) {
                if (!getDescriptor().hasAccessorFor(metadataField.getAttributeName()) || (getDescriptor().hasAccessorFor(metadataField.getAttributeName()) && processingInverse)) {
                    getDescriptor().addAccessor(buildAccessor(metadataField));
                }
            }
        }
    }
    if (hasExplicitAccessType() && !processingInverse) {
        processAccessorMethods(true);
    }
}

Output:
     }
-    if (hasExplicitAccessType() && !processingInverse) {
+    if (hasAccess() && !processingInverse) {
         processAccessorMethods(true);


Input:
private void commonQueryInvalidDomain(String domainName) throws Exception {
    mockMvc.perform(get("String_Node_Str" + domainName).accept(MediaType.parseMediaType("String_Node_Str"))).andExpect(status().isBadRequest()).andExpect(content().contentType("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value(400)).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str"));
}

Output:
 private void commonQueryInvalidDomain(String domainName) throws Exception {
-    mockMvc.perform(get("String_Node_Str" + domainName).accept(MediaType.parseMediaType("String_Node_Str"))).andExpect(status().isBadRequest()).andExpect(content().contentType("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value(400)).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str"));
+    mockMvc.perform(get("String_Node_Str" + StringUtil.urlEncode(domainName)).accept(MediaType.parseMediaType("String_Node_Str"))).andExpect(status().isBadRequest()).andExpect(content().contentType("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value(400)).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str")).andExpect(jsonPath("String_Node_Str").value("String_Node_Str"));
 }


Input:
private void evict(Entry<K, V> newCold) {
    while ((queueSize << 5) < mapSize) {
        convertOldestHotToCold();
    }
    if (stackSize > 0) {
        addToQueue(queue, newCold);
    }
    while (usedMemory > maxMemory && queueSize > 1) {
        Entry<K, V> e = queue.queuePrev;
        usedMemory -= e.memory;
        evictionCount++;
        removeFromQueue(e);
        e.value = null;
        e.memory = 0;
        addToQueue(queue2, e);
        while (queue2Size + queue2Size > stackSize) {
            e = queue2.queuePrev;
            int hash = getHash(e.key);
            invalidate(e.key, hash);
        }
    }
}

Output:
 private void evict(Entry<K, V> newCold) {
-    while ((queueSize << 5) < mapSize) {
+    while (queueSize <= (mapSize >>> 5) && stackSize > 0) {
         convertOldestHotToCold();


Input:
protected Optional<URI> getDockerUriFromEnvironment() {
    String envDockerHost = System.getenv(RemoteDockerProvider.DOCKER_HOST_SYSTEM_ENV);
    try {
        return Optional.of(URI.create(envDockerHost));
    } catch (NullPointerException | IllegalArgumentException ignored) {
        return Optional.absent();
    }
}

Output:
     try {
-        return Optional.of(URI.create(envDockerHost));
-    } catch (NullPointerException | IllegalArgumentException ignored) {
+        URI uri = URI.create(envDockerHost);
+        return Optional.of(uri);
+    } catch (IllegalArgumentException ignored) {
         return Optional.absent();


Input:
protected void onMenuAdded(final Pointer menu) {
    libappindicator.app_indicator_set_menu(this.appIndicator, menu);
}

Output:
 protected void onMenuAdded(final Pointer menu) {
-    libappindicator.app_indicator_set_menu(this.appIndicator, menu);
+    appindicator.app_indicator_set_menu(this.appIndicator, menu);
 }


Input:
public void withhold(int amount) {
    if (amount > 0)
        new CashMove(bank, operatingCompany.get(), amount);
    operatingCompany.get().withhold(amount);
}

Output:
 public void withhold(int amount) {
-    if (amount > 0)
-        new CashMove(bank, operatingCompany.get(), amount);
-    operatingCompany.get().withhold(amount);
+    PublicCompanyI company = operatingCompany.get();
+    pay(bank, company, amount);
+    company.withhold(amount);
+    StockSpaceI newSpace = company.getCurrentSpace();
+    if (newSpace.closesCompany() && company.canClose()) {
+        company.setClosed();
+        ReportBuffer.add(LocalText.getText("String_Node_Str", company.getName(), newSpace.getName()));
+        finishTurn();
+        return;
+    }
 }


Input:
public void addComment(Dao dao, Entity<?> en, String commentTable, String commentColumn) {
    if (!en.hasTableComment() && !en.hasColumnComment()) {
        return;
    }
    List<Sql> sqls = new ArrayList<Sql>();
    if (en.hasTableComment()) {
        Sql tableCommentSQL = Sqls.create(commentTable);
        tableCommentSQL.vars().set("String_Node_Str", en.getTableName()).set("String_Node_Str", en.getTableComment());
        sqls.add(tableCommentSQL);
    }
    if (en.hasColumnComment()) {
        for (MappingField mf : en.getMappingFields()) {
            if (mf.hasColumnComment()) {
                Sql columnCommentSQL = Sqls.create(commentColumn);
                columnCommentSQL.vars().set("String_Node_Str", en.getTableName()).set("String_Node_Str", mf.getColumnName()).set("String_Node_Str", mf.getColumnComment());
                sqls.add(columnCommentSQL);
            }
        }
    }
    dao.execute(sqls.toArray(new Sql[sqls.size()]));
}

Output:
     if (en.hasTableComment()) {
-        Sql tableCommentSQL = Sqls.create(commentTable);
+        Sql tableCommentSQL = Sqls.create(Strings.isBlank(commentTable) ? DEFAULT_COMMENT_TABLE : commentTable);
         tableCommentSQL.vars().set("String_Node_Str", en.getTableName()).set("String_Node_Str", en.getTableComment());


Input:
public ItemPresentation getPresentation() {
    return element instanceof NavigationItem ? ((NavigationItem) element).getPresentation() : null;
}

Output:
 public ItemPresentation getPresentation() {
-    return element instanceof NavigationItem ? ((NavigationItem) element).getPresentation() : null;
+    ItemPresentation presentation = element.getPresentation();
+    return presentation != null ? presentation : new PresentationData();
 }


Input:
protected XEnvironment makeEnv(String str, XProgram init) {
    return XDriver.makeEnv(str, init);
}

Output:
 protected XEnvironment makeEnv(String str, XProgram init) {
-    return XDriver.makeEnv(str, init);
+    return XDriver.makeEnv(str, init, toUpdate);
 }


Input:
public int hashCode() {
    return this.value != null && this.value.value != null ? this.value.value.hashCode() : 0;
}

Output:
 public int hashCode() {
-    return this.value != null && this.value.value != null ? this.value.value.hashCode() : 0;
+    return this.value != null && this.value != null ? this.value.hashCode() : 0;
 }


Input:
public ReportArtEntity generateReportArt(final ReportArtEntity report) {
    log.debug("String_Node_Str");
    final Map<String, ReportingUser> users = Maps.newHashMap();
    final Map<String, String> accounts = Maps.newHashMap();
    final Map<String, InstanceUsageArtEntity> usageEntities = new HashMap<String, InstanceUsageArtEntity>();
    final Map<String, Long> instanceStartTimes = new HashMap<String, Long>();
    foreachInstanceCreateEvent(report.getEndMs(), new Predicate<ReportingInstanceCreateEvent>() {
        public boolean apply(final ReportingInstanceCreateEvent createEvent) {
            if (!report.getZones().containsKey(createEvent.getAvailabilityZone())) {
                report.getZones().put(createEvent.getAvailabilityZone(), new AvailabilityZoneArtEntity());
            }
            AvailabilityZoneArtEntity zone = report.getZones().get(createEvent.getAvailabilityZone());
            final ReportingUser reportingUser = getUserById(users, createEvent.getUserId());
            if (reportingUser == null) {
                log.error("String_Node_Str" + createEvent.getUserId());
                return true;
            }
            final String accountName = getAccountNameById(accounts, reportingUser.getAccountId());
            if (accountName == null) {
                log.error("String_Node_Str" + reportingUser.getAccountId());
                return true;
            }
            if (!zone.getAccounts().containsKey(accountName)) {
                zone.getAccounts().put(accountName, new AccountArtEntity());
            }
            AccountArtEntity account = zone.getAccounts().get(accountName);
            if (!account.getUsers().containsKey(reportingUser.getName())) {
                account.getUsers().put(reportingUser.getName(), new UserArtEntity());
            }
            UserArtEntity user = account.getUsers().get(reportingUser.getName());
            if (!user.getInstances().containsKey(createEvent.getUuid())) {
                user.getInstances().put(createEvent.getUuid(), new InstanceArtEntity(createEvent.getInstanceType(), createEvent.getInstanceId()));
            }
            InstanceArtEntity instance = user.getInstances().get(createEvent.getUuid());
            instance.getUsage().addInstanceCnt(1);
            usageEntities.put(createEvent.getUuid(), instance.getUsage());
            instanceStartTimes.put(createEvent.getUuid(), createEvent.getTimestampMs());
            return true;
        }
    });
    final Map<InstanceMetricDimensionKey, MetricPrevData> prevDataMap = new HashMap<InstanceMetricDimensionKey, MetricPrevData>();
    foreachInstanceUsageEvent(report.getBeginMs() - USAGE_SEARCH_PERIOD, report.getEndMs() + USAGE_SEARCH_PERIOD, new Predicate<ReportingInstanceUsageEvent>() {
        public boolean apply(final ReportingInstanceUsageEvent event) {
            final InstanceMetricDimensionKey key = new InstanceMetricDimensionKey(event.getUuid(), event.getMetric(), event.getDimension());
            final long eventMs = event.getTimestampMs();
            if (event.getValue() == null)
                return true;
            final InstanceUsageArtEntity usageEntity = usageEntities.get(event.getUuid());
            if (usageEntity == null)
                return true;
            if (!prevDataMap.containsKey(key)) {
                if (instanceStartTimes.containsKey(event.getUuid())) {
                    Double fractionalVal = fractionalUsage(report.getBeginMs(), report.getEndMs(), instanceStartTimes.get(event.getUuid()), eventMs, event.getValue());
                    addMetricValueToUsageEntity(usageEntity, event.getMetric(), event.getDimension(), fractionalVal);
                    log.debug(String.format("String_Node_Str", instanceStartTimes.get(event.getUuid()), eventMs, report.getBeginMs(), report.getEndMs(), event.getUuid(), event.getMetric(), event.getDimension(), event.getValue(), fractionalVal));
                }
                prevDataMap.put(key, new MetricPrevData(eventMs, eventMs, event.getValue(), event.getSequenceNum()));
            } else {
                final MetricPrevData prevData = prevDataMap.get(key);
                usageEntity.setDurationMs(Math.max(usageEntity.getDurationMs(), overlap(report.getBeginMs(), report.getEndMs(), prevData.firstMs, eventMs)));
                if (event.getSequenceNum() < prevData.lastSeq) {
                    Double fractionalVal = fractionalUsage(report.getBeginMs(), report.getEndMs(), prevData.lastMs, eventMs, event.getValue());
                    addMetricValueToUsageEntity(usageEntity, event.getMetric(), event.getDimension(), fractionalVal);
                    log.debug(String.format("String_Node_Str", prevData.lastMs, eventMs, report.getBeginMs(), report.getEndMs(), event.getUuid(), event.getMetric(), event.getDimension(), event.getValue(), fractionalVal));
                } else {
                    Double fractionalVal = fractionalUsage(report.getBeginMs(), report.getEndMs(), prevData.lastMs, eventMs, event.getValue() - prevData.lastVal);
                    addMetricValueToUsageEntity(usageEntity, event.getMetric(), event.getDimension(), fractionalVal);
                    log.debug(String.format("String_Node_Str", prevData.lastMs, eventMs, report.getBeginMs(), report.getEndMs(), event.getUuid(), event.getMetric(), event.getDimension(), event.getValue(), prevData.lastVal, fractionalVal));
                }
                prevDataMap.put(key, new MetricPrevData(prevData.firstMs, eventMs, event.getValue(), event.getSequenceNum()));
            }
            return true;
        }
    });
    for (final AvailabilityZoneArtEntity zone : report.getZones().values()) {
        final UsageTotalsArtEntity zoneUsage = zone.getUsageTotals();
        for (final AccountArtEntity account : zone.getAccounts().values()) {
            final UsageTotalsArtEntity accountUsage = account.getUsageTotals();
            for (final UserArtEntity user : account.getUsers().values()) {
                final UsageTotalsArtEntity userUsage = user.getUsageTotals();
                for (final InstanceArtEntity instance : user.getInstances().values()) {
                    updateUsageTotals(userUsage, instance);
                    updateUsageTotals(accountUsage, instance);
                    updateUsageTotals(zoneUsage, instance);
                }
            }
        }
    }
    return report;
}

Output:
     log.debug("String_Node_Str");
-    final Map<String, ReportingUser> users = Maps.newHashMap();
-    final Map<String, String> accounts = Maps.newHashMap();
-    final Map<String, InstanceUsageArtEntity> usageEntities = new HashMap<String, InstanceUsageArtEntity>();
-    final Map<String, Long> instanceStartTimes = new HashMap<String, Long>();
+    final Map<String, ReportingInstanceCreateEvent> createEvents = new HashMap<String, ReportingInstanceCreateEvent>();
     foreachInstanceCreateEvent(report.getEndMs(), new Predicate<ReportingInstanceCreateEvent>() {


Input:
public void testScript() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testScript() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" }, "String_Node_Str");
 }


Input:
public String getEditLink() {
    return pluginSettingsManager.getWordpressRootUrl() + MessageFormat.format(pluginSettingsManager.getWordpressEditPostRelativePath(), metadata.getPostId());
}

Output:
 public String getEditLink() {
-    return pluginSettingsManager.getWordpressRootUrl() + MessageFormat.format(pluginSettingsManager.getWordpressEditPostRelativePath(), metadata.getPostId());
+    return pluginSettingsManager.getWordpressRootUrl() + MessageFormat.format(pluginSettingsManager.getWordpressEditPostRelativePath(), metadata.getPostId().toString());
 }


Input:
public void testTraceConstructors() {
    LTTngTrace testStream1 = null;
    try {
        testStream1 = new LTTngTrace(wrongTracePath, skipIndexing);
        fail("String_Node_Str");
    } catch (Exception e) {
    }
    try {
        URL location = FileLocator.find(LTTngCoreTestPlugin.getPlugin().getBundle(), new Path(tracepath1), null);
        File testfile = new File(FileLocator.toFileURL(location).toURI());
        testStream1 = new LTTngTrace(testfile.getPath(), skipIndexing);
    } catch (Exception e) {
        fail("String_Node_Str");
    }
    System.out.println("String_Node_Str");
}

Output:
     try {
-        testStream1 = new LTTngTrace(wrongTracePath, skipIndexing);
+        testStream1 = new LTTngTrace("String_Node_Str", wrongTracePath, skipIndexing);
         fail("String_Node_Str");


Input:
private List<String> getDatastoreNamePattern(DatastoreType storageType, List<String> storeNames) {
    if (storageType == null && (storeNames == null || storeNames.isEmpty())) {
        return null;
    }
    Set<String> storePattern = null;
    if (storageType == null) {
        logger.debug("String_Node_Str");
        storePattern = datastoreMgr.getDatastoresByNames(storeNames);
    }
    if (storageType == DatastoreType.LOCAL) {
        storePattern = datastoreMgr.getLocalDatastoresByNames(storeNames);
    } else {
        storePattern = datastoreMgr.getSharedDatastoresByNames(storeNames);
    }
    if (storePattern == null || storePattern.isEmpty()) {
        logger.warn("String_Node_Str" + storeNames + "String_Node_Str" + storageType + "String_Node_Str");
        return null;
    }
    return new ArrayList<String>(storePattern);
}

Output:
     Set<String> storePattern = null;
-    if (storageType == null) {
-        logger.debug("String_Node_Str");
-        storePattern = datastoreMgr.getDatastoresByNames(storeNames);
-    }
-    if (storageType == DatastoreType.LOCAL) {
-        storePattern = datastoreMgr.getLocalDatastoresByNames(storeNames);
-    } else {
-        storePattern = datastoreMgr.getSharedDatastoresByNames(storeNames);
-    }
+    storePattern = datastoreMgr.getDatastoresByNames(storeNames);
     if (storePattern == null || storePattern.isEmpty()) {


Input:
protected int doWork() {
    IoUtil.assertFileIsReadable(INPUT);
    if (SEQUENCE_DICTIONARY != null)
        IoUtil.assertFileIsReadable(SEQUENCE_DICTIONARY);
    IoUtil.assertFileIsWritable(OUTPUT);
    final VCFFileReader reader = new VCFFileReader(INPUT);
    final VCFHeader header = new VCFHeader(reader.getFileHeader());
    final SAMSequenceDictionary sequenceDictionary = SEQUENCE_DICTIONARY != null ? SAMFileReader.getSequenceDictionary(SEQUENCE_DICTIONARY) : header.getSequenceDictionary();
    if (CREATE_INDEX && sequenceDictionary == null) {
        throw new PicardException("String_Node_Str");
    }
    final EnumSet<Options> options = CREATE_INDEX ? EnumSet.of(Options.INDEX_ON_THE_FLY) : EnumSet.noneOf(Options.class);
    final VariantContextWriter writer = VariantContextWriterFactory.create(OUTPUT, sequenceDictionary, options);
    writer.writeHeader(header);
    final ProgressLogger progress = new ProgressLogger(Log.getInstance(MakeSitesOnlyVcf.class), 10000);
    final CloseableIterator<VariantContext> iterator = reader.iterator();
    while (iterator.hasNext()) {
        final VariantContext context = iterator.next();
        writer.add(context.subContextFromSamples(NO_SAMPLES, false));
        progress.record(context.getChr(), context.getStart());
    }
    CloserUtil.close(iterator);
    CloserUtil.close(reader);
    writer.close();
    return 0;
}

Output:
     final VCFFileReader reader = new VCFFileReader(INPUT);
-    final VCFHeader header = new VCFHeader(reader.getFileHeader());
+    final VCFHeader header = new VCFHeader(reader.getFileHeader().getMetaDataInInputOrder());
     final SAMSequenceDictionary sequenceDictionary = SEQUENCE_DICTIONARY != null ? SAMFileReader.getSequenceDictionary(SEQUENCE_DICTIONARY) : header.getSequenceDictionary();


Input:
public void register(CartridgeInfo cartridgeInfo, Cluster cluster, PayloadData payloadData, String autoscalePolicyName, String deploymentPolicyName, Properties properties) throws ADCException, UnregisteredCartridgeException {
    log.info("String_Node_Str" + payloadData.getCompletePayloadData().toString());
    ApplicationManagementUtil.registerService(cartridgeInfo.getType(), cluster.getClusterDomain(), cluster.getClusterSubDomain(), payloadData.getCompletePayloadData(), payloadData.getBasicPayloadData().getTenantRange(), cluster.getHostName(), autoscalePolicyName, deploymentPolicyName, properties);
}

Output:
 public void register(CartridgeInfo cartridgeInfo, Cluster cluster, PayloadData payloadData, String autoscalePolicyName, String deploymentPolicyName, Properties properties) throws ADCException, UnregisteredCartridgeException {
-    log.info("String_Node_Str" + payloadData.getCompletePayloadData().toString());
+    if (payloadData != null) {
+        log.info("String_Node_Str" + payloadData.getCompletePayloadData().toString());
+    } else {
+        log.info("String_Node_Str");
+    }
     ApplicationManagementUtil.registerService(cartridgeInfo.getType(), cluster.getClusterDomain(), cluster.getClusterSubDomain(), payloadData.getCompletePayloadData(), payloadData.getBasicPayloadData().getTenantRange(), cluster.getHostName(), autoscalePolicyName, deploymentPolicyName, properties);


Input:
public ActorURL asRemoteURL() {
    return new RemoteActorURL(Actors.host, Actors.port, name);
}

Output:
 public ActorURL asRemoteURL() {
-    return new RemoteActorURL(Actors.host, Actors.port, name);
+    return new RemoteActorURL(host, String.valueOf(port), name);
 }


Input:
public void getWorkerInstances(HttpRequest request, HttpResponder responder, String namespaceId, String appId, String workerId) {
    try {
        int count = store.getWorkerInstances(new NamespaceId(namespaceId).app(appId).worker(workerId));
        responder.sendJson(HttpResponseStatus.OK, new Instances(count));
    } catch (SecurityException e) {
        responder.sendStatus(HttpResponseStatus.UNAUTHORIZED);
    } catch (Throwable e) {
        if (respondIfElementNotFound(e, responder)) {
            return;
        }
        throw e;
    }
}

Output:
     try {
-        int count = store.getWorkerInstances(new NamespaceId(namespaceId).app(appId).worker(workerId));
+        int count = store.getWorkerInstances(validateAndGetNamespace(namespaceId).app(appId).worker(workerId));
         responder.sendJson(HttpResponseStatus.OK, new Instances(count));


Input:
public static void main(String[] args) throws WikiBrainException {
    GADMConverter converter = new GADMConverter();
    converter.downloadAndConvert(new SpatialDataFolder(new File("String_Node_Str")));
}

Output:
     GADMConverter converter = new GADMConverter();
-    converter.downloadAndConvert(new SpatialDataFolder(new File("String_Node_Str")));
+    converter.downloadAndConvert(new File("String_Node_Str"));
 }


Input:
private byte[][] generateDeleteVals(int length) {
    byte[][] values = new byte[length][];
    for (int i = 0; i < values.length; i++) values[i] = NULL_VAL;
    return values;
}

Output:
     byte[][] values = new byte[length][];
-    for (int i = 0; i < values.length; i++) values[i] = NULL_VAL;
+    for (int i = 0; i < values.length; i++) {
+        values[i] = NULL_VAL;
+    }
     return values;


Input:
protected void drawMarkers() {
    if (mMarkerView == null || !mDrawMarkerViews || !valuesToHighlight())
        return;
    for (int i = 0; i < mIndicesToHightlight.length; i++) {
        int xIndex = mIndicesToHightlight[i].getXIndex();
        int dataSetIndex = mIndicesToHightlight[i].getDataSetIndex();
        if (xIndex <= mDeltaX && xIndex <= mDeltaX * mAnimator.getPhaseX()) {
            Entry e = getEntryByDataSetIndex(xIndex, dataSetIndex);
            if (e == null)
                continue;
            float[] pos = getMarkerPosition(e, dataSetIndex);
            if (!mViewPortHandler.isInBounds(pos[0], pos[1]))
                continue;
            mMarkerView.refreshContent(e, dataSetIndex);
            mMarkerView.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
            mMarkerView.layout(0, 0, mMarkerView.getMeasuredWidth(), mMarkerView.getMeasuredHeight());
            if (pos[1] - mMarkerView.getHeight() <= 0) {
                float y = mMarkerView.getHeight() - pos[1];
                mMarkerView.draw(mDrawCanvas, pos[0], pos[1] + y);
            } else {
                mMarkerView.draw(mDrawCanvas, pos[0], pos[1]);
            }
        }
    }
}

Output:
         if (xIndex <= mDeltaX && xIndex <= mDeltaX * mAnimator.getPhaseX()) {
-            Entry e = getEntryByDataSetIndex(xIndex, dataSetIndex);
+            Entry e = mData.getEntryForHighlight(mIndicesToHightlight[i]);
             if (e == null)


Input:
public void transpose() {
    final short numRow = this.numRow;
    final short numCol = this.numCol;
    final double[] copy = elements.clone();
    int k = 0;
    for (int j = 0; j < numRow; j++) {
        for (int i = 0; i < numCol; i++) {
            elements[i * numCol + j] = copy[k++];
        }
    }
    this.numRow = numCol;
    this.numCol = numRow;
}

Output:
         for (int i = 0; i < numCol; i++) {
-            elements[i * numCol + j] = copy[k++];
+            elements[i * numRow + j] = copy[k++];
         }


Input:
public void OpenFQHandle() {
    try {
        fq1 = Files.newBufferedWriter(fq1path, Charset.defaultCharset());
    } catch (IOException ex) {
        log.log(Level.SEVERE, "String_Node_Str");
    }
}

Output:
     } catch (IOException ex) {
-        log.log(Level.SEVERE, "String_Node_Str");
+        log.log(Level.SEVERE, "String_Node_Str", ex);
     }


Input:
public boolean marshal(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, AbstractSession session, NamespaceResolver namespaceResolver) {
    if (xmlAnyAttributeMapping.isReadOnly()) {
        return false;
    }
    Object collection = xmlAnyAttributeMapping.getAttributeValueFromObject(object);
    if (collection == null) {
        return false;
    }
    ContainerPolicy cp = getContainerPolicy();
    Object iter = cp.iteratorFor(collection);
    if (!cp.hasNext(iter)) {
        return false;
    }
    XPathFragment groupingElements = marshalRecord.openStartGroupingElements(namespaceResolver);
    List extraNamespaces = new ArrayList();
    NamespaceResolver nr = marshalRecord.getNamespaceResolver();
    while (cp.hasNext(iter)) {
        Map.Entry entry = (Map.Entry) cp.nextEntry(iter, session);
        Object key = entry.getKey();
        if (key instanceof QName) {
            QName name = (QName) key;
            String value = entry.getValue().toString();
            String qualifiedName = name.getLocalPart();
            if (nr != null) {
                String prefix = nr.resolveNamespaceURI(name.getNamespaceURI());
                if ((prefix != null) && prefix.length() > 0) {
                    qualifiedName = prefix + XMLConstants.COLON + qualifiedName;
                } else if (name.getNamespaceURI() != null && name.getNamespaceURI().length() > 0) {
                    String generatedPrefix = nr.generatePrefix();
                    if (marshalRecord.hasCustomNamespaceMapper()) {
                        String customPrefix = marshalRecord.getMarshaller().getNamespacePrefixMapper().getPreferredPrefix(name.getNamespaceURI(), generatedPrefix, true);
                        if (customPrefix != null && customPrefix.length() > 0) {
                            generatedPrefix = customPrefix;
                        }
                    }
                    qualifiedName = generatedPrefix + XMLConstants.COLON + qualifiedName;
                    nr.put(generatedPrefix, name.getNamespaceURI());
                    extraNamespaces.add(generatedPrefix);
                    marshalRecord.attribute(XMLConstants.XMLNS_URL, generatedPrefix, XMLConstants.XMLNS + XMLConstants.COLON + generatedPrefix, name.getNamespaceURI());
                }
            }
            marshalRecord.attribute(name.getNamespaceURI(), name.getLocalPart(), qualifiedName, value);
        }
    }
    for (int i = 0; i < extraNamespaces.size(); i++) {
        marshalRecord.getNamespaceResolver().removeNamespace((String) extraNamespaces.get(i));
    }
    marshalRecord.closeStartGroupingElements(groupingElements);
    return true;
}

Output:
                     extraNamespaces.add(generatedPrefix);
-                    marshalRecord.attribute(XMLConstants.XMLNS_URL, generatedPrefix, XMLConstants.XMLNS + XMLConstants.COLON + generatedPrefix, name.getNamespaceURI());
+                    marshalRecord.namespaceDeclaration(generatedPrefix, name.getNamespaceURI());
                 }


Input:
private static List<List<Double>> simulate(Comparator<Route> routeMetric) {
    List<List<Double>> tuple = new ArrayList<List<Double>>();
    tuple.add(new ArrayList<Double>());
    tuple.add(new ArrayList<Double>());
    Internet myInternet = new Internet(routeMetric);
    boolean stop = false;
    while (!stop) {
        stop = true;
        for (POP pop : myInternet.getAllPOPs()) {
            stop = pop.propogate() && stop;
        }
    }
    for (POP pop : myInternet.getAllPOPs()) {
        List<Route> routes = pop.getRoutes();
        for (Route r : routes) {
            tuple.get(0).add(r.getCost());
            tuple.get(1).add(r.getMiles());
        }
    }
    return tuple;
}

Output:
     Internet myInternet = new Internet(routeMetric);
-    boolean stop = false;
-    while (!stop) {
-        stop = true;
+    int iterations = 0;
+    for (; ; ) {
+        iterations++;
+        boolean someoneChanged = false;
         for (POP pop : myInternet.getAllPOPs()) {


Input:
public final Bounds getClientAreaBounds(boolean bReduceByInsets) {
    final Bounds boClientArea = BoundsImpl.copyInstance(pwa.getPlotBounds());
    if (bReduceByInsets) {
        boClientArea.adjust(pwa.getPlotInsets());
    }
    return boClientArea;
}

Output:
 public final Bounds getClientAreaBounds(boolean bReduceByInsets) {
-    final Bounds boClientArea = BoundsImpl.copyInstance(pwa.getPlotBounds());
+    final Bounds boClientArea = pwa.getPlotBounds().copyInstance();
     if (bReduceByInsets) {


Input:
public ArrayList<LinkGene> loopThroughLinks(TWEANN cppn, int outputIndex, Substrate s1, Substrate s2, int s1Index, int s2Index, List<Substrate> subs) {
    ArrayList<LinkGene> lg = new ArrayList<LinkGene>();
    for (int X1 = 0; X1 < s1.size.t1; X1++) {
        for (int Y1 = 0; Y1 < s1.size.t2; Y1++) {
            for (int X2 = 0; X2 < s2.size.t1; Y1++) {
                for (int Y2 = 0; Y2 < s2.size.t2; Y2++) {
                    double[] inputs = { (double) X1, (double) X2, (double) Y1, (double) Y2, BIAS };
                    lg.add(new LinkGene(getInnovationID(X1, Y1, s1Index, subs), getInnovationID(X2, Y2, s2Index, subs), cppn.process(inputs)[outputIndex], innovationID++, false));
                }
            }
        }
    }
    return lg;
}

Output:
 public ArrayList<LinkGene> loopThroughLinks(TWEANN cppn, int outputIndex, Substrate s1, Substrate s2, int s1Index, int s2Index, List<Substrate> subs) {
-    ArrayList<LinkGene> lg = new ArrayList<LinkGene>();
+    ArrayList<LinkGene> newLinks = new ArrayList<LinkGene>();
     for (int X1 = 0; X1 < s1.size.t1; X1++) {


Input:
private void parseResults() throws BadPacketException {
    int i = 11;
    int left = getResultCount();
    responses = new Response[left];
    try {
        for (; left > 0; left--) {
            long index = ByteOrder.ubytes2long(ByteOrder.leb2int(payload, i));
            long size = ByteOrder.ubytes2long(ByteOrder.leb2int(payload, i + 4));
            i += 8;
            int j = i;
            for (; ; j++) {
                if (payload[j] == (byte) 0)
                    break;
            }
            String name = new String(payload, i, j - i);
            responses[responses.length - left] = new Response(index, size, name);
            for (j = j + 1; ; j++) {
                if (payload[j] == (byte) 0)
                    break;
            }
            i = j + 1;
        }
        if (i < payload.length - 16)
            throw new BadPacketException("String_Node_Str" + "String_Node_Str");
        else if (i > payload.length - 16)
            throw new BadPacketException("String_Node_Str" + "String_Node_Str");
    } catch (ArrayIndexOutOfBoundsException e) {
        throw new BadPacketException();
    }
}

Output:
         }
-        if (i < payload.length - 16)
-            throw new BadPacketException("String_Node_Str" + "String_Node_Str");
-        else if (i > payload.length - 16)
+        if (i > payload.length - 16)
             throw new BadPacketException("String_Node_Str" + "String_Node_Str");


Input:
private boolean loadPage(FetchedFile file) {
    FetchedFile existing = altMap.get("String_Node_Str" + file.getPath());
    if (existing == null || existing.getTime() != file.getTime() || existing.getHash() != file.getHash()) {
        file.setNoProcess(true);
        changeList.add(file);
        altMap.put("String_Node_Str" + file.getPath(), file);
        return true;
    } else {
        return false;
    }
}

Output:
     if (existing == null || existing.getTime() != file.getTime() || existing.getHash() != file.getHash()) {
-        file.setNoProcess(true);
+        file.setProcessMode(FetchedFile.PROCESS_NONE);
         changeList.add(file);


Input:
private void render(EnergyStage energy, float progress, ForgeDirection orientation, String baseTexture, double x, double y, double z) {
    if (BuildCraftCore.render == RenderMode.NoDynamic) {
        return;
    }
    GL11.glPushMatrix();
    GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
    GL11.glEnable(GL11.GL_LIGHTING);
    GL11.glDisable(GL11.GL_BLEND);
    GL11.glEnable(GL11.GL_CULL_FACE);
    GL11.glColor3f(1, 1, 1);
    GL11.glTranslatef((float) x, (float) y, (float) z);
    float step;
    if (progress > 0.5) {
        step = 7.99F - (progress - 0.5F) * 2F * 7.99F;
    } else {
        step = progress * 2F * 7.99F;
    }
    float translatefact = step / 16;
    float[] angle = { 0, 0, 0 };
    float[] translate = { orientation.offsetX, orientation.offsetY, orientation.offsetZ };
    switch(orientation) {
        case EAST:
        case WEST:
        case DOWN:
            angle[2] = angleMap[orientation.ordinal()];
            break;
        case SOUTH:
        case NORTH:
            angle[0] = angleMap[orientation.ordinal()];
            break;
    }
    box.rotateAngleX = angle[0];
    box.rotateAngleY = angle[1];
    box.rotateAngleZ = angle[2];
    trunk.rotateAngleX = angle[0];
    trunk.rotateAngleY = angle[1];
    trunk.rotateAngleZ = angle[2];
    movingBox.rotateAngleX = angle[0];
    movingBox.rotateAngleY = angle[1];
    movingBox.rotateAngleZ = angle[2];
    chamber.rotateAngleX = angle[0];
    chamber.rotateAngleY = angle[1];
    chamber.rotateAngleZ = angle[2];
    float factor = (float) (1.0 / 16.0);
    func_110628_a(new ResourceLocation(baseTexture));
    box.render(factor);
    GL11.glTranslatef(translate[0] * translatefact, translate[1] * translatefact, translate[2] * translatefact);
    movingBox.render(factor);
    GL11.glTranslatef(-translate[0] * translatefact, -translate[1] * translatefact, -translate[2] * translatefact);
    func_110628_a(new ResourceLocation(DefaultProps.TEXTURE_PATH_BLOCKS + "String_Node_Str"));
    float chamberf = 2F / 16F;
    for (int i = 0; i <= step + 2; i += 2) {
        chamber.render(factor);
        GL11.glTranslatef(translate[0] * chamberf, translate[1] * chamberf, translate[2] * chamberf);
    }
    for (int i = 0; i <= step + 2; i += 2) {
        GL11.glTranslatef(-translate[0] * chamberf, -translate[1] * chamberf, -translate[2] * chamberf);
    }
    String texture = "String_Node_Str";
    switch(energy) {
        case BLUE:
            texture = DefaultProps.TEXTURE_PATH_BLOCKS + "String_Node_Str";
            break;
        case GREEN:
            texture = DefaultProps.TEXTURE_PATH_BLOCKS + "String_Node_Str";
            break;
        case YELLOW:
            texture = DefaultProps.TEXTURE_PATH_BLOCKS + "String_Node_Str";
            break;
        default:
            texture = DefaultProps.TEXTURE_PATH_BLOCKS + "String_Node_Str";
            break;
    }
    func_110628_a(new ResourceLocation(texture));
    trunk.render(factor);
    GL11.glPopAttrib();
    GL11.glPopMatrix();
}

Output:
     float factor = (float) (1.0 / 16.0);
-    func_110628_a(new ResourceLocation(baseTexture));
+    func_110628_a(baseTexture);
     box.render(factor);


Input:
public double getSquelch() {
    return Math.log(squelch);
}

Output:
 public double getSquelch() {
-    return Math.log(squelch);
+    return 10 * Math.log10(squelch);
 }


Input:
public static byte[] generate(byte[] P, byte[] S, int N, int r, int p, int dkLen) {
    if (P == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (S == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (N <= 1 || !isPowerOf2(N)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (r == 1 && N > 65536) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (r < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    int maxParallel = Integer.MAX_VALUE / (128 * r * 8);
    if (p < 1 || p > maxParallel) {
        throw new IllegalArgumentException("String_Node_Str" + maxParallel + "String_Node_Str" + r + "String_Node_Str");
    }
    if (dkLen < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    return MFcrypt(P, S, N, r, p, dkLen);
}

Output:
     }
-    if (r == 1 && N > 65536) {
+    if (r == 1 && N >= 65536) {
         throw new IllegalArgumentException("String_Node_Str");


Input:
private void processInstrumented(IProgressMonitor monitor, VCastDataStore dataStore, Map<String, CoverageUnit> fileNumToCoverageUnit, VCastInstrumentedFile instrumentedFile) throws Exception {
    VCastSourceFile sourceFile = null;
    try {
        sourceFile = dataStore.getSourceFile(instrumentedFile);
    } catch (OseeDataStoreException ex) {
        coverageImport.getLog().logError("String_Node_Str" + instrumentedFile.getId() + "String_Node_Str" + ex.getMessage());
    }
    if (sourceFile != null) {
        monitor.setTaskName(String.format("String_Node_Str", sourceFile.getDisplayName()));
        CoverageUnit sourceFileCoverageUnit = coverageImport.createCoverageUnit(null, sourceFile.getDisplayName(), "String_Node_Str");
        fileNumToCoverageUnit.put(String.valueOf(sourceFile.getUnitIndex()), sourceFileCoverageUnit);
        String lisFileName_badPath = instrumentedFile.getLISFile();
        if (!Strings.isValid(lisFileName_badPath)) {
            coverageImport.getLog().logError("String_Node_Str" + instrumentedFile.getId() + "String_Node_Str");
        }
        String normalizedPath = lisFileName_badPath.replaceAll("String_Node_Str", "String_Node_Str");
        File f = new File(normalizedPath);
        String lisFileName = f.getName();
        VCastLisFileParser lisFileParser = new VCastLisFileParser(lisFileName, input.getVCastDirectory());
        sourceFileCoverageUnit.setFileContentsLoader(lisFileParser);
        String sourceFileNamespace = generateNamespace(input.getNamespace(), sourceFile.getDisplayName());
        CoverageUnit sourceFileParent = coverageImport.getOrCreateParent(sourceFileNamespace);
        if (sourceFileParent != null) {
            sourceFileParent.addCoverageUnit(sourceFileCoverageUnit);
        } else {
            coverageImport.addCoverageUnit(sourceFileCoverageUnit);
        }
        Collection<VCastFunction> functions = Collections.emptyList();
        try {
            functions = dataStore.getFunctions(instrumentedFile);
        } catch (OseeDataStoreException ex) {
            coverageImport.getLog().logError("String_Node_Str" + instrumentedFile.getId() + "String_Node_Str" + ex.getMessage());
        }
        for (VCastFunction function : functions) {
            checkForCancelledStatus(monitor);
            processFunction(monitor, dataStore, lisFileParser, instrumentedFile, sourceFileCoverageUnit, function);
        }
        monitor.worked(1);
    }
}

Output:
 private void processInstrumented(IProgressMonitor monitor, VCastDataStore dataStore, Map<String, CoverageUnit> fileNumToCoverageUnit, VCastInstrumentedFile instrumentedFile) throws Exception {
-    VCastSourceFile sourceFile = null;
+    VCastSourceFileJoin sourceFile = null;
     try {


Input:
public boolean performFinish() {
    ChooseProjectTypePage page = getChosenProjectTypePage();
    Pair<String, IStartupAddon> addon = page.getSelectedAddon();
    if (page.isPageComplete() && addon.getSecond().validate()) {
        MyPreferences.setLastChosenProjectMode(addon.getFirst());
        MyPreferences.flush();
        setResult(addon.getSecond().create());
        return true;
    }
    return false;
}

Output:
     Pair<String, IStartupAddon> addon = page.getSelectedAddon();
-    if (page.isPageComplete() && addon.getSecond().validate()) {
+    if (page.isPageComplete()) {
         MyPreferences.setLastChosenProjectMode(addon.getFirst());


Input:
public boolean addMember(Authorizable authorizable) throws RepositoryException {
    try {
        if (isValid(authorizable)) {
            return getDelegate().addMember(((AuthorizableImpl) authorizable).dlg);
        } else {
            return false;
        }
    } finally {
        mgr.autosave();
    }
}

Output:
         if (isValid(authorizable)) {
-            return getDelegate().addMember(((AuthorizableImpl) authorizable).dlg);
+            return getDelegate().addMember(((AuthorizableImpl) authorizable).getDlg());
         } else {


Input:
public static SessionConfigMetaData parse(XMLStreamReader reader) throws XMLStreamException {
    SessionConfigMetaData sessionConfig = new SessionConfigMetaData();
    final int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        final String value = reader.getAttributeValue(i);
        if (attributeHasNamespace(reader, i)) {
            continue;
        }
        final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
        switch(attribute) {
            case ID:
                {
                    sessionConfig.setId(value);
                    break;
                }
            default:
                throw unexpectedAttribute(reader, i);
        }
    }
    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        final Element element = Element.forName(reader.getLocalName());
        switch(element) {
            case SESSION_TIMEOUT:
                try {
                    sessionConfig.setSessionTimeout(Integer.valueOf(getElementText(reader)));
                } catch (NumberFormatException e) {
                    throw unexpectedValue(reader, e);
                }
                break;
            case COOKIE_CONFIG:
                sessionConfig.setCookieConfig(CookieConfigMetaDataParser.parse(reader));
                break;
            case TRACKING_MODE:
                List<SessionTrackingModeType> trackingModes = sessionConfig.getSessionTrackingModes();
                if (trackingModes == null) {
                    trackingModes = new ArrayList<SessionTrackingModeType>();
                    sessionConfig.setSessionTrackingModes(trackingModes);
                }
                trackingModes.add(SessionTrackingModeType.valueOf(getElementText(reader)));
                break;
            default:
                throw unexpectedElement(reader);
        }
    }
    return sessionConfig;
}

Output:
                 }
-                trackingModes.add(SessionTrackingModeType.valueOf(getElementText(reader)));
+                try {
+                    trackingModes.add(SessionTrackingModeType.valueOf(getElementText(reader)));
+                } catch (IllegalArgumentException e) {
+                    throw unexpectedValue(reader, e);
+                }
                 break;


Input:
public static HighlightInfo highlightNamed(HighlightInfoHolder holder, PsiElement element, PsiElement target) {
    if (target == null) {
        return null;
    }
    IElementType elementType = target.getNode().getElementType();
    if (CSharpTokenSets.KEYWORDS.contains(elementType)) {
        return null;
    }
    TextAttributesKey key = null;
    if (element instanceof CSharpTypeDeclaration) {
        if (DotNetInheritUtil.isParent(DotNetTypes.System_Attribute, (DotNetTypeDeclaration) element, true)) {
            key = CSharpHighlightKey.ATTRIBUTE_NAME;
        } else {
            key = CSharpHighlightKey.CLASS_NAME;
        }
    } else if (element instanceof DotNetConstructorDeclaration) {
        PsiElement parent = element.getParent();
        highlightNamed(holder, parent, target);
        return null;
    } else if (element instanceof DotNetGenericParameter || element instanceof CSharpTypeDefStatementImpl) {
        key = CSharpHighlightKey.GENERIC_PARAMETER_NAME;
    } else if (element instanceof DotNetParameter || element instanceof CSharpLambdaParameter) {
        key = CSharpHighlightKey.PARAMETER;
    } else if (element instanceof DotNetMethodDeclaration) {
        if (CSharpMethodImplUtil.isExtensionWrapper(element)) {
            key = CSharpHighlightKey.EXTENSION_METHOD;
        } else {
            key = ((DotNetModifierListOwner) element).hasModifier(CSharpModifier.STATIC) ? CSharpHighlightKey.STATIC_METHOD : CSharpHighlightKey.INSTANCE_METHOD;
        }
    } else if (element instanceof CSharpMacroDefine) {
        key = CSharpHighlightKey.MACRO_VARIABLE;
    } else if (element instanceof CSharpLocalVariable) {
        key = DefaultLanguageHighlighterColors.LOCAL_VARIABLE;
    } else if (element instanceof DotNetVariable) {
        key = ((DotNetVariable) element).hasModifier(CSharpModifier.STATIC) ? CSharpHighlightKey.STATIC_FIELD : CSharpHighlightKey.INSTANCE_FIELD;
    } else {
        return null;
    }
    HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.INFORMATION).range(target).textAttributes(key).create();
    holder.add(info);
    if (element instanceof DotNetModifierListOwner && DotNetAttributeUtil.hasAttribute((DotNetModifierListOwner) element, DotNetTypes.System_ObsoleteAttribute)) {
        holder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.INFORMATION).range(target).textAttributes(CodeInsightColors.DEPRECATED_ATTRIBUTES).create());
    }
    if (CSharpHighlightUtil.isGeneratedElement(element)) {
        holder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.INFORMATION).range(target).textAttributes(EditorColors.INJECTED_LANGUAGE_FRAGMENT).create());
    }
    return info;
}

Output:
 public static HighlightInfo highlightNamed(HighlightInfoHolder holder, PsiElement element, PsiElement target) {
-    if (target == null) {
+    if (target == null || element == null) {
         return null;


Input:
public void miscTags(ReplaceableTagEvent event) {
    if (!event.matches("String_Node_Str"))
        return;
    String type = event.getType() != null ? event.getType() : "String_Node_Str";
    String typeContext = event.getTypeContext() != null ? event.getTypeContext() : "String_Node_Str";
    String subType = event.getSubType() != null ? event.getSubType() : "String_Node_Str";
    String subTypeContext = event.getSubTypeContext() != null ? event.getSubTypeContext().toUpperCase() : "String_Node_Str";
    String specifier = event.getSpecifier() != null ? event.getSpecifier() : "String_Node_Str";
    String specifierContext = event.getSpecifierContext() != null ? event.getSpecifierContext().toUpperCase() : "String_Node_Str";
    Attribute attribute = new Attribute(event.raw_tag, event.getScriptEntry()).fulfill(1);
    if (type.equalsIgnoreCase("String_Node_Str")) {
        if (subType.equalsIgnoreCase("String_Node_Str")) {
            if (specifier.equalsIgnoreCase("String_Node_Str")) {
                if (aH.matchesInteger(subTypeContext) && aH.matchesInteger(specifierContext)) {
                    int min = aH.getIntegerFrom(subTypeContext);
                    int max = aH.getIntegerFrom(specifierContext);
                    if (min > max) {
                        int store = min;
                        min = max;
                        max = store;
                    }
                    event.setReplaced(new Element(String.valueOf(Utilities.getRandom().nextInt(max - min + 1) + min)).getAttribute(attribute.fulfill(3)));
                }
            }
        } else if (subType.equalsIgnoreCase("String_Node_Str")) {
            dList list = dList.valueOf(subTypeContext);
            event.setReplaced(new Element(list.get(new Random().nextInt(list.size()))).getAttribute(attribute.fulfill(2)));
        } else if (subType.equalsIgnoreCase("String_Node_Str"))
            event.setReplaced(new Element(UUID.randomUUID().toString()).getAttribute(attribute.fulfill(2)));
        if (attribute.startsWith("String_Node_Str"))
            event.setReplaced(new Element(ScriptQueue._getNextId()).getAttribute(attribute.fulfill(2)));
    } else if (type.equalsIgnoreCase("String_Node_Str") || type.equalsIgnoreCase("String_Node_Str") || type.equalsIgnoreCase("String_Node_Str")) {
        String text = event.getTypeContext();
        int from = 1;
        int to = text.length() + 1;
        int tags = 2;
        if (subType.equalsIgnoreCase("String_Node_Str")) {
            from = text.toUpperCase().indexOf(subTypeContext) + subTypeContext.length() + 1;
        }
        if (subType.equalsIgnoreCase("String_Node_Str")) {
            to = text.toUpperCase().indexOf(subTypeContext) + 1;
        }
        try {
            if (subType.equalsIgnoreCase("String_Node_Str"))
                from = Integer.valueOf(subTypeContext);
        } catch (NumberFormatException e) {
        }
        try {
            if (specifier.equalsIgnoreCase("String_Node_Str")) {
                to = Integer.valueOf(specifierContext);
                tags = 3;
            }
        } catch (NumberFormatException e) {
        }
        if (to > text.length())
            to = text.length() + 1;
        event.setReplaced(new Element(text.substring(from - 1, to - 1)).getAttribute(attribute.fulfill(tags)));
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        String item_to_replace = event.getTypeContext();
        String replace = event.getSubTypeContext();
        String replacement = event.getSpecifierContext();
        event.setReplaced(new Element(item_to_replace.replace(replace, replacement)).getAttribute(attribute.fulfill(3)));
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        dEntity ent = dEntity.valueOf(event.getTypeContext());
        event.setReplaced(new Element((ent != null && ent.isUnique() && ent.isSpawned()) ? "String_Node_Str" : "String_Node_Str").getAttribute(attribute.fulfill(1)));
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        String item_to_uppercase = event.getTypeContext();
        event.setReplaced(new Element(item_to_uppercase.toUpperCase()).getAttribute(attribute.fulfill(1)));
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        String item_to_uppercase = event.getTypeContext();
        event.setReplaced(new Element(item_to_uppercase.toLowerCase()).getAttribute(attribute.fulfill(1)));
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        Calendar calendar = Calendar.getInstance();
        Date currentDate = new Date();
        SimpleDateFormat format = new SimpleDateFormat();
        if (subType.equalsIgnoreCase("String_Node_Str")) {
            if (specifier.equalsIgnoreCase("String_Node_Str")) {
                format.applyPattern("String_Node_Str");
                event.setReplaced(new Element(format.format(currentDate)).getAttribute(attribute.fulfill(3)));
            } else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.YEAR)).getAttribute(attribute.fulfill(3)));
            else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.MONTH) + 1).getAttribute(attribute.fulfill(3)));
            else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.DAY_OF_MONTH)).getAttribute(attribute.fulfill(3)));
            else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.HOUR_OF_DAY)).getAttribute(attribute.fulfill(3)));
            else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.MINUTE)).getAttribute(attribute.fulfill(3)));
            else if (specifier.equalsIgnoreCase("String_Node_Str"))
                event.setReplaced(new Element(calendar.get(Calendar.SECOND)).getAttribute(attribute.fulfill(3)));
            else {
                format.applyPattern("String_Node_Str");
                event.setReplaced(format.format(currentDate));
            }
        } else {
            format.applyPattern("String_Node_Str");
            event.setReplaced(format.format(currentDate));
        }
    } else if (type.equalsIgnoreCase("String_Node_Str")) {
        event.setReplaced(new Element(typeContext).getAttribute(attribute.fulfill(1)));
    }
}

Output:
             event.setReplaced(new Element(UUID.randomUUID().toString()).getAttribute(attribute.fulfill(2)));
-        if (attribute.startsWith("String_Node_Str"))
+        else if (subType.equalsIgnoreCase("String_Node_Str"))
             event.setReplaced(new Element(ScriptQueue._getNextId()).getAttribute(attribute.fulfill(2)));


Input:
public IGetParameterDefinitionTask createGetParameterDefinitionTask(IReportRunnable runnable, InputOptions options) {
    IGetParameterDefinitionTask task = null;
    try {
        HttpServletRequest request = (HttpServletRequest) options.getOption(InputOptions.OPT_REQUEST);
        Locale locale = (Locale) options.getOption(InputOptions.OPT_LOCALE);
        task = engine.createGetParameterDefinitionTask(runnable);
        task.setLocale(locale);
        Map context = BirtUtility.getAppContext(request, ReportEngineService.class.getClassLoader());
        task.setAppContext(context);
    } catch (Exception e) {
    }
    return task;
}

Output:
         task.setLocale(locale);
-        Map context = BirtUtility.getAppContext(request, ReportEngineService.class.getClassLoader());
+        Map context = BirtUtility.getAppContext(request);
         task.setAppContext(context);


Input:
private void setupFor(ProjectModel model, boolean editing) {
    this.model = model;
    this.editing = editing;
    addressEdit.setText(model.address.get());
    titleEdit.setText(model.title.get());
    descriptionEdit.setText(model.memo.get());
    Coin goalCoin = Coin.valueOf(model.goalAmount.get());
    if (goalCoin.value != 1) {
        goalAmountEdit.setText(goalCoin.toPlainString());
    }
    minPledgeEdit.setPromptText(model.getMinPledgeAmount().toPlainString());
    if (model.image.get() == null) {
        setupDefaultCoverImage();
    } else {
        InputStream stream = model.image.get().newInput();
        coverImageView.setImage(new Image(stream));
        uncheck(stream::close);
    }
    this.model.title.bind(titleEdit.textProperty());
    this.model.memo.bind(descriptionEdit.textProperty());
    coverPhotoSiteLink.setText(COVERPHOTO_SITE);
    ValidationLink goalValid = new ValidationLink(goalAmountEdit, str -> !LHUtils.didThrow(() -> valueOrThrow(str)));
    goalAmountEdit.textProperty().addListener((obj, prev, cur) -> {
        if (goalValid.isValid.get())
            this.model.goalAmount.set(valueOrThrow(cur).value);
    });
    model.minPledgeAmountProperty().addListener(o -> {
        minPledgeEdit.setPromptText(model.getMinPledgeAmount().toPlainString());
    });
    ValidationLink minPledgeValue = new ValidationLink(minPledgeEdit, str -> {
        if (str.isEmpty())
            return true;
        Coin coin = valueOrNull(str);
        if (coin == null)
            return false;
        Coin amount = model.getMinPledgeAmount();
        return coin.equals(amount) || (coin.isGreaterThan(amount) && coin.isLessThan(Coin.valueOf(this.model.goalAmount.get())));
    });
    ValidationLink addressValid = new ValidationLink(addressEdit, str -> !didThrow(() -> new Address(Main.params, str)));
    addressEdit.textProperty().addListener((obj, prev, cur) -> {
        if (addressValid.isValid.get())
            this.model.address.set(cur);
    });
    ValidationLink.autoDisableButton(nextButton, goalValid, new ValidationLink(titleEdit, str -> !str.isEmpty()), minPledgeValue, addressValid);
    roundCorners(coverImageView, 10);
    Label maxPledgesWarning = new Label(String.format("String_Node_Str", ProjectModel.MAX_NUM_INPUTS));
    maxPledgesWarning.setStyle("String_Node_Str");
    maxPledgesPopOver = new PopOver(maxPledgesWarning);
    maxPledgesPopOver.setDetachable(false);
    maxPledgesPopOver.setArrowLocation(PopOver.ArrowLocation.BOTTOM_CENTER);
    minPledgeEdit.focusedProperty().addListener(o -> {
        if (minPledgeEdit.isFocused())
            maxPledgesPopOver.show(minPledgeEdit);
        else
            maxPledgesPopOver.hide();
    });
}

Output:
     }
-    minPledgeEdit.setPromptText(model.getMinPledgeAmount().toPlainString());
+    if (editing)
+        minPledgeEdit.setText(model.getMinPledgeAmount().toPlainString());
+    else
+        minPledgeEdit.setPromptText(model.getMinPledgeAmount().toPlainString());
     if (model.image.get() == null) {


Input:
private void updateActiveGroup(int userId) {
    File path = Environment.getUserSystemDirectory(userId);
    nativeSetActiveGroup(userId, path.getAbsolutePath().getBytes());
}

Output:
 private void updateActiveGroup(int userId) {
-    File path = Environment.getUserSystemDirectory(userId);
-    nativeSetActiveGroup(userId, path.getAbsolutePath().getBytes());
+    if (mHalDeviceId != 0) {
+        File path = Environment.getUserSystemDirectory(userId);
+        nativeSetActiveGroup(userId, path.getAbsolutePath().getBytes());
+    }
 }


Input:
public Object executeTransform(final Object input) {
    final OrientVertex vertex;
    if (input instanceof OIdentifiable)
        vertex = graph.getVertex(input);
    else if (input instanceof OrientVertex)
        vertex = (OrientVertex) input;
    else
        throw new OTransformException("String_Node_Str" + input + "String_Node_Str");
    Object joinValue = vertex.getProperty(joinFieldName);
    Object result = lookup(joinValue);
    if (result == null) {
        switch(unresolvedLinkAction) {
            case CREATE:
                if (lookup != null) {
                    final String[] lookupParts = lookup.split("String_Node_Str");
                    final OrientVertex linkedV = graph.addTemporaryVertex(lookupParts[0]);
                    linkedV.setProperty(lookupParts[1], joinValue);
                    linkedV.save();
                    result = linkedV;
                } else
                    throw new OConfigurationException("String_Node_Str");
                break;
            case ERROR:
                processor.getStats().incrementErrors();
                log("String_Node_Str", getName(), joinValue);
                break;
            case WARNING:
                processor.getStats().incrementWarnings();
                log("String_Node_Str", getName(), joinValue);
                break;
            case SKIP:
                return null;
            case HALT:
                throw new OETLProcessHaltedException("String_Node_Str" + joinValue + "String_Node_Str");
        }
        if (result != null) {
            final OrientVertex targetVertex = graph.getVertex(result);
            vertex.addEdge(edgeClass, targetVertex);
        }
    }
    return input;
}

Output:
             final OrientVertex targetVertex = graph.getVertex(result);
-            vertex.addEdge(edgeClass, targetVertex);
+            if (directionOut)
+                vertex.addEdge(edgeClass, targetVertex);
+            else
+                targetVertex.addEdge(edgeClass, vertex);
         }


Input:
public int hashCode() {
    int result = super.hashCode();
    result = 31 * result + (freeLook ? 1 : 0);
    return result;
}

Output:
     int result = super.hashCode();
-    result = 31 * result + (freeLook ? 1 : 0);
+    result = 31 * result + (freeLook ? FREE_LOOK_ENABLED_VALUE : FREE_LOOK_DISABLED_VALUE);
     return result;


Input:
public PartRevision createPartRevision(PartRevisionKey revisionKey, String pDescription, String pWorkflowModelId, ACLUserEntry[] pACLUserEntries, ACLUserGroupEntry[] pACLUserGroupEntries, Map<String, Collection<String>> userRoleMapping, Map<String, Collection<String>> groupRoleMapping) throws UserNotFoundException, AccessRightException, WorkspaceNotFoundException, PartRevisionNotFoundException, NotAllowedException, FileAlreadyExistsException, CreationException, RoleNotFoundException, WorkflowModelNotFoundException, PartRevisionAlreadyExistsException, UserGroupNotFoundException {
    User user = userManager.checkWorkspaceWriteAccess(revisionKey.getPartMaster().getWorkspace());
    Locale locale = new Locale(user.getLanguage());
    PartRevisionDAO partRevisionDAO = new PartRevisionDAO(locale, em);
    PartRevision originalPartR = partRevisionDAO.loadPartR(revisionKey);
    if (originalPartR.isCheckedOut()) {
        throw new NotAllowedException(locale, "String_Node_Str");
    }
    if (originalPartR.getNumberOfIterations() == 0) {
        throw new NotAllowedException(locale, "String_Node_Str");
    }
    PartRevision partR = originalPartR.getPartMaster().createNextRevision(user);
    PartIteration lastPartI = originalPartR.getLastIteration();
    PartIteration firstPartI = partR.createNextIteration(user);
    if (lastPartI != null) {
        BinaryResourceDAO binDAO = new BinaryResourceDAO(locale, em);
        for (BinaryResource sourceFile : lastPartI.getAttachedFiles()) {
            String fileName = sourceFile.getName();
            long length = sourceFile.getContentLength();
            Date lastModified = sourceFile.getLastModified();
            String fullName = partR.getWorkspaceId() + "String_Node_Str" + partR.getPartNumber() + "String_Node_Str" + partR.getVersion() + "String_Node_Str" + fileName;
            BinaryResource targetFile = new BinaryResource(fullName, length, lastModified);
            binDAO.createBinaryResource(targetFile);
            firstPartI.addAttachedFile(targetFile);
            try {
                dataManager.copyData(sourceFile, targetFile);
            } catch (StorageException e) {
                LOGGER.log(Level.INFO, null, e);
            }
        }
        List<PartUsageLink> newComponents = new LinkedList<>();
        List<PartUsageLink> oldComponents = lastPartI.getComponents();
        for (PartUsageLink usage : lastPartI.getComponents()) {
            PartUsageLink newUsage = usage.clone();
            em.persist(newUsage);
            newComponents.add(newUsage);
        }
        firstPartI.setComponents(newComponents);
        em.flush();
        PathToPathLinkDAO pathToPathLinkDAO = new PathToPathLinkDAO(locale, em);
        pathToPathLinkDAO.cloneAndUpgradePathToPathLinks(oldComponents, newComponents);
        for (Geometry sourceFile : lastPartI.getGeometries()) {
            String fileName = sourceFile.getName();
            long length = sourceFile.getContentLength();
            int quality = sourceFile.getQuality();
            Date lastModified = sourceFile.getLastModified();
            String fullName = partR.getWorkspaceId() + "String_Node_Str" + partR.getPartNumber() + "String_Node_Str" + partR.getVersion() + "String_Node_Str" + fileName;
            Geometry targetFile = new Geometry(quality, fullName, length, lastModified);
            binDAO.createBinaryResource(targetFile);
            firstPartI.addGeometry(targetFile);
            try {
                dataManager.copyData(sourceFile, targetFile);
            } catch (StorageException e) {
                LOGGER.log(Level.INFO, null, e);
            }
        }
        BinaryResource nativeCADFile = lastPartI.getNativeCADFile();
        if (nativeCADFile != null) {
            String fileName = nativeCADFile.getName();
            long length = nativeCADFile.getContentLength();
            Date lastModified = nativeCADFile.getLastModified();
            String fullName = partR.getWorkspaceId() + "String_Node_Str" + partR.getPartNumber() + "String_Node_Str" + partR.getVersion() + "String_Node_Str" + fileName;
            BinaryResource targetFile = new BinaryResource(fullName, length, lastModified);
            binDAO.createBinaryResource(targetFile);
            firstPartI.setNativeCADFile(targetFile);
            try {
                dataManager.copyData(nativeCADFile, targetFile);
            } catch (StorageException e) {
                LOGGER.log(Level.INFO, null, e);
            }
        }
        Set<DocumentLink> links = new HashSet<>();
        for (DocumentLink link : lastPartI.getLinkedDocuments()) {
            DocumentLink newLink = link.clone();
            links.add(newLink);
        }
        firstPartI.setLinkedDocuments(links);
        List<InstanceAttribute> attrs = new ArrayList<>();
        for (InstanceAttribute attr : lastPartI.getInstanceAttributes()) {
            InstanceAttribute clonedAttribute = attr.clone();
            attrs.add(clonedAttribute);
        }
        firstPartI.setInstanceAttributes(attrs);
    }
    if (pWorkflowModelId != null) {
        UserDAO userDAO = new UserDAO(locale, em);
        UserGroupDAO groupDAO = new UserGroupDAO(locale, em);
        RoleDAO roleDAO = new RoleDAO(locale, em);
        Map<Role, Collection<User>> roleUserMap = new HashMap<>();
        for (Map.Entry<String, Collection<String>> pair : userRoleMapping.entrySet()) {
            String roleName = pair.getKey();
            Collection<String> userLogins = pair.getValue();
            Role role = roleDAO.loadRole(new RoleKey(originalPartR.getWorkspaceId(), roleName));
            Set<User> users = new HashSet<>();
            roleUserMap.put(role, users);
            for (String login : userLogins) {
                User u = userDAO.loadUser(new UserKey(originalPartR.getWorkspaceId(), login));
                users.add(u);
            }
        }
        Map<Role, Collection<UserGroup>> roleGroupMap = new HashMap<>();
        for (Map.Entry<String, Collection<String>> pair : groupRoleMapping.entrySet()) {
            String roleName = pair.getKey();
            Collection<String> groupIds = pair.getValue();
            Role role = roleDAO.loadRole(new RoleKey(originalPartR.getWorkspaceId(), roleName));
            Set<UserGroup> groups = new HashSet<>();
            roleGroupMap.put(role, groups);
            for (String groupId : groupIds) {
                UserGroup g = groupDAO.loadUserGroup(new UserGroupKey(originalPartR.getWorkspaceId(), groupId));
                groups.add(g);
            }
        }
        WorkflowModel workflowModel = new WorkflowModelDAO(locale, em).loadWorkflowModel(new WorkflowModelKey(user.getWorkspaceId(), pWorkflowModelId));
        Workflow workflow = workflowModel.createWorkflow(roleUserMap, roleGroupMap);
        partR.setWorkflow(workflow);
        for (Task task : workflow.getTasks()) {
            if (!task.hasPotentialWorker()) {
                throw new NotAllowedException(locale, "String_Node_Str");
            }
        }
        Collection<Task> runningTasks = workflow.getRunningTasks();
        for (Task runningTask : runningTasks) {
            runningTask.start();
        }
        em.flush();
        mailer.sendApproval(runningTasks, partR);
    }
    partR.setDescription(pDescription);
    if ((pACLUserEntries != null && pACLUserEntries.length > 0) || (pACLUserGroupEntries != null && pACLUserGroupEntries.length > 0)) {
        ACL acl = new ACL();
        if (pACLUserEntries != null) {
            for (ACLUserEntry entry : pACLUserEntries) {
                acl.addEntry(em.getReference(User.class, new UserKey(user.getWorkspaceId(), entry.getPrincipalLogin())), entry.getPermission());
            }
        }
        if (pACLUserGroupEntries != null) {
            for (ACLUserGroupEntry entry : pACLUserGroupEntries) {
                acl.addEntry(em.getReference(UserGroup.class, new UserGroupKey(user.getWorkspaceId(), entry.getPrincipalId())), entry.getPermission());
            }
        }
        partR.setACL(acl);
    }
    Date now = new Date();
    partR.setCreationDate(now);
    partR.setCheckOutUser(user);
    partR.setCheckOutDate(now);
    firstPartI.setCreationDate(now);
    firstPartI.setModificationDate(now);
    partRevisionDAO.createPartR(partR);
    return partR;
}

Output:
         }
-        Collection<Task> runningTasks = workflow.getRunningTasks();
+        runningTasks = workflow.getRunningTasks();
         for (Task runningTask : runningTasks) {


Input:
public void setCollapseMode(boolean value) {
    if (draw_mode == StapGraph.CONSTANT_DRAWMODE_AGGREGATE)
        return;
    if (collapse_mode != value) {
        if (collapse_mode && !value) {
            if (!getRootData().isOnlyChildWithThisName()) {
                rootVisibleNodeNumber = getRootData().uncollapsedPiece;
            }
        }
        if (!collapse_mode && value) {
            if (!getRootData().isOnlyChildWithThisName()) {
                int temp = getRootData().getPartOfCollapsedNode();
                if (temp != StapData.NOT_PART_OF_COLLAPSED_NODE) {
                    rootVisibleNodeNumber = temp;
                }
            }
        }
        collapse_mode = value;
        callgraphView.getMode_collapsednodes().setChecked(value);
    }
    nextMarkedNode = -1;
}

Output:
     if (collapse_mode != value) {
-        if (collapse_mode && !value) {
-            if (!getRootData().isOnlyChildWithThisName()) {
-                rootVisibleNodeNumber = getRootData().uncollapsedPiece;
+        if (draw_mode != StapGraph.CONSTANT_DRAWMODE_LEVEL) {
+            if (collapse_mode && !value) {
+                if (!getRootData().isOnlyChildWithThisName()) {
+                    rootVisibleNodeNumber = getRootData().uncollapsedPiece;
+                }
             }


Input:
public static int getClusterCoalNum_rootedMap(Tree tr, STITreeCluster cluster) {
    Map map = new HashMap();
    List taxa = GlobalMaps.taxonIdentifier.getTaxonList();
    int count = 0;
    for (TNode node : tr.postTraverse()) {
        if (node.isLeaf()) {
            String stTaxon = (String) GlobalMaps.taxonNameMap.getTaxonName(node.getName());
            int index = taxa.indexOf(stTaxon);
            BitSet bs = new BitSet(taxa.size());
            bs.set(index);
            if (cluster.containsCluster(bs)) {
                count++;
            }
            map.put(node, bs);
        } else {
            BitSet bs = new BitSet(taxa.size());
            int intersect = 0;
            int childCount = node.getChildCount();
            for (TNode child : node.getChildren()) {
                BitSet v = (BitSet) map.get(child);
                bs.or(v);
                if ((childCount <= 2) || (!cluster.containsCluster(v)))
                    continue;
                intersect++;
            }
            if (cluster.containsCluster(bs)) {
                count -= node.getChildCount();
                count++;
            } else if (intersect > 1) {
                count -= intersect;
                count++;
            }
            map.put(node, bs);
        }
    }
    return Math.max(count - 1, 0);
}

Output:
             String stTaxon = (String) GlobalMaps.taxonNameMap.getTaxonName(node.getName());
-            int index = taxa.indexOf(stTaxon);
-            BitSet bs = new BitSet(taxa.size());
+            int index = GlobalMaps.taxonIdentifier.taxonId(stTaxon);
+            BitSet bs = new BitSet(GlobalMaps.taxonIdentifier.taxonCount());
             bs.set(index);


Input:
public static int getNativeRGBFormat(RGBFormat rgb) {
    int fmt = 0;
    if (rgb.getBitsPerPixel() == 32) {
        switch(rgb.getRedMask()) {
            case 1:
            case 0xff:
                fmt = FFMPEG.PIX_FMT_BGR32;
                break;
            case 2:
            case (0xff << 8):
                fmt = FFMPEG.PIX_FMT_BGR32_1;
                break;
            case 3:
            case (0xff << 16):
                fmt = FFMPEG.PIX_FMT_RGB32;
                break;
            case 4:
            case (0xff << 24):
                fmt = FFMPEG.PIX_FMT_RGB32_1;
                break;
            default:
                fmt = FFMPEG.PIX_FMT_RGB32;
                break;
        }
    } else {
        fmt = FFMPEG.PIX_FMT_RGB24;
    }
    return fmt;
}

Output:
 public static int getNativeRGBFormat(RGBFormat rgb) {
-    int fmt = 0;
-    if (rgb.getBitsPerPixel() == 32) {
+    int fmt;
+    if (rgb.getBitsPerPixel() == 32)
         switch(rgb.getRedMask()) {


Input:
public synchronized SchemaCatalog getCatalog() {
    if (catalog == null)
        catalog = loadCatalog();
    return catalog;
}

Output:
 public synchronized SchemaCatalog getCatalog() {
-    if (catalog == null)
-        catalog = loadCatalog();
+    if (catalog != null)
+        return catalog;
+    catalog = loadCatalog();
     return catalog;


Input:
public double getValue(Vector parameters) {
    LogisticRegression tmpFunction = new LogisticRegression(this.logisticRegression.getNumClasses(), this.logisticRegression.getNumFeatures(), parameters);
    return -tmpFunction.dataSetLogLikelihood(dataSet) + parameters.norm(2) / (2 * gaussianPriorVariance);
}

Output:
     LogisticRegression tmpFunction = new LogisticRegression(this.logisticRegression.getNumClasses(), this.logisticRegression.getNumFeatures(), parameters);
-    return -tmpFunction.dataSetLogLikelihood(dataSet) + parameters.norm(2) / (2 * gaussianPriorVariance);
+    return -tmpFunction.dataSetLogLikelihood(dataSet) + parameters.dot(parameters) / (2 * gaussianPriorVariance);
 }


Input:
public static Date parse(String dateString, String format) {
    try {
        Date date = new SimpleDateFormat(format).parse(dateString);
        return date;
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
        return null;
    }
}

Output:
     try {
-        Date date = new SimpleDateFormat(format).parse(dateString);
+        SimpleDateFormat sdf = new SimpleDateFormat(format);
+        sdf.setLenient(false);
+        Date date = sdf.parse(dateString);
         return date;


Input:
private void calculateForPosition(ShortPoint2D position) {
    short x = position.x;
    short y = position.y;
    byte player = grid.getPlayerIdAt(x, y);
    boolean isBorder = false;
    if (grid.getBlockedPartition(x, y) > 0) {
        for (EDirection currDir : EDirection.values) {
            short currNeighborX = currDir.getNextTileX(x);
            short currNeighborY = currDir.getNextTileY(y);
            if (!grid.isInBounds(currNeighborX, currNeighborY)) {
                continue;
            }
            byte neighborPlayer = grid.getPlayerIdAt(currNeighborX, currNeighborY);
            boolean neighborIsBorder = false;
            if (neighborPlayer != player && grid.getBlockedPartition(currNeighborX, currNeighborY) > 0) {
                isBorder = true;
            }
            if (neighborPlayer >= 0) {
                for (EDirection currNeighborDir : EDirection.values) {
                    short nextX = currNeighborDir.getNextTileX(currNeighborX);
                    short nextY = currNeighborDir.getNextTileY(currNeighborY);
                    if (grid.isInBounds(nextX, nextY) && grid.getPlayerIdAt(nextX, nextY) != neighborPlayer && grid.getBlockedPartition(nextX, nextY) > 0) {
                        neighborIsBorder = true;
                        break;
                    }
                }
            }
            grid.setBorderAt(currNeighborX, currNeighborY, neighborIsBorder);
        }
    }
    grid.setBorderAt(x, y, isBorder && player >= 0);
}

Output:
             boolean neighborIsBorder = false;
-            if (neighborPlayer != player && grid.getBlockedPartition(currNeighborX, currNeighborY) > 0) {
+            if (neighborPlayer != player) {
                 isBorder = true;


Input:
private ParseTree parseObjectPatternField(PatternKind kind) {
    SourcePosition start = getTreeStartLocation();
    if (peekType() == TokenType.OPEN_SQUARE) {
        ParseTree key = parseComputedPropertyName();
        eat(TokenType.COLON);
        ParseTree value = parseObjectPatternFieldTail(kind);
        return new ComputedPropertyDefinitionTree(getTreeLocation(start), key, value);
    }
    Token name;
    if (peekId() || Keywords.isKeyword(peekType())) {
        name = eatIdOrKeywordAsId();
        if (!peek(TokenType.COLON)) {
            IdentifierToken idToken = (IdentifierToken) name;
            if (Keywords.isKeyword(idToken.value)) {
                reportError("String_Node_Str" + name + "String_Node_Str");
            }
            if (peek(TokenType.EQUAL)) {
                IdentifierExpressionTree idTree = new IdentifierExpressionTree(getTreeLocation(start), idToken);
                eat(TokenType.EQUAL);
                ParseTree defaultValue = parseAssignmentExpression();
                return new DefaultParameterTree(getTreeLocation(start), idTree, defaultValue);
            }
            return new PropertyNameAssignmentTree(getTreeLocation(start), name, null);
        }
    } else {
        name = parseLiteralExpression().literalToken;
    }
    eat(TokenType.COLON);
    ParseTree value = parseObjectPatternFieldTail(kind);
    return new PropertyNameAssignmentTree(getTreeLocation(start), name, value);
}

Output:
             IdentifierToken idToken = (IdentifierToken) name;
-            if (Keywords.isKeyword(idToken.value)) {
+            if (Keywords.isKeyword(idToken.value) && !Keywords.isTypeScriptSpecificKeyword(idToken.value)) {
                 reportError("String_Node_Str" + name + "String_Node_Str");


Input:
protected FQLPPEnvironment makeEnv(String program, FQLPPProgram init) {
    return FQLPPDriver.makeEnv(program, init);
}

Output:
 protected FQLPPEnvironment makeEnv(String program, FQLPPProgram init) {
-    return FQLPPDriver.makeEnv(program, init);
+    return FQLPPDriver.makeEnv(program, init, toUpdate);
 }


Input:
private long mapPage(int page) {
    long target = pageOffset(page + 1);
    if (Files.length(fd) < target && !Files.truncate(fd, target)) {
        throw new RuntimeException("String_Node_Str");
    }
    return Files.mmap(fd, pageSize, pageOffset(page), Files.MAP_RW);
}

Output:
     if (Files.length(fd) < target && !Files.truncate(fd, target)) {
-        throw new RuntimeException("String_Node_Str");
+        throw CairoException.instance(Os.errno()).put("String_Node_Str").put(fd).put("String_Node_Str").put(target);
     }


Input:
private static boolean entityHasFocus(Event event, Entity entity) {
    EventFocusComponent focusComp = (EventFocusComponent) entity.getComponent(EventFocusComponent.class);
    if (focusComp == null)
        return false;
    return focusComp.contains(event.getClass());
}

Output:
         return false;
-    return focusComp.contains(event.getClass());
+    return focusComp.containsClassOrSuperclass(event.getClass());
 }


Input:
public Object getDefaultValueForReturnType(TestOnlyPhase phase) {
    if (defaultReturnValue == UNDEFINED_DEFAULT_RETURN) {
        Class<?> resolvedReturnType = getReturnTypeAsResolvedFromClassArgument();
        if (resolvedReturnType != null) {
            defaultReturnValue = DefaultValues.computeForType(resolvedReturnType);
            if (defaultReturnValue == null) {
                String returnTypeDesc = 'L' + resolvedReturnType.getName().replace('.', '/') + ';';
                String mockedTypeDesc = getClassDesc();
                Object cascadedMock = MockedTypeCascade.getMock(mockedTypeDesc, arguments.methodNameAndDesc, instance, returnTypeDesc, resolvedReturnType);
                useCascadedMock(phase, cascadedMock);
            }
            return defaultReturnValue;
        }
        String returnTypeDesc = DefaultValues.getReturnTypeDesc(arguments.methodNameAndDesc);
        defaultReturnValue = DefaultValues.computeForType(returnTypeDesc);
        if (defaultReturnValue == null) {
            produceCascadedInstanceIfApplicable(phase, returnTypeDesc, arguments.genericSignature);
        }
    }
    return defaultReturnValue;
}

Output:
                 String mockedTypeDesc = getClassDesc();
-                Object cascadedMock = MockedTypeCascade.getMock(mockedTypeDesc, arguments.methodNameAndDesc, instance, returnTypeDesc, resolvedReturnType);
-                useCascadedMock(phase, cascadedMock);
+                defaultReturnValue = MockedTypeCascade.getMock(mockedTypeDesc, arguments.methodNameAndDesc, instance, returnTypeDesc, resolvedReturnType);
             }


Input:
public UserTO read(Long userId) throws NotFoundException {
    SyncopeUser user = syncopeUserDAO.find(userId);
    if (user == null) {
        log.error("String_Node_Str" + userId + "String_Node_Str");
        throw new NotFoundException(String.valueOf(userId));
    }
    return userDataBinder.getUserTO(user);
}

Output:
     }
-    return userDataBinder.getUserTO(user);
+    return userDataBinder.getUserTO(user, userWorkflow);
 }


Input:
public void stop() {
    _handler.removeCallbacks(_runnable);
}

Output:
 public void stop() {
-    _handler.removeCallbacks(_runnable);
+    if (_runnable != null)
+        _handler.removeCallbacks(_runnable);
 }


Input:
public String getIndicatorName() {
    Property property = PropertyHelper.getProperty(indicator.getIndicatorDefinition());
    if (property != null) {
        return property.getDisplayName();
    } else {
        return this.indicator.getName();
    }
}

Output:
 public String getIndicatorName() {
-    Property property = PropertyHelper.getProperty(indicator.getIndicatorDefinition());
-    if (property != null) {
-        return property.getDisplayName();
-    } else {
-        return this.indicator.getName();
+    if (indicator.getIndicatorDefinition() != null) {
+        Property property = PropertyHelper.getProperty(indicator.getIndicatorDefinition());
+        if (property != null) {
+            return property.getDisplayName();
+        }
     }


Input:
public void markForCleanup(long accountId) {
    AccountVO account = findById(accountId);
    if (!account.getNeedsCleanup()) {
        account.setNeedsCleanup(true);
        update(accountId, account);
    }
}

Output:
 public void markForCleanup(long accountId) {
-    AccountVO account = findById(accountId);
+    AccountVO account = findByIdIncludingRemoved(accountId);
     if (!account.getNeedsCleanup()) {


Input:
public TableDefinition buildCMP3_PEARL_HISTTable() {
    TableDefinition table = buildCMP3_PEARLTable();
    table.setName(table.getName() + "String_Node_Str");
    FieldDefinition fieldSTART = new FieldDefinition();
    fieldSTART.setName("String_Node_Str");
    fieldSTART.setTypeName("String_Node_Str");
    fieldSTART.setIsPrimaryKey(true);
    fieldSTART.setIsIdentity(false);
    fieldSTART.setUnique(false);
    fieldSTART.setShouldAllowNull(true);
    table.addField(fieldSTART);
    FieldDefinition fieldEND = new FieldDefinition();
    fieldEND.setName("String_Node_Str");
    fieldEND.setTypeName("String_Node_Str");
    fieldEND.setIsPrimaryKey(false);
    fieldEND.setIsIdentity(false);
    fieldEND.setUnique(false);
    fieldEND.setShouldAllowNull(true);
    table.addField(fieldEND);
    return table;
}

Output:
     fieldSTART.setUnique(false);
-    fieldSTART.setShouldAllowNull(true);
+    fieldSTART.setShouldAllowNull(false);
     table.addField(fieldSTART);