Input:
public void execute(Player player, String message) {
    List<Area> areas = player.getServer().config.dimensions.areas(player.position());
    StringBuilder str = new StringBuilder();
    for (Area area : areas) {
        str.append(area.name);
        str.append("String_Node_Str");
    }
    if (!areas.isEmpty()) {
        str.delete(str.length() - 2, str.length() - 1);
    }
    player.addTMessage(Color.GRAY, "String_Node_Str", Color.WHITE, str.toString());
}

Output:
     }
-    player.addTMessage(Color.GRAY, "String_Node_Str", Color.WHITE, str.toString());
+    player.addTCaptionedMessage("String_Node_Str", str.toString());
 }


Input:
public void updateTaskCount(int processorCoreCount) {
    if (GATTracer.isActivated()) {
        System.err.println("String_Node_Str");
    }
}

Output:
     if (GATTracer.isActivated()) {
-        System.err.println("String_Node_Str");
+        logger.error("String_Node_Str");
     }


Input:
public void testWorkspaceMappings() throws Exception {
    helper.setSkylarkSemantics("String_Node_Str");
    helper.parse("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    assertMapping(helper, "String_Node_Str", "String_Node_Str", "String_Node_Str");
}

Output:
     helper.setSkylarkSemantics("String_Node_Str");
-    helper.parse("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    helper.parse("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    assertMapping(helper, "String_Node_Str", "String_Node_Str", "String_Node_Str");
     assertMapping(helper, "String_Node_Str", "String_Node_Str", "String_Node_Str");


Input:
public AppSale getAppSale() {
    return Beans.get(AppSaleRepository.class).find(appSaleId);
}

Output:
 public AppSale getAppSale() {
-    return Beans.get(AppSaleRepository.class).find(appSaleId);
+    return appSaleRepo.all().fetchOne();
 }


Input:
private static JSType joinNominalTypes(JSType nt1, JSType nt2) {
    if (nt1 == null || nt2 == null) {
        return null;
    }
    NominalType n1 = getNominalTypeIfSingletonObj(nt1);
    NominalType n2 = getNominalTypeIfSingletonObj(nt2);
    if (n1 != null && n2 != null) {
        NominalType tmp = NominalType.pickSuperclass(n1, n2);
        if (tmp != null) {
            return tmp.getInstanceAsJSType();
        }
    }
    return JSType.join(nt1, nt2);
}

Output:
     if (n1 != null && n2 != null) {
-        NominalType tmp = NominalType.pickSuperclass(n1, n2);
+        NominalType tmp = NominalType.join(n1, n2);
         if (tmp != null) {


Input:
protected Pair<Map<Volume, List<StoragePool>>, List<Volume>> findSuitablePoolsForVolumes(VirtualMachineProfile<? extends VirtualMachine> vmProfile, DeploymentPlan plan, ExcludeList avoid, int returnUpTo) {
    List<VolumeVO> volumesTobeCreated = _volsDao.findUsableVolumesForInstance(vmProfile.getId());
    Map<Volume, List<StoragePool>> suitableVolumeStoragePools = new HashMap<Volume, List<StoragePool>>();
    List<Volume> readyAndReusedVolumes = new ArrayList<Volume>();
    for (VolumeVO toBeCreated : volumesTobeCreated) {
        s_logger.debug("String_Node_Str" + toBeCreated.getId() + "String_Node_Str" + toBeCreated.getVolumeType().name() + "String_Node_Str");
        if (plan.getPoolId() != null) {
            if (toBeCreated.getState() == Volume.State.Ready && toBeCreated.getPoolId() != null) {
                s_logger.debug("String_Node_Str" + toBeCreated.getPoolId());
                List<StoragePool> suitablePools = new ArrayList<StoragePool>();
                StoragePoolVO pool = _storagePoolDao.findById(toBeCreated.getPoolId());
                if (!pool.isInMaintenance()) {
                    if (!avoid.shouldAvoid(pool)) {
                        long exstPoolDcId = pool.getDataCenterId();
                        Long exstPoolPodId = pool.getPodId();
                        Long exstPoolClusterId = pool.getClusterId();
                        if (plan.getDataCenterId() == exstPoolDcId && plan.getPodId() == exstPoolPodId && plan.getClusterId() == exstPoolClusterId) {
                            s_logger.debug("String_Node_Str");
                            suitablePools.add(pool);
                            suitableVolumeStoragePools.put(toBeCreated, suitablePools);
                            readyAndReusedVolumes.add(toBeCreated);
                            continue;
                        } else {
                            s_logger.debug("String_Node_Str");
                        }
                    } else {
                        s_logger.debug("String_Node_Str");
                    }
                } else {
                    s_logger.debug("String_Node_Str");
                }
            }
        }
        s_logger.debug("String_Node_Str");
        DiskOfferingVO diskOffering = _diskOfferingDao.findById(toBeCreated.getDiskOfferingId());
        DiskProfile diskProfile = new DiskProfile(toBeCreated, diskOffering, vmProfile.getHypervisorType());
        boolean useLocalStorage = false;
        if (vmProfile.getType() != VirtualMachine.Type.User) {
            String ssvmUseLocalStorage = _configDao.getValue(Config.SystemVMUseLocalStorage.key());
            if (ssvmUseLocalStorage.equalsIgnoreCase("String_Node_Str")) {
                useLocalStorage = true;
            }
        } else {
            useLocalStorage = diskOffering.getUseLocalStorage();
        }
        diskProfile.setUseLocalStorage(useLocalStorage);
        boolean foundPotentialPools = false;
        Enumeration<StoragePoolAllocator> enPool = _storagePoolAllocators.enumeration();
        while (enPool.hasMoreElements()) {
            final StoragePoolAllocator allocator = enPool.nextElement();
            final List<StoragePool> suitablePools = allocator.allocateToPool(diskProfile, vmProfile.getTemplate(), plan, avoid, returnUpTo);
            if (suitablePools != null && !suitablePools.isEmpty()) {
                suitableVolumeStoragePools.put(toBeCreated, suitablePools);
                foundPotentialPools = true;
                break;
            }
        }
        if (!foundPotentialPools) {
            s_logger.debug("String_Node_Str" + toBeCreated + "String_Node_Str" + plan.getClusterId());
            suitableVolumeStoragePools.clear();
            break;
        }
    }
    if (suitableVolumeStoragePools.isEmpty()) {
        s_logger.debug("String_Node_Str");
    }
    return new Pair<Map<Volume, List<StoragePool>>, List<Volume>>(suitableVolumeStoragePools, readyAndReusedVolumes);
}

Output:
                         long exstPoolDcId = pool.getDataCenterId();
-                        Long exstPoolPodId = pool.getPodId();
-                        Long exstPoolClusterId = pool.getClusterId();
+                        long exstPoolPodId = pool.getPodId() != null ? pool.getPodId() : -1;
+                        long exstPoolClusterId = pool.getClusterId() != null ? pool.getClusterId() : -1;
                         if (plan.getDataCenterId() == exstPoolDcId && plan.getPodId() == exstPoolPodId && plan.getClusterId() == exstPoolClusterId) {


Input:
public void updateInstance(final ServerContext context, final String resourceId, final UpdateRequest request, final ResultHandler<Resource> handler) {
    Token admin = new Token();
    admin.setId(getCookieFromServerContext(context));
    final JsonValue jVal = request.getNewContent();
    final String rev = request.getRevision();
    IdentityDetails dtls = null, newDtls = null;
    IdentityServicesImpl idsvc = null;
    Resource resource = null;
    try {
        idsvc = new IdentityServicesImpl();
        dtls = idsvc.read(resourceId, idSvcsAttrList, admin);
        newDtls = jsonValueToIdentityDetails(jVal);
        newDtls.setName(resourceId);
        String userpass = jVal.get("String_Node_Str").asString();
        if (userpass != null && !userpass.isEmpty()) {
            if (checkValidPassword(resourceId, userpass.toCharArray(), realm) || isAdmin(context)) {
            } else {
                if (checkValidPassword(resourceId, getPasswordFromHeader(context).toCharArray(), realm)) {
                } else {
                    throw new PermanentException(401, "String_Node_Str", null);
                }
            }
        }
        UpdateResponse message = idsvc.update(newDtls, admin);
        IdentityDetails checkIdent = idsvc.read(dtls.getName(), idSvcsAttrList, admin);
        resource = new Resource(resourceId, "String_Node_Str", identityDetailsToJsonValue(checkIdent));
        handler.handleResult(resource);
    } catch (final ObjectNotFound o) {
        try {
            dtls = jsonValueToIdentityDetails(jVal);
            dtls.setName(resourceId);
            CreateResponse success = idsvc.create(dtls, admin);
            IdentityDetails checkIdent = idsvc.read(dtls.getName(), idSvcsAttrList, admin);
            resource = new Resource(resourceId, "String_Node_Str", identityDetailsToJsonValue(checkIdent));
            handler.handleResult(resource);
        } catch (final TokenExpired tokenExpired) {
            RestDispatcher.debug.error("String_Node_Str" + resourceId + "String_Node_Str" + tokenExpired);
            handler.handleError(new PermanentException(401, "String_Node_Str", null));
        } catch (final Exception e) {
            RestDispatcher.debug.error("String_Node_Str" + e);
            handler.handleError(new BadRequestException(e.getMessage(), e));
        }
    } catch (final NeedMoreCredentials needMoreCredentials) {
        RestDispatcher.debug.error("String_Node_Str" + resourceId + "String_Node_Str" + needMoreCredentials);
        handler.handleError(new ForbiddenException("String_Node_Str", needMoreCredentials));
    } catch (final TokenExpired tokenExpired) {
        RestDispatcher.debug.error("String_Node_Str" + resourceId + "String_Node_Str" + tokenExpired);
        handler.handleError(new PermanentException(401, "String_Node_Str", null));
    } catch (final AccessDenied accessDenied) {
        RestDispatcher.debug.error("String_Node_Str" + resourceId + "String_Node_Str" + accessDenied);
        handler.handleError(new ForbiddenException(accessDenied.getMessage(), accessDenied));
    } catch (final GeneralFailure generalFailure) {
        RestDispatcher.debug.error("String_Node_Str" + generalFailure);
        handler.handleError(new BadRequestException(generalFailure.getMessage(), generalFailure));
    } catch (final Exception exception) {
        RestDispatcher.debug.error("String_Node_Str" + exception);
        handler.handleError(new NotFoundException(exception.getMessage(), exception));
    }
}

Output:
             } else {
-                if (checkValidPassword(resourceId, getPasswordFromHeader(context).toCharArray(), realm)) {
+                String strPass = getPasswordFromHeader(context);
+                if (strPass != null && !strPass.isEmpty() && checkValidPassword(resourceId, strPass.toCharArray(), realm)) {
                 } else {


Input:
public boolean apply(ItemStack input) {
    if (input == null || input.isEmpty()) {
        return false;
    }
    IFluidHandlerItem handler = FluidUtil.getFluidHandler(input);
    if (handler == null) {
        return false;
    }
    if (fluid.isFluidStackIdentical(handler.drain(Fluid.BUCKET_VOLUME, false))) {
        return true;
    }
    return false;
}

Output:
     }
-    IFluidHandlerItem handler = FluidUtil.getFluidHandler(input);
+    IFluidHandlerItem handler = input.getCount() > 1 ? FluidUtil.getFluidHandler(ItemHelper.cloneStack(input, 1)) : FluidUtil.getFluidHandler(input);
     if (handler == null) {


Input:
public static void setupTest() throws IOException {
    addTemplatePlugins(TEMPLATE_ID, "String_Node_Str", DBSource.class, KVTableSource.class, StreamBatchSource.class, TableSource.class, DBRecord.class, TimePartitionedFileSetDatasetAvroSource.class, BatchCubeSink.class, DBSink.class, KVTableSink.class, TableSink.class, TimePartitionedFileSetDatasetAvroSink.class, AvroKeyOutputFormat.class, AvroKey.class, TimePartitionedFileSetDatasetParquetSink.class, AvroParquetOutputFormat.class);
    addTemplatePlugins(TEMPLATE_ID, "String_Node_Str", MetaKVTableSource.class);
    addTemplatePlugins(TEMPLATE_ID, "String_Node_Str", MetaKVTableSink.class);
    addTemplatePlugins(TEMPLATE_ID, "String_Node_Str", ProjectionTransform.class, ScriptFilterTransform.class, StructuredRecordToGenericRecordTransform.class);
    addTemplatePlugins(TEMPLATE_ID, "String_Node_Str", JDBCDriver.class);
    addTemplatePluginJson(TEMPLATE_ID, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", JDBCDriver.class.getName());
    deployTemplate(NAMESPACE, TEMPLATE_ID, ETLBatchTemplate.class, PipelineConfigurable.class.getPackage().getName(), BatchSource.class.getPackage().getName());
}

Output:
     addTemplatePluginJson(TEMPLATE_ID, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", JDBCDriver.class.getName());
-    deployTemplate(NAMESPACE, TEMPLATE_ID, ETLBatchTemplate.class, PipelineConfigurable.class.getPackage().getName(), BatchSource.class.getPackage().getName());
+    deployTemplate(NAMESPACE, TEMPLATE_ID, ETLBatchTemplate.class, PipelineConfigurable.class.getPackage().getName(), BatchSource.class.getPackage().getName(), ETLConfig.class.getPackage().getName());
 }


Input:
private void addParameters(ICapPO testStep, TestResultNode resultNode) {
    List<IParamDescriptionPO> parameterList = testStep.getParameterList();
    String value = null;
    for (IParamDescriptionPO desc : parameterList) {
        ITDManager tdManager = null;
        try {
            tdManager = m_externalTestDataBP.getExternalCheckedTDManager(testStep);
        } catch (JBException e) {
            log.error(Messages.TestDataNotAvailable + StringConstants.DOT, e);
        }
        TestExecution te = TestExecution.getInstance();
        List<ExecObject> stackList = new ArrayList<ExecObject>(te.getTrav().getExecStackAsList());
        int dataSetIndex = 0;
        if (tdManager.findColumnForParam(desc.getUniqueId()) == -1) {
            IParameterInterfacePO referencedDataCube = testStep.getReferencedDataCube();
            if (referencedDataCube != null) {
                desc = referencedDataCube.getParameterForName(desc.getName());
            }
        }
        ITestDataPO date = tdManager.getCell(dataSetIndex, desc);
        ParamValueConverter conv = new ModelParamValueConverter(date.getValue(te.getLocale()), testStep, te.getLocale(), desc);
        try {
            value = conv.getExecutionString(stackList, te.getLocale());
        } catch (InvalidDataException e) {
            log.error(e.getMessage());
            value = MessageIDs.getMessageObject(e.getErrorId()).getMessage(new Object[] {});
        }
        resultNode.addParameter(new TestResultParameter(desc.getUniqueId(), desc.getType(), StringUtils.defaultString(value)));
    }
}

Output:
         }
-        resultNode.addParameter(new TestResultParameter(desc.getUniqueId(), desc.getType(), StringUtils.defaultString(value)));
+        resultNode.addParameter(new TestResultParameter(CompSystemI18n.getString(desc.getUniqueId()), CompSystemI18n.getString(desc.getType()), StringUtils.defaultString(value)));
     }


Input:
public void map(final GeoWaveInputKey key, final SimpleFeatureImpl value, final Context context) throws IOException, InterruptedException {
    final Integer pointId = Integer.parseInt(value.getAttribute("String_Node_Str").toString());
    final Geometry geometry = (Geometry) value.getDefaultGeometry();
    final Coordinate coord = geometry.getCentroid().getCoordinate();
    final DataPoint dp = new DataPoint(pointId, coord.x, coord.y, -1, false);
    final String outputRowId = context.getConfiguration().get("String_Node_Str");
    DataPoint assignedCentroid = null;
    double leastDist = Double.MAX_VALUE;
    for (final DataPoint centroid : centroids) {
        final double dist = centroid.calculateDistance(dp);
        if (dist < leastDist) {
            assignedCentroid = centroid;
            leastDist = dist;
        }
    }
    final Mutation m = new Mutation(outputRowId);
    m.put(new Text(new Integer(assignedCentroid.id).toString()), new Text(pointId.toString()), new Value(coord.toString().getBytes()));
    context.write(outKey, m);
}

Output:
     final Mutation m = new Mutation(outputRowId);
-    m.put(new Text(new Integer(assignedCentroid.id).toString()), new Text(pointId.toString()), new Value(coord.toString().getBytes()));
+    m.put(new Text(assignedCentroid.id.toString()), new Text(pointId.toString()), new Value(coord.toString().getBytes()));
     context.write(outKey, m);


Input:
public static void save(Account account, SQLiteDatabase database) {
    ContentValues values = new ContentValues();
    values.put("String_Node_Str", 0);
    values.put("String_Node_Str", account.getUserName());
    values.put("String_Node_Str", account.getUserId());
    values.put("String_Node_Str", account.getDisplayName());
    values.put("String_Node_Str", account.getProfileUrl());
    values.put("String_Node_Str", account.getAvatarUrl());
    values.put("String_Node_Str", account.getPrimaryBlogId());
    values.put("String_Node_Str", account.getSiteCount());
    values.put("String_Node_Str", account.getVisibleSiteCount());
    values.put("String_Node_Str", account.getAccessToken());
    values.put("String_Node_Str", account.getEmail());
    values.put("String_Node_Str", account.getFirstName());
    values.put("String_Node_Str", account.getLastName());
    values.put("String_Node_Str", account.getAboutMe());
    values.put("String_Node_Str", account.getNewEmail());
    values.put("String_Node_Str", account.getPendingEmailChange());
    values.put("String_Node_Str", account.getPendingEmailChange());
    database.insertWithOnConflict(ACCOUNT_TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE);
}

Output:
     values.put("String_Node_Str", account.getPendingEmailChange());
-    values.put("String_Node_Str", account.getPendingEmailChange());
+    values.put("String_Node_Str", account.getWebAddress());
     database.insertWithOnConflict(ACCOUNT_TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE);


Input:
public void element(XPathFragment frag) {
    Element element = document.createElementNS(frag.getNamespaceURI(), frag.getShortName());
    getNode().appendChild(element);
}

Output:
     Element element = document.createElementNS(frag.getNamespaceURI(), frag.getShortName());
-    getNode().appendChild(element);
+    node.appendChild(element);
 }


Input:
public void testBinarySearchObjectComparator() {
    Comparator inverseSort = new Comparator() {

        public int compare(Object o1, Object o2) {
            return ((Comparable) o2).compareTo(o1);
        }
    };
    List a1 = new ArrayList();
    int ret = Collections.binarySearch(a1, "String_Node_Str", inverseSort);
    assertEquals(-1, ret);
    List a2 = new ArrayList(Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }));
    ret = Collections.binarySearch(a2, "String_Node_Str", inverseSort);
    assertEquals(-3, ret);
    ret = Collections.binarySearch(a2, "String_Node_Str", inverseSort);
    assertEquals(2, ret);
    List a3 = new ArrayList(Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }));
    ret = Collections.binarySearch(a3, "String_Node_Str", inverseSort);
    assertEquals(-5, ret);
    ret = Collections.binarySearch(a3, "String_Node_Str", inverseSort);
    assertEquals(-1, ret);
    ret = Collections.binarySearch(a3, "String_Node_Str", inverseSort);
    assertEquals(0, ret);
    List a4 = new ArrayList(Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }));
    ret = Collections.binarySearch(a4, "String_Node_Str", null);
    assertEquals(3, ret);
}

Output:
 public void testBinarySearchObjectComparator() {
-    Comparator inverseSort = new Comparator() {
+    Comparator<String> inverseSort = new Comparator<String>() {


Input:
public boolean apply(ComputeMetadata nodeMetadata) {
    if (nodeMetadata == null) {
        return false;
    }
    for (AbstractMap.SimpleImmutableEntry entry : tagPairs) {
        if (!nodeMetadata.getUserMetadata().get(entry.getKey()).equals(entry.getValue())) {
            return false;
        }
    }
    return true;
}

Output:
     for (AbstractMap.SimpleImmutableEntry entry : tagPairs) {
-        if (!nodeMetadata.getUserMetadata().get(entry.getKey()).equals(entry.getValue())) {
+        String value = nodeMetadata.getUserMetadata().get(entry.getKey());
+        if (value == null || !value.equals(entry.getValue())) {
             return false;


Input:
protected void invalidateNearCache(Data key) {
    if (nearCache != null) {
        nearCache.remove(key);
    }
}

Output:
 protected void invalidateNearCache(Data key) {
-    if (nearCache != null) {
-        nearCache.remove(key);
+    if (nearCache == null || key == null) {
+        return;
     }


Input:
public void onSuccess(ListResult<ContactDTO> result) {
    final HashMap<String, Object> properties = buildPropertyMap(contactModelDTO, login, firstName, familyName, organizationName, mainOrgUnit, secondaryOrgUnits);
    if (result == null || result.getSize() == 0) {
        createEntity(properties);
        return;
    }
    final DedupeContactDialog dedupeContactDialog = new DedupeContactDialog(true);
    dedupeContactDialog.getPossibleDuplicatesGrid().getStore().add(result.getList());
    dedupeContactDialog.getFirstStepMainButton().addSelectionListener(new SelectionListener<ButtonEvent>() {
        public void componentSelected(ButtonEvent ce) {
            createEntity(properties);
            dedupeContactDialog.hide();
        }
    });
    dedupeContactDialog.setSecondStepHandler(new DedupeContactDialog.SecondStepHandler() {
        public void initialize(final Integer contactId, final ListStore<ContactDuplicatedProperty> propertiesStore) {
            dispatch.execute(new GetContactDuplicatedProperties(contactId, null, properties), new CommandResultHandler<ListResult<ContactDuplicatedProperty>>() {
                protected void onCommandSuccess(ListResult<ContactDuplicatedProperty> result) {
                    propertiesStore.add(result.getList());
                }
            }, new LoadingMask(dedupeContactDialog));
        }
        public void downloadImage(String id, final Image image) {
            imageProvider.provideDataUrl(id, new SuccessCallback<String>() {
                public void onSuccess(String dataUrl) {
                    image.setUrl(dataUrl);
                }
            });
        }
        public void handleDedupeContact(final Integer targetedContactId, List<ContactDuplicatedProperty> selectedProperties) {
            dispatch.execute(new DedupeContact(selectedProperties, targetedContactId), new CommandResultHandler<ContactDTO>() {
                protected void onCommandSuccess(ContactDTO targetedContactDTO) {
                    dedupeContactDialog.hide();
                    eventBus.navigateRequest(Page.CONTACT_DASHBOARD.requestWith(RequestParameter.ID, targetedContactId));
                }
            });
        }
    });
    dedupeContactDialog.show();
}

Output:
 public void onSuccess(ListResult<ContactDTO> result) {
-    final HashMap<String, Object> properties = buildPropertyMap(contactModelDTO, login, firstName, familyName, organizationName, mainOrgUnit, secondaryOrgUnits);
+    final HashMap<String, Object> properties = buildPropertyMap(contactModelDTO, firstName, familyName, organizationName, mainOrgUnit, secondaryOrgUnits);
     if (result == null || result.getSize() == 0) {


Input:
List<Redirect> generateRedirects(String key, List<String> registryUrls) {
    List<Redirect> redirects = new ArrayList<Redirect>();
    if (StringUtils.isBlank(key) || !removeEmptyUrlsAndValidate(registryUrls)) {
        LOGGER.error("String_Node_Str");
        LOGGER.error("String_Node_Str", key);
        LOGGER.error("String_Node_Str", registryUrls);
        return redirects;
    }
    redirects.add(new DomainRedirect(key, registryUrls));
    return redirects;
}

Output:
     if (StringUtils.isBlank(key) || !removeEmptyUrlsAndValidate(registryUrls)) {
-        LOGGER.error("String_Node_Str");
-        LOGGER.error("String_Node_Str", key);
-        LOGGER.error("String_Node_Str", registryUrls);
+        logger.error("String_Node_Str" + "String_Node_Str");
+        logger.error("String_Node_Str", key);
+        logger.error("String_Node_Str", registryUrls);
         return redirects;


Input:
public static void startCluster() {
    if (!isStarted) {
        File workingDirectory = new File("String_Node_Str");
        Configuration conf = new Configuration();
        System.setProperty("String_Node_Str", workingDirectory.getAbsolutePath());
        conf.set("String_Node_Str", new File(workingDirectory, "String_Node_Str").getAbsolutePath());
        conf.set("String_Node_Str", "String_Node_Str");
        conf.set("String_Node_Str", "String_Node_Str");
        conf.set("String_Node_Str", "String_Node_Str");
        conf.set("String_Node_Str", "String_Node_Str");
        conf.set("String_Node_Str", "String_Node_Str");
        try {
            masterDir = new File(workingDirectory, "String_Node_Str");
            conf.set(HConstants.HBASE_DIR, masterDir.toURI().toURL().toString());
        } catch (MalformedURLException e1) {
            logger.error(e1.getMessage());
        }
        Configuration hbaseConf = HBaseConfiguration.create(conf);
        utility = new HBaseTestingUtility(hbaseConf);
        try {
            MiniZooKeeperCluster zkCluster = new MiniZooKeeperCluster(conf);
            zkCluster.setDefaultClientPort(2181);
            zkCluster.setTickTime(18000);
            zkDir = new File(utility.getClusterTestDir().toString());
            zkCluster.startup(zkDir);
            utility.setZkCluster(zkCluster);
            utility.startMiniCluster();
            utility.getHBaseCluster().startMaster();
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new RuntimeException(e);
        }
        isStarted = true;
    }
}

Output:
 public static void startCluster() {
-    if (!isStarted) {
+    if (checkIfServerRunning()) {
         File workingDirectory = new File("String_Node_Str");


Input:
protected void internalTransform(String phaseName, Map options) {
    System.out.println("String_Node_Str" + phaseName + "String_Node_Str" + options + "String_Node_Str");
    _generatorAttributeFileName = PhaseOptions.getString(options, "String_Node_Str");
    boolean overwrite = PhaseOptions.getBoolean(options, "String_Node_Str");
    if (_generatorAttributeFileName.length() == 0) {
        throw new InternalErrorException("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    }
    System.out.println("String_Node_Str" + _generatorAttributeFileName);
    GeneratorAttribute generatorAttribute = null;
    try {
        MoMLParser parser = new MoMLParser();
        CompositeActor toplevel;
        List oldFilters = parser.getMoMLFilters();
        parser.setMoMLFilters(null);
        try {
            parser.addMoMLFilters(BackwardCompatibility.allFilters());
            toplevel = (CompositeActor) parser.parse(null, new File(_generatorAttributeFileName).toURL());
        } finally {
            parser.setMoMLFilters(oldFilters);
        }
        generatorAttribute = (GeneratorAttribute) toplevel.getAttribute(Copernicus.GENERATOR_NAME, GeneratorAttribute.class);
        if (generatorAttribute == null) {
            System.out.println("String_Node_Str" + _generatorAttributeFileName + "String_Node_Str" + "String_Node_Str" + Copernicus.GENERATOR_NAME + "String_Node_Str" + toplevel.exportMoML());
            generatorAttribute = new GeneratorAttribute(toplevel, Copernicus.GENERATOR_NAME);
        }
    } catch (Exception ex) {
        throw new InternalErrorException(_model, ex, "String_Node_Str" + "String_Node_Str");
    }
    _outputDirectory = PhaseOptions.getString(options, "String_Node_Str");
    if (!_outputDirectory.endsWith("String_Node_Str")) {
        _outputDirectory = _outputDirectory + "String_Node_Str";
    }
    File outDirFile = new File(_outputDirectory);
    if (!outDirFile.isDirectory()) {
        outDirFile.mkdirs();
    }
    _targetPackage = PhaseOptions.getString(options, "String_Node_Str");
    _templateDirectory = PhaseOptions.getString(options, "String_Node_Str");
    if (!_templateDirectory.endsWith("String_Node_Str")) {
        _templateDirectory = _templateDirectory + "String_Node_Str";
    }
    Map substituteMap;
    try {
        substituteMap = Copernicus.newMap(generatorAttribute);
        substituteMap.put("String_Node_Str", _outputDirectory);
        substituteMap.put("String_Node_Str", _targetPackage);
        substituteMap.put("String_Node_Str", _templateDirectory);
        substituteMap.putAll(_addedSubstitutions);
    } catch (IllegalActionException ex) {
        throw new InternalErrorException(_model, ex, "String_Node_Str" + generatorAttribute);
    }
    if (overwrite || !(new File(_outputDirectory + "String_Node_Str")).isFile()) {
        try {
            System.out.println("String_Node_Str" + _templateDirectory + "String_Node_Str" + _outputDirectory + "String_Node_Str");
            CodeGeneratorUtilities.substitute(_templateDirectory + "String_Node_Str", substituteMap, _outputDirectory + "String_Node_Str");
        } catch (Exception ex) {
            System.err.println("String_Node_Str" + ex);
            ex.printStackTrace();
            throw new InternalErrorException(_model, ex, "String_Node_Str");
        }
    } else {
        System.out.println("String_Node_Str" + _outputDirectory + "String_Node_Str");
    }
    BufferedReader inputFile = null;
    String obfuscateTemplate = _templateDirectory + "String_Node_Str";
    try {
        inputFile = CodeGeneratorUtilities.openAsFileOrURL(obfuscateTemplate);
    } catch (IOException ex) {
        System.out.println("String_Node_Str" + "String_Node_Str" + ex);
    }
    if (inputFile != null) {
        try {
            CodeGeneratorUtilities.substitute(inputFile, substituteMap, _outputDirectory + "String_Node_Str");
        } catch (Exception ex) {
            System.err.println("String_Node_Str" + ex);
            ex.printStackTrace();
            throw new InternalErrorException(_model, ex, "String_Node_Str");
        }
    }
}

Output:
         List oldFilters = parser.getMoMLFilters();
-        parser.setMoMLFilters(null);
+        MoMLParser.setMoMLFilters(null);
         try {


Input:
private List<ecoDrop> parseDrops(String dropsString, Boolean isFixedDrops) {
    List<ecoDrop> drops = new ArrayList<ecoDrop>();
    if (dropsString != null && !dropsString.isEmpty()) {
        try {
            for (String dropString : dropsString.split("String_Node_Str")) {
                ecoDrop drop = new ecoDrop();
                String[] dropParts = dropString.split("String_Node_Str");
                String[] itemParts = dropParts[0].split("String_Node_Str");
                if (itemParts.length > 1) {
                    for (int i = 1; i < itemParts.length; i++) {
                        String[] enchantParts = itemParts[i].split("String_Node_Str");
                        drop.addEnchantment(Enchantment.getByName(enchantParts[0].toUpperCase()), enchantParts.length > 1 ? Integer.parseInt(enchantParts[1]) : 1);
                    }
                }
                String[] itemSubParts = itemParts[0].split("String_Node_Str");
                drop.setItem(Material.matchMaterial(itemSubParts[0]));
                if (drop.getItem() == null)
                    throw new Exception();
                drop.setData(itemSubParts.length > 1 ? Byte.parseByte(itemSubParts[1]) : 1);
                String[] amountRange = dropParts[1].split("String_Node_Str");
                if (amountRange.length == 2) {
                    drop.setMinAmount(Integer.parseInt(amountRange[0]));
                    drop.setMaxAmount(Integer.parseInt(amountRange[1]));
                } else {
                    drop.setMaxAmount(Integer.parseInt(dropParts[1]));
                }
                drop.setPercentage(Double.parseDouble(dropParts[2]));
                drop.setIsFixedDrops(isFixedDrops);
                drops.add(drop);
            }
        } catch (Exception exception) {
            log.warning("String_Node_Str" + dropsString);
        }
    }
    return drops;
}

Output:
                     throw new Exception();
-                drop.setData(itemSubParts.length > 1 ? Byte.parseByte(itemSubParts[1]) : 1);
+                drop.setData(itemSubParts.length > 1 ? Byte.parseByte(itemSubParts[1]) : 0);
                 String[] amountRange = dropParts[1].split("String_Node_Str");


Input:
private void initPropsAsVarsInRelationship(final PropertyMap map, final BPELScopeActivity templatePlan) {
    final AbstractRelationshipTemplate relationshipTemplate = templatePlan.getRelationshipTemplate();
    if (relationshipTemplate.getProperties() != null) {
        final Element propertyElement = relationshipTemplate.getProperties().getDOMElement();
        for (int i = 0; i < propertyElement.getChildNodes().getLength(); i++) {
            if (propertyElement.getChildNodes().item(i).getNodeType() == Node.TEXT_NODE) {
                continue;
            }
            final String propName = propertyElement.getChildNodes().item(i).getLocalName();
            final String propVarName = relationshipTemplate.getId().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + propertyElement.getChildNodes().item(i).getLocalName();
            map.addPropertyMapping(relationshipTemplate.getId(), propName, "String_Node_Str" + propVarName);
            String value = "String_Node_Str";
            for (int j = 0; j < propertyElement.getChildNodes().item(i).getChildNodes().getLength(); j++) {
                if (propertyElement.getChildNodes().item(i).getChildNodes().item(j).getNodeType() == Node.TEXT_NODE) {
                    value += propertyElement.getChildNodes().item(i).getChildNodes().item(j).getNodeValue();
                }
            }
            PropertyVariableInitializer.LOG.debug("String_Node_Str" + propVarName);
            PropertyVariableInitializer.LOG.debug("String_Node_Str" + value);
            this.planHandler.addPropertyVariable(propVarName, templatePlan.getBuildPlan());
            if (!value.trim().isEmpty() && !value.trim().equals("String_Node_Str")) {
                this.planHandler.initializePropertyVariable(propVarName, value, templatePlan.getBuildPlan());
            }
        }
    }
}

Output:
             final String propName = propertyElement.getChildNodes().item(i).getLocalName();
-            final String propVarName = relationshipTemplate.getId().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + propertyElement.getChildNodes().item(i).getLocalName();
+            final String propVarName = ModelUtils.makeValidNCName(relationshipTemplate.getId()) + "String_Node_Str" + propertyElement.getChildNodes().item(i).getLocalName();
             map.addPropertyMapping(relationshipTemplate.getId(), propName, "String_Node_Str" + propVarName);


Input:
public void setUp() throws Exception {
    eventStack = new LinkedBlockingQueue<>();
    AppStorage storage = createStorage();
    if (storage instanceof ListenableAppStorage) {
        this.storage = (ListenableAppStorage) storage;
    } else {
        this.storage = new DefaultListenableAppStorage(storage);
    }
    this.storage.addListener(this, eventList -> eventStack.addAll(eventList.getEvents()));
}

Output:
     }
-    this.storage.addListener(this, eventList -> eventStack.addAll(eventList.getEvents()));
+    this.storage.addListener(l);
 }


Input:
public boolean onCommand(CommandSender cs, Command cmd, String alias, String[] args) {
    if (!(cs instanceof Player)) {
        plugin.log(plugin.getMessage("String_Node_Str"));
        return true;
    }
    if (args.length > 0) {
        if (args[0].equalsIgnoreCase("String_Node_Str"))
            args[0] = "String_Node_Str";
        else if (args[0].equalsIgnoreCase("String_Node_Str"))
            args[0] = "String_Node_Str";
        else if (args[0].equalsIgnoreCase("String_Node_Str"))
            args[0] = "String_Node_Str";
    }
    Player player = (Player) cs;
    if (args.length == 0 || args[0].equalsIgnoreCase("String_Node_Str")) {
        plugin.msg(player, "String_Node_Str");
        String s = "String_Node_Str";
        for (String sKey : CircuitManager.getValidCircuitTypes().keySet()) {
            s += sKey + "String_Node_Str";
        }
        plugin.msg(player, ChatColor.YELLOW + plugin.getMessage("String_Node_Str") + ChatColor.WHITE + s.substring(0, s.length() - 2));
    } else if (args[0].equalsIgnoreCase("String_Node_Str") || args[0].equalsIgnoreCase("String_Node_Str")) {
        if (CircuitManager.hasPendingCircuit(player)) {
            CircuitManager.removePendingCircuit(player);
            plugin.msg(player, plugin.getMessage("String_Node_Str"));
        } else {
            plugin.msg(player, plugin.getMessage("String_Node_Str"));
        }
    } else if (args[0].equalsIgnoreCase("String_Node_Str")) {
        if (CircuitManager.hasPendingCircuit(player)) {
            PendingCircuit pc = CircuitManager.getPendingCircuit(player);
            if (pc.hasSenderLocation()) {
                if (pc.hasReceiver()) {
                    CircuitManager.addCircuit(pc);
                    if (pc.getSenderLocation().getBlock().getType() == Material.WOODEN_DOOR || pc.getSenderLocation().getBlock().getType() == Material.SPRUCE_DOOR || pc.getSenderLocation().getBlock().getType() == Material.BIRCH_DOOR || pc.getSenderLocation().getBlock().getType() == Material.JUNGLE_DOOR || pc.getSenderLocation().getBlock().getType() == Material.ACACIA_DOOR || pc.getSenderLocation().getBlock().getType() == Material.DARK_OAK_DOOR) {
                        Block bDoor = pc.getSenderLocation().getBlock();
                        int iData = (int) bDoor.getData();
                        Block bOtherPiece = bDoor.getRelative((iData & 0x08) == 0x08 ? BlockFace.DOWN : BlockFace.UP);
                        CircuitManager.addCircuit(bOtherPiece.getLocation(), pc.getCircuit());
                    }
                    CircuitManager.removePendingCircuit(player);
                    plugin.msg(player, plugin.getMessage("String_Node_Str"));
                } else {
                    plugin.msg(player, plugin.getMessage("String_Node_Str"));
                }
            } else {
                plugin.msg(player, plugin.getMessage("String_Node_Str"));
            }
        } else {
            plugin.msg(player, plugin.getMessage("String_Node_Str"));
        }
    } else if (CircuitManager.isValidCircuitType(args[0])) {
        if (player.hasPermission("String_Node_Str" + args[0])) {
            double dDelay = 0;
            if (args.length > 1) {
                try {
                    dDelay = Double.parseDouble(args[1]);
                } catch (NumberFormatException e) {
                    dDelay = -1;
                }
                if (dDelay < 0 || (dDelay > QuantumConnectors.MAX_DELAY_TIME && !player.hasPermission("String_Node_Str"))) {
                    dDelay = 0;
                    plugin.msg(player, ChatColor.RED + plugin.getMessage("String_Node_Str").replaceAll("String_Node_Str", new Integer(QuantumConnectors.MAX_DELAY_TIME).toString()));
                }
            }
            String sDelayMsg = "String_Node_Str" + args[0] + "String_Node_Str" + dDelay + "String_Node_Str";
            sDelayMsg = "String_Node_Str";
            int iDelayTicks = (int) Math.round(dDelay * 20);
            if (!CircuitManager.hasPendingCircuit(player)) {
                CircuitManager.addPendingCircuit(player, CircuitManager.getCircuitType(args[0]), iDelayTicks);
                plugin.msg(player, plugin.getMessage("String_Node_Str").replace("String_Node_Str", args[0].toUpperCase()).replace("String_Node_Str", new Double(dDelay).toString()));
            } else {
                CircuitManager.getPendingCircuit(player).setCircuitType(CircuitManager.getCircuitType(args[0]), iDelayTicks);
                plugin.msg(player, plugin.getMessage("String_Node_Str").replace("String_Node_Str", args[0].toUpperCase()).replace("String_Node_Str", new Double(dDelay).toString()));
            }
        } else {
            plugin.msg(player, ChatColor.RED + plugin.getMessage("String_Node_Str").replace("String_Node_Str", args[0].toUpperCase()));
        }
    } else {
        plugin.msg(player, plugin.getMessage("String_Node_Str"));
    }
    return true;
}

Output:
     if (args.length == 0 || args[0].equalsIgnoreCase("String_Node_Str")) {
-        plugin.msg(player, "String_Node_Str");
+        plugin.msg(player, plugin.getMessage("String_Node_Str"));
         String s = "String_Node_Str";


Input:
public void testAbstractCovariance_GRE272_4() {
    this.runNegativeTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

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


Input:
protected boolean checkMeasureVerticalSpanOverlapped(ColumnEvent ev) {
    if (ev.measureIndex == -1) {
        return false;
    }
    LevelHandle spanLevel = null;
    switch(ev.type) {
        case ColumnEvent.MEASURE_CHANGE:
        case ColumnEvent.COLUMN_EDGE_CHANGE:
            spanLevel = crosstabItem.getMeasure(ev.measureIndex).getCell().getSpanOverOnRow();
            break;
        case ColumnEvent.COLUMN_TOTAL_CHANGE:
        case ColumnEvent.GRAND_TOTAL_CHANGE:
            int dimCount = crosstabItem.getDimensionCount(ROW_AXIS_TYPE);
            DimensionViewHandle rdv = crosstabItem.getDimension(ROW_AXIS_TYPE, dimCount - 1);
            spanLevel = getAggregationCell(dimCount - 1, rdv.getLevelCount() - 1, ev.dimensionIndex, ev.levelIndex, ev.measureIndex).getSpanOverOnRow();
            break;
    }
    if (spanLevel != null) {
        int targetSpanGroupIndex = GroupUtil.getGroupIndex(rowGroups, spanLevel);
        if (targetSpanGroupIndex != -1) {
            try {
                EdgeCursor rowEdgeCursor = getRowEdgeCursor();
                if (rowEdgeCursor != null) {
                    targetSpanGroupIndex--;
                    if (targetSpanGroupIndex == -1) {
                        return !rowEdgeCursor.isFirst();
                    } else {
                        DimensionCursor dc = (DimensionCursor) rowEdgeCursor.getDimensionCursor().get(targetSpanGroupIndex);
                        if (!GroupUtil.isDummyGroup(dc)) {
                            return rowEdgeCursor.getPosition() > dc.getEdgeStart();
                        }
                    }
                }
            } catch (OLAPException e) {
                logger.log(Level.SEVERE, Messages.getString("String_Node_Str"), e);
            }
        }
    }
    return false;
}

Output:
         case ColumnEvent.COLUMN_EDGE_CHANGE:
-            spanLevel = crosstabItem.getMeasure(ev.measureIndex).getCell().getSpanOverOnRow();
+            spanLevel = getMeasureCell(ev.measureIndex).getSpanOverOnRow();
             break;


Input:
private void validateConfig() {
    if (hasText(dbName)) {
        throw new MongobeeConfigurationException("String_Node_Str");
    }
    if (hasText(changelogsScanPackage)) {
        throw new MongobeeConfigurationException("String_Node_Str");
    }
}

Output:
 private void validateConfig() {
-    if (hasText(dbName)) {
+    if (!hasText(dbName)) {
         throw new MongobeeConfigurationException("String_Node_Str");


Input:
public org.hl7.fhir.dstu2.model.AuditEvent convertAuditEvent(org.hl7.fhir.dstu3.model.AuditEvent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.AuditEvent tgt = new org.hl7.fhir.dstu2.model.AuditEvent();
    copyDomainResource(src, tgt);
    tgt.getEvent().setType(convertCoding(src.getType()));
    for (org.hl7.fhir.dstu3.model.Coding t : src.getSubtype()) tgt.getEvent().addSubtype(convertCoding(t));
    tgt.getEvent().setAction(convertAuditEventAction(src.getAction()));
    tgt.getEvent().setDateTime(src.getRecorded());
    tgt.getEvent().setOutcome(convertAuditEventOutcome(src.getOutcome()));
    tgt.getEvent().setOutcomeDesc(src.getOutcomeDesc());
    for (org.hl7.fhir.dstu3.model.Coding t : src.getPurposeOfEvent()) tgt.getEvent().addPurposeOfEvent(convertCoding(t));
    for (org.hl7.fhir.dstu3.model.AuditEvent.AuditEventAgentComponent t : src.getAgent()) tgt.addParticipant(convertAuditEventAgentComponent(t));
    tgt.setSource(convertAuditEventSourceComponent(src.getSource()));
    for (org.hl7.fhir.dstu3.model.AuditEvent.AuditEventEntityComponent t : src.getEntity()) tgt.addObject(convertAuditEventEntityComponent(t));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.AuditEvent convertAuditEvent(org.hl7.fhir.dstu3.model.AuditEvent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public boolean mergeSets(int elemIndex0, int elemIndex1) {
    int repr0 = getRepr(elemIndex0);
    int repr1 = getRepr(elemIndex1);
    if (repr0 == repr1)
        return false;
    int cmp = ranks[repr0] - ranks[repr1];
    if (cmp == 0)
        ranks[repr0]++;
    else if (cmp < 0) {
        int temp = repr0;
        repr0 = repr1;
        repr1 = temp;
    }
    parents[repr1] = repr0;
    sizes[repr0] += sizes[repr1];
    sizes[repr1] = 0;
    numSets--;
    return true;
}

Output:
         return false;
-    int cmp = ranks[repr0] - ranks[repr1];
-    if (cmp == 0)
-        ranks[repr0]++;
-    else if (cmp < 0) {
+    int cmp = ranks.get(repr0) - ranks.get(repr1);
+    if (cmp == 0) {
+        int r = ranks.get(repr0);
+        ranks.put(repr0, r + 1);
+    } else if (cmp < 0) {
         int temp = repr0;


Input:
public boolean isReady() throws PtalonRuntimeException {
    if (_unknownAssignments.size() > 0) {
        return false;
    }
    try {
        if (getType(_symbol).equals("String_Node_Str")) {
            PtalonParameter param = _actor.getPtalonParameter(_symbol);
            if (!param.hasValue()) {
                return false;
            }
        } else if (!(getType(_symbol).equals("String_Node_Str") || getType(_symbol).equals("String_Node_Str"))) {
            throw new PtalonRuntimeException("String_Node_Str" + _symbol);
        }
        for (String bool : _boolParams) {
            PtalonBoolParameter param = (PtalonBoolParameter) _actor.getAttribute(getMappedName(bool));
            if (!param.hasValue()) {
                return false;
            }
        }
        for (String integer : _intParams) {
            PtalonIntParameter param = (PtalonIntParameter) _actor.getAttribute(getMappedName(integer));
            if (!param.hasValue()) {
                return false;
            }
        }
        for (ActorTree child : _children) {
            if (!child.isReady()) {
                return false;
            }
        }
        return true;
    } catch (Exception e) {
        throw new PtalonRuntimeException("String_Node_Str");
    }
}

Output:
 public boolean isReady() throws PtalonRuntimeException {
-    if (_unknownAssignments.size() > 0) {
-        return false;
+    for (String portName : _unknownExpressions.keySet()) {
+        if (evaluateString(_unknownExpressions.get(portName)) == null) {
+            return false;
+        }
     }


Input:
private void generateComponentElementParamInfo(boolean istRunJob, Element parametersElement, List elementParameterList, INode node) {
    List<IElementParameter> copyElementParameterList = new ArrayList(elementParameterList);
    if (elementParameterList != null && elementParameterList.size() != 0) {
        for (int j = 0; j < elementParameterList.size(); j++) {
            IElementParameter elemparameter = (IElementParameter) elementParameterList.get(j);
            if ((istRunJob && elemparameter.getName().equals("String_Node_Str")) || (!elemparameter.isShow(copyElementParameterList) && (!elemparameter.getName().equals(EParameterFieldType.SCHEMA_TYPE.getName()))) || elemparameter.getCategory().equals(EComponentCategory.MAIN) || elemparameter.getCategory().equals(EComponentCategory.VIEW) || elemparameter.getName().equals(IHTMLDocConstants.REPOSITORY) || elemparameter.getName().equals("String_Node_Str") || elemparameter.getName().equals("String_Node_Str") || elemparameter.getName().equals("String_Node_Str") || elemparameter.getName().equals(EParameterFieldType.ENCODING_TYPE.getName())) {
                continue;
            }
            Object eleObj = elemparameter.getValue();
            String value = "String_Node_Str";
            if (eleObj != null) {
                value = eleObj.toString();
            }
            if (elemparameter.getName().equals(EParameterFieldType.PROPERTY_TYPE.getName()) && value.equals(IHTMLDocConstants.REPOSITORY)) {
                String repositoryValueForPropertyType = getRepositoryValueForPropertyType(copyElementParameterList, "String_Node_Str");
                value = repositoryValueForPropertyType == null ? IHTMLDocConstants.REPOSITORY_BUILT_IN : value.toString().toLowerCase() + "String_Node_Str" + repositoryValueForPropertyType;
            } else if (elemparameter.getName().equals(EParameterFieldType.SCHEMA_TYPE.getName()) && value.equals(IHTMLDocConstants.REPOSITORY)) {
                String repositoryValueForSchemaType = getRepositoryValueForSchemaType(copyElementParameterList, "String_Node_Str");
                value = repositoryValueForSchemaType == null ? IHTMLDocConstants.REPOSITORY_BUILT_IN : value.toString().toLowerCase() + "String_Node_Str" + repositoryValueForSchemaType;
            } else if (elemparameter.getName().equals(EParameterFieldType.QUERYSTORE_TYPE.getName()) && value.equals(IHTMLDocConstants.REPOSITORY)) {
                String repositoryValueForQueryStoreType = getRepositoryValueForQueryStoreType(copyElementParameterList, "String_Node_Str");
                value = repositoryValueForQueryStoreType == null ? IHTMLDocConstants.REPOSITORY_BUILT_IN : value.toString().toLowerCase() + "String_Node_Str" + repositoryValueForQueryStoreType;
            } else if (elemparameter.getRepositoryValue() != null && elemparameter.getRepositoryValue().contains("String_Node_Str") && ProjectManager.getInstance().getCurrentProject().getEmfProject().isHidePassword() && !ContextParameterUtils.containContextVariables((String) elemparameter.getValue())) {
                value = "String_Node_Str";
            }
            Element columnElement = parametersElement.addElement("String_Node_Str");
            columnElement.addAttribute("String_Node_Str", HTMLDocUtils.checkString(elemparameter.getDisplayName()));
            if (value.equalsIgnoreCase(IHTMLDocConstants.REPOSITORY_BUILT_IN)) {
                value = IHTMLDocConstants.DISPLAY_BUILT_IN;
            }
            columnElement.setText(value);
        }
    }
}

Output:
             }
-            columnElement.setText(value);
+            columnElement.addAttribute("String_Node_Str", HTMLDocUtils.checkString(value));
         }


Input:
private RDSaveHelper getRdSaveHelper() {
    if (this.rdSaveHelper == null) {
        rdSaveHelper = new RDSaveHelper(this.resultService.getSession().getEngineContext(), this.resultService.getQueryDefn(), this.odiResult, new IDInfo(this.resultService.getQueryResults().getID()));
    }
    return this.rdSaveHelper;
}

Output:
     if (this.rdSaveHelper == null) {
-        rdSaveHelper = new RDSaveHelper(this.resultService.getSession().getEngineContext(), this.resultService.getQueryDefn(), this.odiResult, new IDInfo(this.resultService.getQueryResults().getID()));
+        IDInfo id = null;
+        if (this.resultService.getQueryDefn() instanceof ISubqueryDefinition) {
+            id = new IDInfo(null, this.resultService.getQueryDefn().getName());
+        } else {
+            id = new IDInfo(this.resultService.getQueryResults().getID());
+        }
+        rdSaveHelper = new RDSaveHelper(this.resultService.getSession().getEngineContext(), this.resultService.getQueryDefn(), this.odiResult, id);
     }


Input:
public void checkUserSuspension() {
    UserTO userTO = UserTestITCase.getUniqueSampleTO("String_Node_Str");
    MembershipTO membershipTO = new MembershipTO();
    membershipTO.setRoleId(7L);
    AttributeTO testAttributeTO = new AttributeTO();
    testAttributeTO.setSchema("String_Node_Str");
    testAttributeTO.addValue("String_Node_Str");
    membershipTO.addAttribute(testAttributeTO);
    userTO.addMembership(membershipTO);
    userTO = createUser(userTO);
    assertNotNull(userTO);
    UserService userService2 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
    userTO = userService2.read(userTO.getId());
    assertNotNull(userTO);
    assertNotNull(userTO.getFailedLogins());
    assertEquals(Integer.valueOf(0), userTO.getFailedLogins());
    UserService userService3 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
    Throwable t = null;
    try {
        userService3.read(userTO.getId());
        fail();
    } catch (Exception e) {
        t = e;
    }
    assertNotNull(t);
    t = null;
    try {
        userService3.read(userTO.getId());
    } catch (Exception e) {
        t = e;
    }
    assertNotNull(t);
    t = null;
    try {
        userService3.read(userTO.getId());
    } catch (Exception e) {
        t = e;
    }
    assertNotNull(t);
    t = null;
    super.resetRestTemplate();
    userTO = userService.read(userTO.getId());
    assertNotNull(userTO);
    assertNotNull(userTO.getFailedLogins());
    assertEquals(Integer.valueOf(3), userTO.getFailedLogins());
    userService3 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
    try {
        userService3.read(userTO.getId());
    } catch (Exception e) {
        t = e;
    }
    assertNotNull(t);
    t = null;
    super.resetRestTemplate();
    userTO = userService.read(userTO.getId());
    assertNotNull(userTO);
    assertNotNull(userTO.getFailedLogins());
    assertEquals(Integer.valueOf(3), userTO.getFailedLogins());
    assertEquals("String_Node_Str", userTO.getStatus());
    userService2 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
    try {
        userService2.read(userTO.getId());
        assertNotNull(userTO);
    } catch (Exception e) {
        t = e;
    }
    assertNotNull(t);
    t = null;
    super.resetRestTemplate();
    userTO = userService.reactivate(userTO.getId());
    assertNotNull(userTO);
    assertEquals("String_Node_Str", userTO.getStatus());
    userService2 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
    userTO = userService2.read(userTO.getId());
    assertNotNull(userTO);
    assertEquals(Integer.valueOf(0), userTO.getFailedLogins());
}

Output:
     assertNotNull(userTO);
-    UserService userService2 = setupCredentials(userService, userTO.getUsername(), "String_Node_Str");
+    UserService userService2 = setupCredentials(userService, UserService.class, userTO.getUsername(), "String_Node_Str");
     userTO = userService2.read(userTO.getId());


Input:
ModuleDefinition copy(String URIprefix, String displayId, String version) {
    ModuleDefinition cloned = this.deepCopy();
    cloned.setWasDerivedFrom(this.getIdentity());
    cloned.setPersistentIdentity(createCompliantURI(URIprefix, displayId, "String_Node_Str"));
    cloned.setDisplayId(displayId);
    cloned.setVersion(version);
    URI newIdentity = createCompliantURI(URIprefix, displayId, version);
    cloned.setIdentity(newIdentity);
    int count = 0;
    for (FunctionalComponent component : cloned.getFunctionalComponents()) {
        if (!component.isSetDisplayId())
            component.setDisplayId("String_Node_Str" + ++count);
        component.updateCompliantURI(this.getPersistentIdentity().toString(), component.getDisplayId(), version);
        cloned.removeChildSafely(component, cloned.functionalComponents);
        cloned.addFunctionalComponent(component);
    }
    count = 0;
    for (Module module : cloned.getModules()) {
        if (!module.isSetDisplayId())
            module.setDisplayId("String_Node_Str" + ++count);
        module.updateCompliantURI(this.getPersistentIdentity().toString(), module.getDisplayId(), version);
        cloned.removeChildSafely(module, cloned.modules);
        cloned.addModule(module);
    }
    count = 0;
    for (Interaction interaction : cloned.getInteractions()) {
        if (!interaction.isSetDisplayId())
            interaction.setDisplayId("String_Node_Str" + ++count);
        interaction.updateCompliantURI(this.getPersistentIdentity().toString(), interaction.getDisplayId(), version);
        cloned.removeChildSafely(interaction, cloned.interactions);
        cloned.addInteraction(interaction);
    }
    return cloned;
}

Output:
             component.setDisplayId("String_Node_Str" + ++count);
-        component.updateCompliantURI(this.getPersistentIdentity().toString(), component.getDisplayId(), version);
+        component.updateCompliantURI(cloned.getPersistentIdentity().toString(), component.getDisplayId(), version);
         cloned.removeChildSafely(component, cloned.functionalComponents);


Input:
public String getHighlightTitle() {
    if (StringHelper.containsNonWhitespace(highlightTitle)) {
        return highlightTitle;
    }
    return getTitle();
}

Output:
 public String getHighlightTitle() {
-    if (StringHelper.containsNonWhitespace(highlightTitle)) {
-        return highlightTitle;
-    }
-    return getTitle();
+    return highlightTitle;
 }


Input:
public void run() {
    boolean connected = true;
    clientInfo.setForward(false);
    clientInfo.setHostname(null);
    LocalSocket clientSocket = new LocalSocket(socketToClient, this);
    if (!clientSocket.success) {
        printLogMessage("String_Node_Str");
        return;
    }
    String kickMessage = Packet01Login.processLogin(clientSocket.in, clientSocket.out, this, this, Globals.isAuth(), clientInfo);
    if (kickMessage != null) {
        printLogMessage(kickMessage);
        PacketFFKick.kick(clientSocket.out, this, this, kickMessage);
        connected = false;
    }
    if (BanList.banned(clientInfo.getUsername())) {
        printLogMessage(clientInfo.getUsername() + "String_Node_Str");
        PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
        connected = false;
    }
    if (clientInfo.getHostname() == null) {
        clientInfo.setHostname(ReconnectCache.get(clientInfo.getUsername()));
        if (clientInfo.getHostname() == null || clientInfo.getHostname().equals("String_Node_Str")) {
            clientInfo.setHostname(defaultHostname);
        }
    }
    boolean firstConnection = true;
    while (connected && !killed()) {
        String redirectLocal = getRedirect();
        setRedirect(null);
        if (redirectLocal != null) {
            clientInfo.setHostname(redirectLocal);
        }
        printLogMessage("String_Node_Str" + clientInfo.getHostname());
        String nextHostname = RedirectManager.getNextHostname(listenHostname, clientInfo.getHostname());
        Integer nextPortnum = RedirectManager.getNextPort(listenHostname, clientInfo.getHostname());
        if (nextHostname == null || nextPortnum == null) {
            printLogMessage("String_Node_Str" + clientInfo.getHostname());
            PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str" + clientInfo.getHostname());
            LocalSocket.closeSocket(clientSocket.socket, this);
            return;
        }
        Socket serverBasicSocket = LocalSocket.openSocket(nextHostname, nextPortnum, this);
        if (serverBasicSocket == null) {
            printLogMessage("String_Node_Str");
            PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
            LocalSocket.closeSocket(clientSocket.socket, this);
            return;
        }
        LocalSocket serverSocket = new LocalSocket(serverBasicSocket, this);
        if (!serverSocket.success) {
            printLogMessage("String_Node_Str");
            PacketFFKick.kickAndClose(clientSocket, this, this, "String_Node_Str");
            return;
        }
        Boolean proxyLogin = RedirectManager.isNextProxy(listenHostname, clientInfo.getHostname());
        if (proxyLogin == null) {
            printLogMessage("String_Node_Str");
            PacketFFKick.kickAndClose(clientSocket, this, this, "String_Node_Str");
            return;
        }
        kickMessage = Packet01Login.serverLogin(serverSocket.in, serverSocket.out, this, this, proxyLogin, clientInfo);
        if (kickMessage != null) {
            printLogMessage(kickMessage);
            PacketFFKick.kick(clientSocket.out, this, this, kickMessage);
            connected = false;
        }
        if (connected) {
            Packet01Login serverLoginPacket = new Packet01Login(serverSocket.in, this, this);
            if (serverLoginPacket.packetId == null || serverLoginPacket.read(serverSocket.in, this, this, true, null) == null) {
                printLogMessage("String_Node_Str");
                connected = false;
            } else {
                if (serverLoginPacket.packetId == 0x01) {
                    clientInfo.setPlayerEntityId(serverLoginPacket.getVersion());
                } else if (serverLoginPacket.packetId == (byte) 0xFF) {
                    PacketFFKick.kickAndClose(clientSocket, this, this, ((UnitString) serverLoginPacket.fields[0]).getValue());
                    return;
                } else {
                    PacketFFKick.kickAndClose(clientSocket, this, this, "String_Node_Str");
                    return;
                }
                if (firstConnection) {
                    firstConnection = false;
                    Packet01Login clientLoginPacket = new Packet01Login(clientSocket.out, this, this);
                    if (!clientInfo.getForward()) {
                        clientLoginPacket.setVersion(Globals.getDefaultPlayerId());
                    } else {
                        clientLoginPacket.setVersion(serverLoginPacket.getVersion());
                    }
                    if (Globals.getDimension() == null) {
                        if (Globals.isVerbose()) {
                            printLogMessage("String_Node_Str" + serverLoginPacket.getDimension());
                        }
                        clientLoginPacket.setDimension(serverLoginPacket.getDimension());
                    } else {
                        if (Globals.isVerbose()) {
                            printLogMessage("String_Node_Str" + Globals.getDimension());
                        }
                        clientLoginPacket.setDimension(Globals.getDimension());
                    }
                    clientLoginPacket.setMapSeed(serverLoginPacket.getMapSeed());
                    clientLoginPacket.setUsername(serverLoginPacket.getUsername());
                    if (clientLoginPacket.packetId == null || clientLoginPacket.write(clientSocket.out, this, this, true) == null) {
                        printLogMessage("String_Node_Str");
                        connected = false;
                    }
                } else {
                    short holdingLocal = getHolding();
                    if (holdingLocal != 0) {
                        if (!Globals.isQuiet()) {
                            printLogMessage("String_Node_Str" + holding);
                        }
                        Packet10HoldingChange holdingChange = new Packet10HoldingChange(serverSocket.out, this, this);
                        holdingChange.setSlot(holding);
                        if (holdingChange.packetId == null || holdingChange.write(serverSocket.out, this, this, false) == null) {
                            printLogMessage("String_Node_Str");
                            connected = false;
                        }
                    }
                }
                if (connected) {
                    if (!Globals.isQuiet()) {
                        if (clientInfo.getForward()) {
                            printLogMessage("String_Node_Str");
                        } else {
                            printLogMessage("String_Node_Str");
                        }
                    }
                    ReconnectCache.store(clientInfo.getUsername(), clientInfo.getHostname());
                    if (clientInfo.getForward()) {
                        serverToClient = new DataStreamBridge(serverSocket.in, clientSocket.out, this);
                        clientToServer = new DataStreamBridge(clientSocket.in, serverSocket.out, this);
                        connected = false;
                    } else {
                        serverToClient = new DataStreamDownLinkBridge(serverSocket.in, clientSocket.out, this);
                        clientToServer = new DataStreamUpLinkBridge(clientSocket.in, serverSocket.out, this);
                    }
                    boolean localEnabled;
                    synchronized (enabledSync) {
                        localEnabled = enabled;
                        if (enabled) {
                            serverToClient.start();
                            clientToServer.start();
                        }
                    }
                    if (localEnabled) {
                        while ((clientToServer.isAlive() || serverToClient.isAlive())) {
                            try {
                                clientToServer.join(500);
                                serverToClient.join(500);
                            } catch (InterruptedException ie) {
                                kill();
                            }
                            if (killed() || (!(clientToServer.isAlive() && serverToClient.isAlive()))) {
                                clientToServer.interrupt();
                                serverToClient.interrupt();
                            }
                        }
                        connected = getRedirect() != null;
                    }
                }
            }
        }
        printLogMessage("String_Node_Str");
        LocalSocket.closeSocket(serverSocket.socket, this);
        if (connected) {
            if (Globals.isVerbose()) {
                printLogMessage("String_Node_Str");
            }
            revive();
        }
    }
    if (!getKickMessageSent()) {
        PacketFFKick.kick(clientSocket.out, this, this, "String_Node_Str");
    }
    printLogMessage("String_Node_Str");
    LocalSocket.closeSocket(clientSocket.socket, this);
}

Output:
         printLogMessage(kickMessage);
-        PacketFFKick.kick(clientSocket.out, this, this, kickMessage);
+        PacketFFKick.kickAndClose(clientSocket, this, this, kickMessage);
         connected = false;


Input:
public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("String_Node_Str");
    builder.append(this.instanceId).append("String_Node_Str");
    if (this.runtimeState != null)
        builder.append("String_Node_Str").append(this.runtimeState.getReference()).append("String_Node_Str");
    if (this.clusterName != null)
        builder.append("String_Node_Str").append(this.clusterName).append("String_Node_Str");
    if (this.partitionName != null)
        builder.append("String_Node_Str").append(this.partitionName).append("String_Node_Str");
    if (this.imageId != null)
        builder.append("String_Node_Str").append(this.imageId).append("String_Node_Str");
    if (this.kernelId != null)
        builder.append("String_Node_Str").append(this.kernelId).append("String_Node_Str");
    if (this.ramdiskId != null)
        builder.append("String_Node_Str").append(this.ramdiskId).append("String_Node_Str");
    if (this.vmType != null)
        builder.append("String_Node_Str").append(this.vmType).append("String_Node_Str");
    if (this.platform != null)
        builder.append("String_Node_Str").append(this.platform).append("String_Node_Str");
    if (this.networkGroups != null)
        builder.append("String_Node_Str").append(this.networkGroups).append("String_Node_Str");
    if (this.networkIndex != null)
        builder.append("String_Node_Str").append(this.networkIndex).append("String_Node_Str");
    if (this.transientVolumes != null)
        builder.append("String_Node_Str").append(this.transientVolumes).append("String_Node_Str");
    if (this.persistentVolumes != null)
        builder.append("String_Node_Str").append(this.persistentVolumes);
    if (this.bundleTask != null)
        builder.append("String_Node_Str").append(this.bundleTask).append("String_Node_Str");
    if (this.networkConfig != null)
        builder.append("String_Node_Str").append(this.networkConfig).append("String_Node_Str");
    if (this.launchTime != null)
        builder.append("String_Node_Str").append(this.launchTime).append("String_Node_Str");
    if (this.sshKeyPair != null)
        builder.append("String_Node_Str").append(this.sshKeyPair).append("String_Node_Str");
    return builder.toString();
}

Output:
         builder.append("String_Node_Str").append(this.persistentVolumes);
-    if (this.bundleTask != null)
+    if (this.bundleTask != null && this.bundleTask.getReference() != null)
         builder.append("String_Node_Str").append(this.bundleTask).append("String_Node_Str");


Input:
public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
    if (DBG)
        log("String_Node_Str" + token + "String_Node_Str" + cookie + "String_Node_Str" + ci);
    if (cookie instanceof Call) {
        if (DBG)
            log("String_Node_Str");
        Call call = (Call) cookie;
        Connection conn = call.getEarliestConnection();
        PhoneUtils.CallerInfoToken cit = PhoneUtils.startGetCallerInfo(getContext(), conn, this, null);
        int presentation = Connection.PRESENTATION_ALLOWED;
        if (conn != null)
            presentation = conn.getNumberPresentation();
        if (DBG)
            log("String_Node_Str" + presentation + "String_Node_Str" + ci.contactExists);
        if (ci.contactExists) {
            updateDisplayForPerson(ci, Connection.PRESENTATION_ALLOWED, false, call);
        } else {
            updateDisplayForPerson(cit.currentInfo, presentation, false, call);
        }
        updatePhotoForCallState(call);
    } else if (cookie instanceof TextView) {
        if (DBG)
            log("String_Node_Str");
        ((TextView) cookie).setText(PhoneUtils.getCompactNameFromCallerInfo(ci, mContext));
    }
}

Output:
         Call call = (Call) cookie;
-        Connection conn = call.getEarliestConnection();
+        Connection conn = null;
+        int phoneType = mApplication.phone.getPhoneType();
+        if (phoneType == Phone.PHONE_TYPE_CDMA) {
+            conn = call.getLatestConnection();
+        } else if (phoneType == Phone.PHONE_TYPE_GSM) {
+            conn = call.getEarliestConnection();
+        } else {
+            throw new IllegalStateException("String_Node_Str" + phoneType);
+        }
         PhoneUtils.CallerInfoToken cit = PhoneUtils.startGetCallerInfo(getContext(), conn, this, null);


Input:
void genAggrCode(ST code, String headTable, ST ifUpdated) {
    AggrFunction f = headP.getAggrF();
    String contains = containsGroupbyPrefix(headTable, f);
    ST if_ = tmplGroup.getInstanceOf("String_Node_Str");
    if (f.isSimpleAggr()) {
        if_.add("String_Node_Str", "String_Node_Str" + contains);
        if_.add("String_Node_Str", assignVars(Arrays.asList(new Object[] { aggrVar() }), f.getArgs()));
        if_.add("String_Node_Str", insertHeadParamsTo(headTable));
        if_.add("String_Node_Str", isUpdatedVar() + "String_Node_Str");
        if_.add("String_Node_Str", ifUpdated);
        if_.add("String_Node_Str", "String_Node_Str");
        code.add("String_Node_Str", if_);
    } else {
        if_.add("String_Node_Str", "String_Node_Str" + contains);
        if (f.getAggrColumnType().isArray()) {
            String aggrValType = f.getAggrColumnType().getComponentType().getSimpleName();
            Variable v = (Variable) f.getArgs().get(0);
            if_.add("String_Node_Str", aggrValType + "String_Node_Str" + aggrVar() + "String_Node_Str" + aggrValType + "String_Node_Str" + v + "String_Node_Str");
            if_.add("String_Node_Str", "String_Node_Str" + aggrVar() + "String_Node_Str" + aggrVar() + "String_Node_Str" + aggrValType + "String_Node_Str");
        } else {
            String aggrValType = f.getAggrColumnType().getSimpleName();
            if_.add("String_Node_Str", aggrValType + "String_Node_Str" + aggrVar() + "String_Node_Str" + aggrValType + "String_Node_Str" + "String_Node_Str");
        }
        if_.add("String_Node_Str", isUpdatedVar() + "String_Node_Str" + f.codegen(aggrVar()).render());
        if_.add("String_Node_Str", insertHeadParamsTo(headTable));
        if_.add("String_Node_Str", "String_Node_Str");
        code.add("String_Node_Str", if_);
    }
    genAggrUpdateCode(code, headTable, ifUpdated);
    if (useChoice()) {
        ifUpdated.add("String_Node_Str", choiceMadeVar() + "String_Node_Str");
        if (hasOnlyChoiceVar(rule.getHead())) {
            ifUpdated.add("String_Node_Str", "String_Node_Str");
        }
    }
}

Output:
     String contains = containsGroupbyPrefix(headTable, f);
-    ST if_ = tmplGroup.getInstanceOf("String_Node_Str");
+    ST ifElse = tmplGroup.getInstanceOf("String_Node_Str");
     if (f.isSimpleAggr()) {


Input:
private void analyze() {
    if (model == null) {
        return;
    }
    final long time = System.currentTimeMillis();
    ModelConfiguration config = model.getOutputConfig();
    if (config == null) {
        config = model.getInputConfig();
    }
    DataHandle data;
    if (target == ModelPart.INPUT) {
        data = config.getInput().getHandle();
    } else {
        data = model.getOutput();
    }
    if ((config == null) || (data == null)) {
        reset();
        return;
    }
    if (data != null)
        data = data.getView(config.getConfig());
    final int index = data.getColumnIndexOf(attribute);
    if (index == -1) {
        clearCache();
        reset();
        return;
    }
    if (cache.containsKey(attribute)) {
        return;
    }
    final AttributeType type = config.getInput().getDefinition().getAttributeType(attribute);
    Hierarchy hierarchy = null;
    if (type instanceof Hierarchy) {
        hierarchy = (Hierarchy) type;
    } else if (type == AttributeType.SENSITIVE_ATTRIBUTE) {
        hierarchy = config.getHierarchy(attribute);
    }
    boolean suppressed = false;
    final Map<String, Double> map = new HashMap<String, Double>();
    for (int i = 0; i < data.getNumRows(); i++) {
        if (!suppressed) {
            suppressed |= data.isOutlier(i);
        }
        final String val = data.getValue(i, index);
        if (!map.containsKey(val)) {
            map.put(val, 1d);
        } else {
            map.put(val, map.get(val) + 1);
        }
    }
    final String[] dvals;
    if (hierarchy != null) {
        final int level = data.getGeneralization(attribute);
        final List<String> list = new ArrayList<String>();
        final Set<String> done = new HashSet<String>();
        final String[][] h = hierarchy.getHierarchy();
        for (int i = 0; i < h.length; i++) {
            final String val = h[i][level];
            if (map.containsKey(val) || ((model.getAnonymizer() != null) && val.equals(model.getAnonymizer().getSuppressionString()))) {
                if (!done.contains(val)) {
                    list.add(val);
                    done.add(val);
                }
            }
        }
        if (suppressed) {
            if (!done.contains(model.getAnonymizer().getSuppressionString())) {
                list.add(model.getAnonymizer().getSuppressionString());
                if (!map.containsKey(list.add(model.getAnonymizer().getSuppressionString()))) {
                    map.put(model.getAnonymizer().getSuppressionString(), 0d);
                }
            }
        }
        dvals = list.toArray(new String[] {});
    } else {
        final DataType<?> dtype = data.getDataType(attribute);
        final String[] v = new String[map.size()];
        int i = 0;
        for (final String s : map.keySet()) {
            v[i++] = s;
        }
        Arrays.sort(v, new Comparator<String>() {
            public int compare(final String arg0, final String arg1) {
                try {
                    return dtype.compare(arg0, arg1);
                } catch (final Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        dvals = v;
    }
    double sum = 0;
    for (final double i : map.values()) {
        sum += i;
    }
    int step = map.size() / MAX_DIMENSION;
    step = Math.max(step, 1);
    final int length = (int) Math.ceil((double) map.size() / (double) step);
    controller.getResources().getLogger().info("String_Node_Str" + length + "String_Node_Str" + step + "String_Node_Str" + dvals.length + "String_Node_Str" + MAX_DIMENSION);
    int sindex = 0;
    final double[] distribution = new double[length];
    for (int i = 0; i < dvals.length; i += step) {
        for (int j = 0; j < step; j++) {
            if (sindex < distribution.length) {
                if ((i + j) < dvals.length) {
                    distribution[sindex] += map.get(dvals[i + j]) / sum;
                }
            } else {
                controller.getResources().getLogger().warn("String_Node_Str");
            }
        }
        sindex++;
    }
    cache.put(attribute, distribution);
    controller.getResources().getLogger().info("String_Node_Str" + (System.currentTimeMillis() - time));
}

Output:
     }
-    if (data != null)
+    if (data != null && model.getViewConfig().isSubset()) {
         data = data.getView(config.getConfig());


Input:
private void drawLeft(Graphics g, int rowIndex, int colIndex, int x, int y, int w, int h, int[] data) {
    if (data[0] == 0 && data[1] == 0) {
        return;
    }
    int nTopWidth = 0;
    int nTopStyle = 0;
    int nTopX = -1;
    int nTopY = -1;
    if (rowIndex > 0) {
        int[] nTop = borderData[(rowIndex - 1) * (2 * colCount + 1) + colCount + colIndex];
        nTopWidth = nTop[1];
        nTopStyle = nTop[0];
        nTopX = nTop[3];
        nTopY = nTop[4];
    }
    int nBottomWidth = 0;
    int nBottomStyle = 0;
    int nBottomX = -1;
    int nBottomY = -1;
    if (rowIndex < rowCount - 1) {
        int[] nBottom = borderData[(rowIndex + 1) * (2 * colCount + 1) + colCount + colIndex];
        nBottomWidth = nBottom[1];
        nBottomStyle = nBottom[0];
        nBottomX = nBottom[3];
        nBottomY = nBottom[4];
    }
    int nTopLeftWidth = 0;
    int nTopLeftStyle = 0;
    int nTopLeftX = -1;
    int nTopLeftY = -1;
    if (colIndex > 0 && rowIndex >= 0) {
        int[] nTopLeft = borderData[rowIndex * (2 * colCount + 1) + colIndex - 1];
        nTopLeftWidth = nTopLeft[1];
        nTopLeftStyle = nTopLeft[0];
        nTopLeftX = nTopLeft[3];
        nTopLeftY = nTopLeft[4];
    }
    int nTopRightWidth = 0;
    int nTopRightStyle = 0;
    int nTopRightX = -1;
    int nTopRightY = -1;
    if (colIndex >= 0 && rowIndex >= 0) {
        int[] nTopRight = borderData[rowIndex * (2 * colCount + 1) + colIndex];
        nTopRightWidth = nTopRight[1];
        nTopRightStyle = nTopRight[0];
        nTopRightX = nTopRight[3];
        nTopRightY = nTopRight[4];
    }
    int nBottomLeftWidth = 0;
    int nBottomLeftStyle = 0;
    int nBottomLeftX = -1;
    int nBottomLeftY = -1;
    if (colIndex > 0 && rowIndex <= rowCount - 1) {
        int[] nBottomLeft = borderData[(rowIndex + 1) * (2 * colCount + 1) + colIndex - 1];
        nBottomLeftWidth = nBottomLeft[1];
        nBottomLeftStyle = nBottomLeft[0];
        nBottomLeftX = nBottomLeft[3];
        nBottomLeftY = nBottomLeft[4];
    }
    int nBottomRightWidth = 0;
    int nBottomRightStyle = 0;
    int nBottomRightX = -1;
    int nBottomRightY = -1;
    if (colIndex >= 0 && rowIndex <= rowCount - 1) {
        int[] nBottomRight = borderData[(rowIndex + 1) * (2 * colCount + 1) + colIndex];
        nBottomRightWidth = nBottomRight[1];
        nBottomRightStyle = nBottomRight[0];
        nBottomRightX = nBottomRight[3];
        nBottomRightY = nBottomRight[4];
    }
    int ntexWidth = Math.max(nTopLeftWidth, nTopRightWidth);
    boolean exTop = false;
    boolean exBottom = false;
    int ry = (rowIndex == 0) ? (y + ntexWidth) : (y + ntexWidth / 2);
    int rh = (rowIndex == 0) ? (h - ntexWidth) : (h - ntexWidth / 2);
    if (TableBorderCollisionArbiter.canExtend(data, nTopWidth, nTopStyle, nTopLeftWidth, nTopLeftStyle, nTopLeftX, nTopLeftY, nTopRightWidth, nTopRightStyle, nTopRightX, nTopRightY, true, true) || TableBorderCollisionArbiter.isBrotherWin(data, nTopWidth, nTopStyle, nTopX, nTopY, nTopLeftWidth, nTopLeftStyle, nTopLeftX, nTopLeftY, nTopRightWidth, nTopRightStyle, nTopRightX, nTopRightY, true, true) || (data[3] == -2)) {
        ry = (rowIndex == 0) ? (y) : (y - ntexWidth / 2 - ntexWidth % 2);
        rh = (rowIndex == 0) ? (h) : (h + ntexWidth / 2 + ntexWidth % 2);
        exTop = true;
    }
    int nbexWidth = Math.max(nBottomLeftWidth, nBottomRightWidth);
    if (TableBorderCollisionArbiter.canExtend(data, nBottomWidth, nBottomStyle, nBottomRightWidth, nBottomRightStyle, nBottomRightX, nBottomRightY, nBottomLeftWidth, nBottomLeftStyle, nBottomLeftX, nBottomLeftY, false, true) || TableBorderCollisionArbiter.isBrotherWin(data, nBottomWidth, nBottomStyle, nBottomX, nBottomY, nBottomRightWidth, nBottomRightStyle, nBottomRightX, nBottomRightY, nBottomLeftWidth, nBottomLeftStyle, nBottomLeftX, nBottomLeftY, false, true) || (data[3] == -2 && rowIndex == rowCount - 1)) {
        rh += ((rowIndex == rowCount - 1) ? (0) : (nbexWidth / 2));
        exBottom = true;
    } else {
        rh -= ((rowIndex == rowCount - 1) ? (nbexWidth) : (nbexWidth / 2 + nbexWidth % 2));
    }
    int direction = BorderUtil.LEFT;
    int[] widths = new int[] { 0, 0, data[1], 0 };
    if (data[3] == nTopLeftX && data[4] == nTopLeftY && data[3] == nBottomLeftX && data[4] == nBottomLeftY) {
        direction = BorderUtil.RIGHT;
        widths[0] = exTop ? nTopLeftWidth : 0;
        widths[1] = exBottom ? nBottomLeftWidth : 0;
        widths[2] = 0;
        widths[3] = data[1];
    } else if (data[3] == nTopLeftX && data[4] == nTopLeftY) {
        direction = BorderUtil.RIGHT;
        widths[0] = exTop ? nTopLeftWidth : 0;
        widths[1] = 0;
        widths[2] = 0;
        widths[3] = data[1];
    } else if (data[3] == nBottomLeftX && data[4] == nBottomLeftY) {
        direction = BorderUtil.RIGHT;
        widths[0] = 0;
        widths[1] = exBottom ? nBottomLeftWidth : 0;
        widths[2] = 0;
        widths[3] = data[1];
    } else if (data[3] == nTopRightX && data[4] == nTopRightY && data[3] == nBottomRightX && data[4] == nBottomRightY) {
        widths[0] = exTop ? nTopRightWidth : 0;
        widths[1] = exBottom ? nBottomRightWidth : 0;
        widths[2] = data[1];
        widths[3] = 0;
    } else if (data[3] == nTopRightX && data[4] == nTopRightY) {
        widths[0] = exTop ? nTopRightWidth : 0;
        widths[1] = 0;
        widths[2] = data[1];
        widths[3] = 0;
    } else if (data[3] == nBottomRightX && data[4] == nBottomRightY) {
        widths[0] = 0;
        widths[1] = exBottom ? nBottomRightWidth : 0;
        widths[2] = data[1];
        widths[3] = 0;
    } else if (data[3] != rowIndex || data[4] != colIndex) {
        direction = BorderUtil.LEFT;
        widths[0] = 0;
        widths[1] = 0;
        widths[2] = data[1];
        widths[3] = 0;
    }
    Rectangle r = new Rectangle(x - data[1] / 2, ry, data[1], rh);
    if (colIndex == 0) {
        r.x = x;
    }
    if (data[0] != 0) {
        g.setForegroundColor(ColorManager.getColor(data[2]));
        if (data[0] == -2) {
            BorderUtil.drawDoubleLine(g, direction, widths, r);
        } else {
            BorderUtil.drawSingleLine(g, direction, data[0], widths, r);
        }
    } else if (data[1] > 0) {
        g.setForegroundColor(ReportColorConstants.ShadowLineColor);
        BorderUtil.drawDefaultLine(g, direction, r);
    }
}

Output:
         g.setForegroundColor(ColorManager.getColor(data[2]));
-        if (data[0] == -2) {
-            BorderUtil.drawDoubleLine(g, direction, widths, r);
-        } else {
-            BorderUtil.drawSingleLine(g, direction, data[0], widths, r);
-        }
+        BorderUtil.drawBorderLine(g, direction, data[0], widths, r);
     } else if (data[1] > 0) {


Input:
public static Collection<IAttributeType> getIAttributeTypes(Collection<String> types) throws OseeCoreException {
    Collection<IAttributeType> attrTypes = new HashSet<IAttributeType>();
    for (String value : types) {
        long uuid = parseUuid(value);
        if (uuid != -1L) {
            attrTypes.add(TokenFactory.createAttributeType(uuid, "String_Node_Str"));
        }
    }
    return attrTypes;
}

Output:
 public static Collection<IAttributeType> getIAttributeTypes(Collection<String> types) throws OseeCoreException {
-    Collection<IAttributeType> attrTypes = new HashSet<IAttributeType>();
+    Collection<IAttributeType> attrTypes = new LinkedHashSet<IAttributeType>();
     for (String value : types) {


Input:
public void setupSelectComponent(SelectComponent selectComponent) {
    Class<?> valueType = selectComponent.getValueType();
    Iterable<?> choices = null;
    if (valueType.isEnum()) {
        Class<? extends Enum> enumClass = valueType.asSubclass(Enum.class);
        choices = EnumSet.allOf(enumClass);
    } else if (Boolean.class == valueType) {
        choices = Arrays.asList(Boolean.TRUE, Boolean.FALSE);
    } else {
        choices = addonRegistry.getServices(valueType);
    }
    selectComponent.setValueChoices(choices);
}

Output:
         choices = EnumSet.allOf(enumClass);
-    } else if (Boolean.class == valueType) {
+    } else if (Boolean.class == valueType || boolean.class == valueType) {
         choices = Arrays.asList(Boolean.TRUE, Boolean.FALSE);


Input:
public void viewLogout(CellID viewCellId) {
    ViewCellImpl viewCell;
    synchronized (cells) {
        viewCell = (ViewCellImpl) cells.get(viewCellId);
    }
    viewCell.getViewCache().logout();
}

Output:
     synchronized (cells) {
-        viewCell = (ViewCellImpl) cells.get(viewCellId);
+        viewCell = (ViewCellImpl) cells.get(viewCellID);
     }


Input:
public void setJava(String java) {
    this.java = java;
}

Output:
 public void setJava(String java) {
-    this.java = java;
+    this.java.set(0, java);
 }


Input:
public synchronized void sendBuildEvent(BuildEvent event, final ArtifactGroupNamer namer) {
    BuildEventConverters converters = new BuildEventConverters() {
        public PathConverter pathConverter() {
            return pathConverter;
        }
        public ArtifactGroupNamer artifactGroupNamer() {
            return namer;
        }
    };
    String protoJsonRepresentation;
    try {
        protoJsonRepresentation = JsonFormat.printer().omittingInsignificantWhitespace().print(event.asStreamProto(converters)) + "String_Node_Str";
    } catch (InvalidProtocolBufferException e) {
        protoJsonRepresentation = "String_Node_Str";
    }
    writeData(protoJsonRepresentation.getBytes());
}

Output:
     }
-    writeData(protoJsonRepresentation.getBytes());
+    writeData(protoJsonRepresentation.getBytes(StandardCharsets.UTF_8));
 }


Input:
public static byte[] getNextPrefix(final byte[] prefix) {
    return new Scan(prefix).getStopRow();
}

Output:
 public static byte[] getNextPrefix(final byte[] prefix) {
-    return new Scan(prefix).getStopRow();
+    return new Scan().setRowPrefixFilter(prefix).getStopRow();
 }


Input:
public String getBody() {
    if (getSubObjectId() == null || "String_Node_Str".equals(getSubObjectId())) {
        return super.getBody();
    } else {
        Comment comment = DocsApplication.getComment(Long.parseLong(getSubObjectId()));
        if (comment == null) {
            return "String_Node_Str" + getSubObjectId() + "String_Node_Str";
        }
        return renderComment(comment);
    }
}

Output:
         }
-        return renderComment(comment);
+        return renderComment(comment, doc);
     }


Input:
protected void executeInSameVM(String[] args) {
    if (null != maxMem) {
        log("String_Node_Str" + maxMem, Project.MSG_WARN);
    }
    IMessageHolder holder = messageHolder;
    int numPreviousErrors;
    if (null == holder) {
        MessageHandler mhandler = new MessageHandler(true);
        final IMessageHandler delegate = verbose ? MessagePrinter.VERBOSE : MessagePrinter.TERSE;
        mhandler.setInterceptor(delegate);
        if (!verbose) {
            mhandler.ignore(IMessage.INFO);
        }
        holder = mhandler;
        numPreviousErrors = 0;
    } else {
        numPreviousErrors = holder.numMessages(IMessage.ERROR, true);
    }
    {
        Main newmain = new Main();
        newmain.setHolder(holder);
        newmain.setCompletionRunner(new Runnable() {
            public void run() {
                doCompletionTasks();
            }
        });
        if (null != main) {
            MessageUtil.fail(holder, "String_Node_Str");
            return;
        }
        main = newmain;
    }
    try {
        main.runMain(args, false);
    } finally {
        main = null;
    }
    if (failonerror) {
        int errs = holder.numMessages(IMessage.ERROR, false);
        errs -= numPreviousErrors;
        if (0 < errs) {
            throw new BuildException(errs + "String_Node_Str");
        }
    }
    {
        IMessage[] fails = holder.getMessages(IMessage.FAIL, true);
        if (!LangUtil.isEmpty(fails)) {
            StringBuffer sb = new StringBuffer();
            String prefix = "String_Node_Str";
            int numThrown = 0;
            for (int i = 0; i < fails.length; i++) {
                String message = fails[i].getMessage();
                if (LangUtil.isEmpty(message)) {
                    message = "String_Node_Str";
                } else if (-1 != message.indexOf(USAGE_SUBSTRING)) {
                    continue;
                }
                Throwable t = fails[i].getThrown();
                if (null != t) {
                    numThrown++;
                    sb.append(prefix);
                    sb.append(LangUtil.unqualifiedClassName(t.getClass()));
                    String thrownMessage = t.getMessage();
                    if (!LangUtil.isEmpty(thrownMessage)) {
                        sb.append("String_Node_Str" + thrownMessage + "String_Node_Str");
                    }
                }
                sb.append("String_Node_Str" + message + "String_Node_Str");
                prefix = "String_Node_Str";
            }
            if (0 < sb.length()) {
                sb.append("String_Node_Str" + numThrown + "String_Node_Str");
                throw new BuildException(sb.toString());
            }
        }
    }
}

Output:
         if (0 < errs) {
-            throw new BuildException(errs + "String_Node_Str");
+            String m = errs + "String_Node_Str";
+            MessageUtil.print(System.err, holder, "String_Node_Str", MessageUtil.MESSAGE_ALL, MessageUtil.PICK_ERROR, true);
+            throw new BuildException(m);
         }


Input:
private void checkForWaypointMarkerMoving(MarkerSource source, Marker marker, boolean dragging) {
    if (GenericWaypoint.class.isInstance(source)) {
        LatLng position = marker.getPosition();
        GenericWaypoint waypoint = (GenericWaypoint) source;
        waypoint.setCoord(position);
        if (dragging)
            waypoint.updateDistanceFromPrevPoint();
        else
            waypoint.setPrevPoint(mission.getWaypoints());
        updateInfoWindow(waypoint, marker);
        missionPath.update(mission);
        mListener.onMovingWaypoint(waypoint, position);
    }
}

Output:
         GenericWaypoint waypoint = (GenericWaypoint) source;
-        waypoint.setCoord(position);
-        if (dragging)
-            waypoint.updateDistanceFromPrevPoint();
-        else
-            waypoint.setPrevPoint(mission.getWaypoints());
-        updateInfoWindow(waypoint, marker);
+        waypoint.setCoordinate(position);
         missionPath.update(mission);


Input:
public int size() {
    return fArContainer.length;
}

Output:
 public int size() {
-    return fArContainer.length;
+    return container.length;
 }


Input:
private void processTxFromBestChain(Transaction tx) throws VerificationException {
    checkState(lock.isLocked());
    boolean isDeadCoinbase = tx.isCoinBase() && dead.containsKey(tx.getHash());
    if (isDeadCoinbase) {
        log.info("String_Node_Str", tx.getHashAsString(), tx.getConfidence().getConfidenceType().name());
        dead.remove(tx.getHash());
    }
    if (inactive.containsKey(tx.getHash())) {
        log.info("String_Node_Str", tx.getHashAsString());
        inactive.remove(tx.getHash());
    }
    updateForSpends(tx, true);
    boolean hasOutputsToMe = tx.getValueSentToMe(this, true).compareTo(BigInteger.ZERO) > 0;
    if (hasOutputsToMe) {
        if (tx.isEveryOwnedOutputSpent(this)) {
            log.info("String_Node_Str", tx.getHashAsString());
            addWalletTransaction(Pool.SPENT, tx);
        } else {
            log.info("String_Node_Str", tx.getHashAsString());
            addWalletTransaction(Pool.UNSPENT, tx);
        }
    } else if (tx.getValueSentFromMe(this).compareTo(BigInteger.ZERO) > 0) {
        log.info("String_Node_Str", tx.getHashAsString());
        addWalletTransaction(Pool.SPENT, tx);
    }
    TransactionInput doubleSpent = findDoubleSpendAgainstPending(tx);
    if (doubleSpent != null) {
        killTx(tx, doubleSpent, doubleSpent.getParentTransaction());
    }
}

Output:
     }
-    TransactionInput doubleSpent = findDoubleSpendAgainstPending(tx);
-    if (doubleSpent != null) {
-        killTx(tx, doubleSpent, doubleSpent.getParentTransaction());
-    }
+    checkForDoubleSpendAgainstPending(tx, true);
 }


Input:
public static int copy(ByteBuffer src, ByteBuffer dest) {
    int n = Math.min(src.remaining(), dest.remaining());
    int srcPosition = src.position();
    int destPosition = dest.position();
    int ixSrc = srcPosition + src.arrayOffset();
    int ixDest = destPosition + dest.arrayOffset();
    System.arraycopy(src.array(), ixSrc, dest.array(), ixDest, n);
    src.position(srcPosition + n);
    dest.position(destPosition + n);
    return n;
}

Output:
     int n = Math.min(src.remaining(), dest.remaining());
-    int srcPosition = src.position();
-    int destPosition = dest.position();
-    int ixSrc = srcPosition + src.arrayOffset();
-    int ixDest = destPosition + dest.arrayOffset();
-    System.arraycopy(src.array(), ixSrc, dest.array(), ixDest, n);
-    src.position(srcPosition + n);
-    dest.position(destPosition + n);
+    if (n > 0) {
+        int srcPosition = src.position();
+        int destPosition = dest.position();
+        int ixSrc = srcPosition + src.arrayOffset();
+        int ixDest = destPosition + dest.arrayOffset();
+        System.arraycopy(src.array(), ixSrc, dest.array(), ixDest, n);
+        src.position(srcPosition + n);
+        dest.position(destPosition + n);
+    }
     return n;


Input:
private List<View> generatePage(final LibraryResultsPage page, JSONObject results) throws JSONException {
    LayoutInflater layoutInflater = (LayoutInflater) page.getApplication().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    LinearLayout libraryResultsTemplate = (LinearLayout) layoutInflater.inflate(R.layout.library_results_template, page.getContentLayout(), false);
    page.getContentLayout().addView(libraryResultsTemplate);
    List<View> outputs = new ArrayList<View>();
    final JSONObject jsonPage = results.getJSONObject("String_Node_Str");
    final LinearLayout resultsLayout = (LinearLayout) page.findViewById(R.id.resultsLayout);
    final TextView resultsNo = (TextView) page.findViewById(R.id.libraryResultsNo);
    populateResults(page, getNextResultsPage(page), resultsLayout, resultsNo);
    Button nextButton = (Button) page.findViewById(R.id.moreButton);
    nextButton.setEnabled(false);
    if (jsonPage.getBoolean("String_Node_Str")) {
        nextButton.setEnabled(true);
        nextButton.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                new LibraryNextPageTask(page, resultsLayout, resultsNo, false).execute();
            }
        });
    }
    return outputs;
}

Output:
     nextButton.setEnabled(false);
-    if (jsonPage.getBoolean("String_Node_Str")) {
+    System.out.println();
+    if (jsonPage.getBoolean("String_Node_Str") & jsonPage.getInt("String_Node_Str") > 1) {
         nextButton.setEnabled(true);