Input:
private void processObjectFetched(StageRequest method) {
    try {
        final String fileId = (String) method.getArgs()[0];
        final ObjectVersionMapping record = (ObjectVersionMapping) method.getArgs()[1];
        final InternalObjectData data = (InternalObjectData) method.getArgs()[2];
        final ErrorResponse error = (ErrorResponse) method.getArgs()[3];
        ReplicatedFileState state = files.get(fileId);
        if (state != null) {
            if (error != null) {
                numObjsInFlight--;
                fetchObjects();
                failed(state, error, "String_Node_Str");
            } else {
                final int bytes = data.getData().remaining();
                master.getStorageStage().writeObjectWithoutGMax(fileId, record.getObjectNumber(), state.getsPolicy(), 0, data.getData(), CowPolicy.PolicyNoCow, null, false, record.getObjectVersion(), null, new WriteObjectCallback() {
                    public void writeComplete(OSDWriteResponse result, ErrorResponse error) {
                        if (error != null) {
                            Logging.logMessage(Logging.LEVEL_ERROR, Category.replication, this, "String_Node_Str", ErrorUtils.formatError(error));
                        }
                    }
                });
                master.getPreprocStage().pingFile(fileId);
                master.objectReplicated();
                master.replicatedDataReceived(bytes);
                numObjsInFlight--;
                final int numPendingFile = state.getNumObjectsPending() - 1;
                state.setNumObjectsPending(numPendingFile);
                state.getPolicy().objectFetched(record.getObjectVersion());
                if (Logging.isDebug())
                    Logging.logMessage(Logging.LEVEL_DEBUG, Category.replication, this, "String_Node_Str", localID, fileId, numPendingFile);
                fetchObjects();
                if (numPendingFile == 0) {
                    Logging.logMessage(Logging.LEVEL_DEBUG, Category.replication, this, "String_Node_Str", localID, fileId);
                    doOpen(state);
                }
            }
        }
    } catch (Exception ex) {
        Logging.logError(Logging.LEVEL_ERROR, this, ex);
    }
}

Output:
         if (state != null) {
-            if (error != null) {
+            if (error != null || data.getData() == null) {
                 numObjsInFlight--;


Input:
public Flow makeFromEntry(MetaDataEntry entry) {
    Flow fl = new Flow(entry.getId(), entry.getApplication());
    fl.setName(entry.getTextField(FieldTypes.Flow.NAME));
    fl.setStreams(StringToList(entry.getTextField(FieldTypes.Flow.STREAMS)));
    fl.setDatasets(StringToList(entry.getTextField(FieldTypes.Flow.DATASETS)));
    return fl;
}

Output:
     fl.setName(entry.getTextField(FieldTypes.Flow.NAME));
-    fl.setStreams(StringToList(entry.getTextField(FieldTypes.Flow.STREAMS)));
-    fl.setDatasets(StringToList(entry.getTextField(FieldTypes.Flow.DATASETS)));
+    fl.setStreams(stringToList(entry.getTextField(FieldTypes.Flow.STREAMS)));
+    fl.setDatasets(stringToList(entry.getTextField(FieldTypes.Flow.DATASETS)));
     return fl;


Input:
public CarriagePackage PreparePackage(Directions MotionDirection) throws CarriageMotionException {
    CarriagePackage Package = super.PreparePackage(null);
    CarriageTranslocatorEntity Target = null;
    java.util.LinkedList<BlockPosition> ActiveTranslocators;
    try {
        ActiveTranslocators = ActiveTranslocatorSets.get(Player).get(Label);
    } catch (Throwable Throwable) {
        Throwable.printStackTrace();
        throw (new CarriageMotionException("String_Node_Str"));
    }
    for (int Index = 0; Index < ActiveTranslocators.size(); Index++) {
        BlockPosition Position = ActiveTranslocators.get(Index);
        try {
            CarriageTranslocatorEntity Translocator = (CarriageTranslocatorEntity) WorldUtil.GetWorld(Position.Dimension).getBlockTileEntity(Position.X, Position.Y, Position.Z);
            if (Translocator == this) {
                continue;
            }
            boolean TargetValid = true;
            for (BlockRecord Record : Package.NewPositions) {
                if (!Translocator.worldObj.isAirBlock(Record.X + Translocator.xCoord, Record.Y + Translocator.yCoord, Record.Z + Translocator.zCoord)) {
                    TargetValid = false;
                    break;
                }
            }
            if (TargetValid) {
                Target = Translocator;
                break;
            }
        } catch (Throwable Throwable) {
            Throwable.printStackTrace();
        }
    }
    if (Target == null) {
        throw (new CarriageMotionException("String_Node_Str"));
    }
    Package.Translocator = Target;
    return (Package);
}

Output:
         try {
-            CarriageTranslocatorEntity Translocator = (CarriageTranslocatorEntity) WorldUtil.GetWorld(Position.Dimension).getBlockTileEntity(Position.X, Position.Y, Position.Z);
+            CarriageTranslocatorEntity Translocator = (CarriageTranslocatorEntity) WorldUtil.GetWorld(Position.Dimension).getTileEntity(Position.X, Position.Y, Position.Z);
             if (Translocator == this) {


Input:
public String getSuffix(String worldName) {
    String suffixNode = "String_Node_Str";
    if (worldName != null && !worldName.isEmpty()) {
        suffixNode = "String_Node_Str" + worldName + "String_Node_Str" + suffixNode;
    }
    return this.node.getString(suffixNode);
}

Output:
 public String getSuffix(String worldName) {
-    String suffixNode = "String_Node_Str";
-    if (worldName != null && !worldName.isEmpty()) {
-        suffixNode = "String_Node_Str" + worldName + "String_Node_Str" + suffixNode;
-    }
-    return this.node.getString(suffixNode);
+    return this.node.getString(formatPath(worldName, "String_Node_Str"));
 }


Input:
private void setMaxAlarmIconToAlarmOpendedByUser() {
    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmOpenedByUserIcon);
}

Output:
 private void setMaxAlarmIconToAlarmOpendedByUser() {
-    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmOpenedByUserIcon);
+    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmOpenedByUserIcon, BUNDLE.getString("String_Node_Str"));
 }


Input:
public String getValue() {
    return locate(new FirstMatch<>(DISPLAYED.and(CHECKED.and(TRUE))).andThen(GET).andThen(element(PARENT)).andThen(TEXT));
}

Output:
 public String getValue() {
-    return locate(new FirstMatch<>(DISPLAYED.and(CHECKED.and(TRUE))).andThen(GET).andThen(element(PARENT)).andThen(TEXT));
+    return locate(new FirstMatch<>(DISPLAYED.and(CHECKED.and(TRUE))).andThen(GET).andThen(VALUE));
 }


Input:
private void fireProgressStateChanged(Date startDate, Date endDate, String[] keywords, int progress) {
    ProgressEvent event = new ProgressEvent(this, startDate, endDate, keywords, progress);
    synchronized (progressListeners) {
        Iterator iter = progressListeners.iterator();
        while (iter.hasNext()) {
            HistorySearchProgressListener item = (HistorySearchProgressListener) iter.next();
            item.progressChanged(event);
        }
    }
}

Output:
     synchronized (progressListeners) {
-        Iterator iter = progressListeners.iterator();
+        Iterator<HistorySearchProgressListener> iter = progressListeners.iterator();
         while (iter.hasNext()) {


Input:
public static SetExt make(final Collection<Term> l) {
    return make(l.toArray(new Term[l.size()]));
}

Output:
 public static SetExt make(final Collection<Term> l) {
-    return make(l.toArray(new Term[l.size()]));
+    return make(l.toArray(new Term[0]));
 }


Input:
public void transferAll(List<String> list) {
    for (String opt : keySet()) {
        _transfer(opt, list);
    }
}

Output:
 public void transferAll(List<String> list) {
-    for (String opt : keySet()) {
-        _transfer(opt, list);
+    for (Object opt : keySet().toArray()) {
+        _transfer((String) opt, list);
     }


Input:
private void initTempExpressionList(IndicatorDefinition definition) {
    if (tempExpressionList == null) {
        tempExpressionList = new ArrayList<Expression>();
    } else {
        tempExpressionList.clear();
    }
    if (definition != null) {
        EList<Expression> expressions = definition.getSqlGenericExpression();
        for (Expression exp : expressions) {
            Expression newExp = BooleanExpressionHelper.createExpression(exp.getLanguage(), exp.getBody());
            newExp.setVersion(exp.getVersion());
            tempExpressionList.add(newExp);
        }
    }
}

Output:
         for (Expression exp : expressions) {
-            Expression newExp = BooleanExpressionHelper.createExpression(exp.getLanguage(), exp.getBody());
-            newExp.setVersion(exp.getVersion());
-            tempExpressionList.add(newExp);
+            tempExpressionList.add(cloneExpression(exp));
         }


Input:
private void fillDefaultsWhenHiveVersionChanged() {
    if (isCreation) {
        String distribution = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HIVE_DISTRIBUTION);
        String version = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HIVE_VERSION);
        if (distribution == null) {
            return;
        }
        IHadoopDistributionService hadoopDistributionService = getHadoopDistributionService();
        if (hadoopDistributionService == null) {
            return;
        }
        IHDistribution hiveDistribution = hadoopDistributionService.getHiveDistributionManager().getDistribution(distribution, false);
        if (hiveDistribution == null) {
            return;
        }
        IHDistributionVersion hiveVersion = hiveDistribution.getHDVersion(version, false);
        if (hiveVersion == null) {
            return;
        }
        boolean useYarn = Boolean.valueOf(getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_USE_YARN));
        String defaultNN = hiveVersion.getDefaultConfig(distribution, EHadoopProperties.NAMENODE_URI.getName());
        String nameNodeURLstr = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_NAME_NODE_URL);
        String jobTrackerURLStr = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_JOB_TRACKER_URL);
        String hiveKerberosPrin = getConnection().getParameters().get(ConnParameterKeys.HIVE_AUTHENTICATION_HIVEPRINCIPLA);
        if (StringUtils.isNotEmpty(nameNodeURLstr)) {
            nameNodeURLTxt.setText(nameNodeURLstr);
        } else if (defaultNN != null) {
            nameNodeURLTxt.setText(defaultNN);
        }
        String defaultJTORRM = null;
        if (useYarn) {
            defaultJTORRM = hiveVersion.getDefaultConfig(distribution, EHadoopProperties.RESOURCE_MANAGER.getName());
        } else {
            defaultJTORRM = hiveVersion.getDefaultConfig(distribution, EHadoopProperties.JOBTRACKER.getName());
        }
        if (StringUtils.isNotEmpty(jobTrackerURLStr)) {
            jobTrackerURLTxt.setText(jobTrackerURLStr);
        } else if (defaultJTORRM != null) {
            jobTrackerURLTxt.setText(defaultJTORRM);
        }
        String defaultPrincipal = hiveVersion.getDefaultConfig(distribution, EHadoopCategory.HIVE.getName(), EHadoopProperties.HIVE_PRINCIPAL.getName());
        if (StringUtils.isNotEmpty(hiveKerberosPrin)) {
            hivePrincipalTxt.setText(hiveKerberosPrin);
        } else if (defaultPrincipal != null) {
            hivePrincipalTxt.setText(defaultPrincipal);
        }
        String defaultDatabase = hiveVersion.getDefaultConfig(distribution, EHadoopCategory.HIVE.getName(), EHadoopProperties.DATABASE.getName());
        if (StringUtils.isNotEmpty(getConnection().getSID())) {
            sidOrDatabaseText.setText(getConnection().getSID());
        } else if (defaultDatabase != null) {
            sidOrDatabaseText.setText(defaultDatabase);
            getConnection().setSID(defaultDatabase);
        }
    }
}

Output:
 private void fillDefaultsWhenHiveVersionChanged() {
-    if (isCreation) {
+    if (isCreation && isNeedFillDefaults()) {
         String distribution = getConnection().getParameters().get(ConnParameterKeys.CONN_PARA_KEY_HIVE_DISTRIBUTION);


Input:
private boolean synCategories() {
    boolean result = true;
    List<Category> categoryList = serviceHelper.getCategories();
    for (Category category : categoryList) {
        dbHelper.addCategory(category);
    }
    return result;
}

Output:
     List<Category> categoryList = serviceHelper.getCategories();
-    for (Category category : categoryList) {
-        dbHelper.addCategory(category);
+    if (categoryList == null) {
+        result = false;
+    } else {
+        for (Category category : categoryList) {
+            dbHelper.addCategory(category);
+        }
     }


Input:
protected boolean requiresUrl() {
    return !(getWizard() instanceof CloudFoundryApplicationWizard) || ((CloudFoundryApplicationWizard) getWizard()).requiresUrl();
}

Output:
 protected boolean requiresUrl() {
-    return !(getWizard() instanceof CloudFoundryApplicationWizard) || ((CloudFoundryApplicationWizard) getWizard()).requiresUrl();
+    return wizardDelegate == null || wizardDelegate.getApplicationDelegate() == null || wizardDelegate.getApplicationDelegate().requiresURL();
 }


Input:
public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
    if (msg instanceof HttpRequest) {
        HttpRequest request = this.request = (HttpRequest) msg;
        responseContent.setLength(0);
        if (request.getMethod().equals(HttpMethod.POST)) {
            URI uri = new URI(request.getUri());
            String signature = null;
            String expires = null;
            String metadata = null;
            String hostname = null;
            long contentLength = 0;
            for (Entry<String, String> entry : request.headers()) {
                switch(entry.getKey()) {
                    case HEADER_SIGNATURE:
                        signature = entry.getValue();
                        break;
                    case HEADER_METADATA:
                        metadata = entry.getValue();
                        break;
                    case HEADER_EXPIRES:
                        expires = entry.getValue();
                        break;
                    case HEADER_HOST:
                        hostname = entry.getValue();
                        break;
                    case HttpHeaders.Names.CONTENT_LENGTH:
                        contentLength = Long.valueOf(entry.getValue());
                        break;
                }
            }
            logger.info("String_Node_Str" + signature);
            logger.info("String_Node_Str" + metadata);
            logger.info("String_Node_Str" + expires);
            logger.info("String_Node_Str" + hostname);
            logger.info("String_Node_Str" + contentLength);
            QueryStringDecoder decoderQuery = new QueryStringDecoder(uri);
            Map<String, List<String>> uriAttributes = decoderQuery.parameters();
            uuid = uriAttributes.get("String_Node_Str").get(0);
            logger.info("String_Node_Str" + uuid);
            UploadEntity uploadEntity = null;
            try {
                storageResource.validatePostUploadRequest(signature, metadata, expires, hostname, contentLength, uuid);
                uploadEntity = storageResource.createUploadEntity(uuid, metadata, contentLength);
            } catch (InvalidParameterValueException ex) {
                logger.error("String_Node_Str", ex);
                responseContent.append(ex.getMessage());
                writeResponse(ctx.channel(), HttpResponseStatus.BAD_REQUEST);
                requestProcessed = true;
                return;
            }
            if (uploadEntity == null) {
                logger.error("String_Node_Str");
                responseContent.append("String_Node_Str");
                writeResponse(ctx.channel(), HttpResponseStatus.INTERNAL_SERVER_ERROR);
                requestProcessed = true;
                return;
            }
            DiskFileUpload.baseDirectory = uploadEntity.getInstallPathPrefix();
            logger.info("String_Node_Str" + DiskFileUpload.baseDirectory);
            try {
                decoder = new HttpPostRequestDecoder(factory, request);
            } catch (ErrorDataDecoderException | IncompatibleDataDecoderException e) {
                logger.error("String_Node_Str", e);
                responseContent.append(e.getMessage());
                writeResponse(ctx.channel(), HttpResponseStatus.INTERNAL_SERVER_ERROR);
                requestProcessed = true;
                return;
            }
        } else {
            logger.warn("String_Node_Str");
            responseContent.append("String_Node_Str");
            writeResponse(ctx.channel(), HttpResponseStatus.BAD_REQUEST);
            requestProcessed = true;
            return;
        }
    }
    if (decoder != null) {
        if (msg instanceof HttpContent) {
            HttpContent chunk = (HttpContent) msg;
            try {
                decoder.offer(chunk);
            } catch (ErrorDataDecoderException e) {
                logger.error("String_Node_Str", e);
                responseContent.append(e.getMessage());
                writeResponse(ctx.channel(), HttpResponseStatus.INTERNAL_SERVER_ERROR);
                requestProcessed = true;
                return;
            }
            if (chunk instanceof LastHttpContent) {
                writeResponse(ctx.channel(), readFileUploadData());
                reset();
            }
        }
    }
}

Output:
                     case HttpHeaders.Names.CONTENT_LENGTH:
-                        contentLength = Long.valueOf(entry.getValue());
+                        contentLength = Long.parseLong(entry.getValue());
                         break;


Input:
public static String readXQueryFromResource(Resource resource) {
    Assert.notNull(resource, "String_Node_Str");
    Assert.isTrue(resource.exists(), "String_Node_Str");
    Assert.isTrue(resource.isReadable(), "String_Node_Str");
    try {
        URL url = resource.getURL();
        InputStream inStream = url.openStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
        String line = reader.readLine();
        StringBuilder builder = new StringBuilder();
        while (line != null) {
            builder.append(line).append("String_Node_Str");
            line = reader.readLine();
        }
        String xQuery = builder.toString();
        reader.close();
        return xQuery;
    } catch (IOException e) {
        throw new MessagingException("String_Node_Str", e);
    }
}

Output:
         InputStream inStream = url.openStream();
-        BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
+        reader = new BufferedReader(new InputStreamReader(inStream));
         String line = reader.readLine();


Input:
private void appendRenderedFile(FolderComponent fc, VFSItem child, String currentContainerPath, StringOutput sb, URLBuilder ubu, Translator translator, boolean iframePostEnabled, boolean canContainerVersion, int pos) {
    boolean canWrite = child.getParentContainer().canWrite() == VFSConstants.YES;
    boolean canDelete = child.getParentContainer().canDelete() == VFSConstants.YES;
    boolean canMail = fc.isCanMail();
    boolean isAbstract = (child instanceof AbstractVirtualContainer);
    Versions versions = null;
    if (canContainerVersion && child instanceof Versionable) {
        Versionable versionable = (Versionable) child;
        if (versionable.getVersions().isVersioned()) {
            versions = versionable.getVersions();
        }
    }
    boolean canVersion = versions != null && !versions.getRevisions().isEmpty();
    boolean canAddToEPortfolio = FolderConfig.isEPortfolioAddEnabled();
    VFSLeaf leaf = null;
    if (child instanceof VFSLeaf) {
        leaf = (VFSLeaf) child;
    }
    boolean isContainer = (leaf == null);
    MetaInfo metaInfo = null;
    if (child instanceof MetaTagged) {
        metaInfo = ((MetaTagged) child).getMetaInfo();
    }
    boolean lockedForUser = lockManager.isLockedForMe(child, fc.getIdentityEnvironnement().getIdentity(), fc.getIdentityEnvironnement().getRoles());
    String name = child.getName();
    String pathAndName = currentContainerPath;
    if (pathAndName.length() > 0 && !pathAndName.endsWith("String_Node_Str"))
        pathAndName = pathAndName + "String_Node_Str";
    pathAndName = pathAndName + name;
    sb.append("String_Node_Str");
    if (canWrite || canDelete || canMail) {
        sb.append("String_Node_Str");
        sb.append(FileSelection.FORM_ID);
        sb.append("String_Node_Str");
        sb.append(StringHelper.escapeHtml(name));
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str").append(pos).append("String_Node_Str");
    if (isContainer) {
        ubu.buildURI(sb, null, null, pathAndName, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
        sb.append("String_Node_Str");
        if (iframePostEnabled) {
            StringOutput so = new StringOutput();
            ubu.appendTarget(so);
            sb.append(so.toString());
        }
    } else {
        ubu.buildURI(sb, new String[] { PARAM_SERV }, new String[] { "String_Node_Str" }, pathAndName, AJAXFlags.MODE_NORMAL);
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    if (isContainer)
        sb.append(CSSHelper.CSS_CLASS_FILETYPE_FOLDER);
    else
        sb.append(CSSHelper.createFiletypeIconCssClassFor(name));
    sb.append("String_Node_Str");
    if (isAbstract)
        sb.append("String_Node_Str");
    sb.append(name);
    if (isAbstract)
        sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    if (metaInfo != null) {
        boolean hasMeta = false;
        sb.append("String_Node_Str").append(pos).append("String_Node_Str");
        if (StringHelper.containsNonWhitespace(metaInfo.getTitle())) {
            String title = StringHelper.escapeHtml(metaInfo.getTitle());
            sb.append("String_Node_Str").append(Formatter.escapeDoubleQuotes(title)).append("String_Node_Str");
            hasMeta = true;
        }
        if (StringHelper.containsNonWhitespace(metaInfo.getComment())) {
            sb.append("String_Node_Str");
            String comment = StringHelper.escapeHtml(metaInfo.getComment());
            sb.append(Formatter.escapeDoubleQuotes(comment));
            sb.append("String_Node_Str");
            hasMeta = true;
        }
        if (metaInfo.isThumbnailAvailable()) {
            sb.append("String_Node_Str");
            ubu.buildURI(sb, new String[] { PARAM_SERV_THUMBNAIL }, new String[] { "String_Node_Str" }, pathAndName, AJAXFlags.MODE_NORMAL);
            sb.append("String_Node_Str");
            hasMeta = true;
        }
        String author = metaInfo.getCreator();
        if (StringHelper.containsNonWhitespace(author)) {
        } else {
            author = metaInfo.getAuthor();
            if (!"String_Node_Str".equals(author)) {
                author = UserManager.getInstance().getUserDisplayName(author);
            } else {
                author = null;
            }
        }
        author = StringHelper.escapeHtml(author);
        if (StringHelper.containsNonWhitespace(author)) {
            sb.append("String_Node_Str").append(Formatter.escapeDoubleQuotes(translator.translate("String_Node_Str")));
            sb.append("String_Node_Str").append(Formatter.escapeDoubleQuotes(author)).append("String_Node_Str");
            hasMeta = true;
        }
        sb.append("String_Node_Str");
        if (hasMeta) {
            sb.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(pos).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(pos).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(pos).append("String_Node_Str").append("String_Node_Str").append(pos).append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append("String_Node_Str");
        }
    }
    sb.append("String_Node_Str");
    if (!isContainer) {
        sb.append("String_Node_Str");
        sb.append(Formatter.formatBytes(leaf.getSize()));
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    long lastModified = child.getLastModified();
    sb.append("String_Node_Str");
    if (lastModified != VFSConstants.UNDEFINED)
        sb.append(DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, translator.getLocale()).format(new Date(lastModified)));
    else
        sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    if (canContainerVersion) {
        if (canVersion)
            if (versions != null) {
                sb.append("String_Node_Str");
                sb.append(versions.getRevisionNr());
                sb.append("String_Node_Str");
            }
        sb.append("String_Node_Str");
    }
    boolean locked = lockManager.isLocked(child);
    if (locked) {
        LockInfo lock = lockManager.getLock(child);
        sb.append("String_Node_Str");
        if (lock != null && lock.getLockedBy() != null) {
            String fullname = userManager.getUserDisplayName(lock.getLockedBy());
            String date = "String_Node_Str";
            if (lock.getCreationDate() != null) {
                date = fc.getDateTimeFormat().format(lock.getCreationDate());
            }
            String msg = translator.translate("String_Node_Str", new String[] { fullname, date });
            if (lock.isWebDAVLock()) {
                msg += "String_Node_Str";
            }
            sb.append(msg);
        }
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    if (canWrite) {
        int actionCount = 0;
        if (canVersion)
            actionCount++;
        String nameLowerCase = name.toLowerCase();
        boolean isLeaf = (child instanceof VFSLeaf);
        boolean isEditable = (isLeaf && !lockedForUser && (nameLowerCase.endsWith("String_Node_Str") || nameLowerCase.endsWith("String_Node_Str") || nameLowerCase.endsWith("String_Node_Str") || nameLowerCase.endsWith("String_Node_Str") || nameLowerCase.endsWith("String_Node_Str")));
        if (isEditable)
            actionCount++;
        boolean canEP = canAddToEPortfolio && !isContainer;
        if (canEP)
            actionCount++;
        boolean canMetaData = canMetaInfo(child);
        if (canMetaData)
            actionCount++;
        if (actionCount == 1 && canMetaData) {
            sb.append("String_Node_Str");
            ubu.buildURI(sb, new String[] { PARAM_EDTID }, new String[] { Integer.toString(pos) }, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
            sb.append("String_Node_Str");
            if (iframePostEnabled) {
                StringOutput so = new StringOutput();
                ubu.appendTarget(so);
                sb.append(so.toString());
            }
            sb.append("String_Node_Str").append(StringHelper.escapeHtml(translator.translate("String_Node_Str"))).append("String_Node_Str");
        } else if (actionCount > 1) {
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            if (canMetaData) {
                sb.append("String_Node_Str");
                ubu.buildURI(sb, new String[] { PARAM_EDTID }, new String[] { Integer.toString(pos) }, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
                sb.append("String_Node_Str");
                if (iframePostEnabled) {
                    StringOutput so = new StringOutput();
                    ubu.appendTarget(so);
                    sb.append(so.toString());
                }
                sb.append("String_Node_Str").append(StringHelper.escapeHtml(translator.translate("String_Node_Str"))).append("String_Node_Str");
            }
            if (isEditable) {
                sb.append("String_Node_Str");
                ubu.buildURI(sb, new String[] { PARAM_CONTENTEDITID }, new String[] { Integer.toString(pos) }, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
                sb.append("String_Node_Str");
                if (iframePostEnabled) {
                    StringOutput so = new StringOutput();
                    ubu.appendTarget(so);
                    sb.append(so.toString());
                }
                sb.append("String_Node_Str").append(StringHelper.escapeHtml(translator.translate("String_Node_Str"))).append("String_Node_Str");
            }
            if (canVersion) {
                sb.append("String_Node_Str");
                ubu.buildURI(sb, new String[] { PARAM_VERID }, new String[] { Integer.toString(pos) }, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
                sb.append("String_Node_Str");
                if (iframePostEnabled) {
                    StringOutput so = new StringOutput();
                    ubu.appendTarget(so);
                    sb.append(so.toString());
                }
                sb.append("String_Node_Str").append(StringHelper.escapeHtml(translator.translate("String_Node_Str"))).append("String_Node_Str");
            }
            if (canEP) {
                if (metaInfo != null) {
                    Identity author = metaInfo.getAuthorIdentity();
                    if (author != null && fc.getIdentityEnvironnement().getIdentity().getKey().equals(author.getKey())) {
                        sb.append("String_Node_Str");
                        ubu.buildURI(sb, new String[] { PARAM_EPORT }, new String[] { Integer.toString(pos) }, iframePostEnabled ? AJAXFlags.MODE_TOBGIFRAME : AJAXFlags.MODE_NORMAL);
                        sb.append("String_Node_Str");
                        if (iframePostEnabled) {
                            StringOutput so = new StringOutput();
                            ubu.appendTarget(so);
                            sb.append(so.toString());
                        }
                        sb.append("String_Node_Str").append(StringHelper.escapeHtml(translator.translate("String_Node_Str"))).append("String_Node_Str");
                    }
                }
            }
            sb.append("String_Node_Str");
        }
    }
    sb.append("String_Node_Str");
}

Output:
         } else if (actionCount > 1) {
-            sb.append("String_Node_Str");
-            sb.append("String_Node_Str");
+            sb.append("String_Node_Str").append(pos).append("String_Node_Str").append("String_Node_Str").append(pos).append("String_Node_Str");
             if (canMetaData) {


Input:
public static ProjectTableRecipe readFromBuffer(PacketBuffer buf) {
    try {
        byte inputItemStackCount = buf.readByte();
        List<IIngredient> input = Lists.newArrayList();
        for (int i = 0; i < inputItemStackCount; ++i) {
            input.add(readIngredient(buf));
        }
        byte outputItemStackCount = buf.readByte();
        List<ItemStack> output = Lists.newArrayList();
        for (int i = 0; i < outputItemStackCount; ++i) {
            output.add(buf.readItemStackFromBuffer());
        }
        final String displayName = ByteBufUtils.readUTF8String(buf);
        return new ProjectTableRecipe(output, displayName, input);
    } catch (IOException e) {
        throw new SteamNSteelException("String_Node_Str", e);
    }
}

Output:
         for (int i = 0; i < outputItemStackCount; ++i) {
-            output.add(buf.readItemStackFromBuffer());
+            output.add(PacketBufferExtensions.readLargeItemStackFromBuffer(buf));
         }


Input:
private static void fillSynonmsForDB2(IMetadataConnection iMetadataConnection, List<TdColumn> metadataColumns, NamedColumnSet table, String tableName) throws SQLException {
    String synSQL = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + tableName + "String_Node_Str";
    if (!("String_Node_Str").equals(iMetadataConnection.getSchema())) {
        synSQL += "String_Node_Str" + iMetadataConnection.getSchema() + "String_Node_Str";
    }
    synSQL += "String_Node_Str";
    Statement sta = ExtractMetaDataUtils.conn.createStatement();
    ExtractMetaDataUtils.setQueryStatementTimeout(sta);
    ResultSet columns = sta.executeQuery(synSQL);
    String typeName = null;
    int index = 0;
    while (columns.next()) {
        long numPrecRadix = 0;
        String columnName = columns.getString("String_Node_Str");
        TdColumn column = ColumnHelper.createTdColumn(columnName);
        String label = column.getLabel();
        label = ManagementTextUtils.filterSpecialChar(label);
        String sub = "String_Node_Str";
        String sub2 = "String_Node_Str";
        String label2 = label;
        if (label != null && label.length() > 0 && label.startsWith("String_Node_Str")) {
            sub = label.substring(1);
            if (sub != null && sub.length() > 0) {
                sub2 = sub.substring(1);
            }
        }
        ICoreService coreService = CoreRuntimePlugin.getInstance().getCoreService();
        if (coreService.isKeyword(label) || coreService.isKeyword(sub) || coreService.isKeyword(sub2)) {
            label = "String_Node_Str" + label;
        }
        label = MetadataToolHelper.validateColumnName(label, index);
        column.setLabel(label);
        column.setOriginalField(label2);
        if (!ExtractMetaDataUtils.needFakeDatabaseMetaData(iMetadataConnection.getDbType(), iMetadataConnection.isSqlMode())) {
            typeName = columns.getString("String_Node_Str");
        }
        try {
            int column_size = columns.getInt("String_Node_Str");
            column.setLength(column_size);
            numPrecRadix = columns.getLong("String_Node_Str");
            column.setPrecision(numPrecRadix);
        } catch (Exception e1) {
            log.warn(e1, e1);
        }
        DatabaseConnection dbConnection = (DatabaseConnection) ConnectionHelper.getConnection(table);
        String dbmsId = dbConnection == null ? null : dbConnection.getDbmsId();
        if (dbmsId != null) {
            MappingTypeRetriever mappingTypeRetriever = MetadataTalendType.getMappingTypeRetriever(dbmsId);
            String talendType = mappingTypeRetriever.getDefaultSelectedTalendType(typeName, ExtractMetaDataUtils.getIntMetaDataInfo(columns, "String_Node_Str"), ExtractMetaDataUtils.getIntMetaDataInfo(columns, "String_Node_Str"));
            column.setTalendType(talendType);
            String defaultSelectedDbType = MetadataTalendType.getMappingTypeRetriever(dbConnection.getDbmsId()).getDefaultSelectedDbType(talendType);
            column.setSourceType(defaultSelectedDbType);
        }
        try {
            column.setNullable("String_Node_Str".equals(columns.getString("String_Node_Str")));
        } catch (Exception e) {
            log.error(e);
        }
        metadataColumns.add(column);
        index++;
    }
    columns.close();
}

Output:
         }
-        label = MetadataToolHelper.validateColumnName(label, index);
+        label = MetadataToolHelper.validateColumnName(label, columnIndex, columnLabels);
         column.setLabel(label);


Input:
private List<String> installFromPackageCloud() {
    OsDetails osDetails = getMachine().getMachineDetails().getOsDetails();
    return ImmutableList.<String>builder().add(osDetails.getName().toLowerCase().contains("String_Node_Str") ? addSbinPathCommand() : "String_Node_Str").add(ifNotExecutable("String_Node_Str", Joiner.on('\n').join(installCurl()))).addAll(ifExecutableElse("String_Node_Str", installDebianBased(), installRpmBased())).build();
}

Output:
     OsDetails osDetails = getMachine().getMachineDetails().getOsDetails();
-    return ImmutableList.<String>builder().add(osDetails.getName().toLowerCase().contains("String_Node_Str") ? addSbinPathCommand() : "String_Node_Str").add(ifNotExecutable("String_Node_Str", Joiner.on('\n').join(installCurl()))).addAll(ifExecutableElse("String_Node_Str", installDebianBased(), installRpmBased())).build();
+    return ImmutableList.<String>builder().add(osDetails.getName().toLowerCase().contains("String_Node_Str") ? addSbinPathCommand() : "String_Node_Str").add(ifNotExecutable("String_Node_Str", INSTALL_CURL)).addAll(ifExecutableElse("String_Node_Str", installDebianBased(), installRpmBased())).build();
 }


Input:
protected void materializeHierarchies(DataHandle handle) {
    Set<String> attributes = new HashSet<>(this.getQuasiIdentifiersWithGeneralization());
    attributes.addAll(this.getQuasiIdentifiersWithClusteringAndMicroaggregation());
    for (String attribute : attributes) {
        String[] data = handle.getDistinctValues(handle.getColumnIndexOf(attribute));
        if (isHierarchyBuilderAvailable(attribute)) {
            try {
                this.hierarchies.put(attribute, this.getHierarchyBuilder(attribute).build(data));
            } catch (Exception e) {
                throw new IllegalStateException("String_Node_Str" + attribute + "String_Node_Str", e);
            }
        } else {
            String[][] hierarchy = new String[data.length][];
            for (int i = 0; i < data.length; i++) {
                hierarchy[i] = new String[] { data[i] };
            }
            this.hierarchies.put(attribute, Hierarchy.create(hierarchy));
        }
    }
}

Output:
             }
-        } else {
+        } else if (!isHierarchyAvailable(attribute)) {
             String[][] hierarchy = new String[data.length][];


Input:
public List getAggregateOnList() {
    return (List) getProperty(null, AGGREGATEON_MEMBER);
}

Output:
 public List getAggregateOnList() {
-    return (List) getProperty(null, AGGREGATEON_MEMBER);
+    List value = (List) getProperty(null, AGGREGATEON_MEMBER);
+    if (value == null)
+        return Collections.EMPTY_LIST;
+    return (List) value;
 }


Input:
private static RemoteFileDesc newRFD(String name, String hash) {
    Set urns = null;
    if (hash != null) {
        urns = new HashSet(1);
        try {
            urns.add(URN.createSHA1Urn(hash));
        } catch (IOException e) {
            fail("String_Node_Str");
        }
    }
    return new RemoteFileDesc("String_Node_Str", 6346, 13l, name, 1024, new byte[16], 56, false, 4, true, null, urns);
}

Output:
     }
-    return new RemoteFileDesc("String_Node_Str", 6346, 13l, name, 1024, new byte[16], 56, false, 4, true, null, urns);
+    return new RemoteFileDesc("String_Node_Str", PORT, 13l, name, 1024, new byte[16], 56, false, 4, true, null, urns);
 }


Input:
public org.hl7.fhir.dstu2.model.MedicationDispense.MedicationDispenseSubstitutionComponent convertMedicationDispenseSubstitutionComponent(org.hl7.fhir.dstu3.model.MedicationDispense.MedicationDispenseSubstitutionComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.MedicationDispense.MedicationDispenseSubstitutionComponent tgt = new org.hl7.fhir.dstu2.model.MedicationDispense.MedicationDispenseSubstitutionComponent();
    copyElement(src, tgt);
    tgt.setType(convertCodeableConcept(src.getType()));
    for (org.hl7.fhir.dstu3.model.CodeableConcept t : src.getReason()) tgt.addReason(convertCodeableConcept(t));
    for (org.hl7.fhir.dstu3.model.Reference t : src.getResponsibleParty()) tgt.addResponsibleParty(convertReference(t));
    return tgt;
}

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


Input:
private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
    java.nio.ByteBuffer buffer = java.nio.ByteBuffer.wrap(data);
    int messageType = buffer.get();
    if (messageType == MSG_CHANNEL_ACK) {
        logger.info(getEndpoint().getID() + "String_Node_Str" + sid);
        WebRtcDataStream channel = channels.get(sid);
        if (channel != null) {
            if (!channel.isAcknowledged()) {
                channel.ackReceived();
                notifyChannelOpened(channel);
            } else {
                logger.warn("String_Node_Str" + sid);
            }
        } else {
            logger.error("String_Node_Str" + sid);
        }
    } else if (messageType == MSG_OPEN_CHANNEL) {
        int channelType = buffer.get();
        int priority = buffer.getShort();
        long reliability = buffer.getInt();
        int labelLength = buffer.getShort();
        int protocolLength = buffer.getShort();
        byte[] labelRaw = new byte[labelLength];
        buffer.get(labelRaw);
        String label = new String(labelRaw);
        byte[] protocolRaw = new byte[protocolLength];
        buffer.get(protocolRaw);
        String protocol = new String(protocolRaw);
        logger.info("String_Node_Str" + getEndpoint().getID() + "String_Node_Str" + "String_Node_Str" + sid + "String_Node_Str" + channelType + "String_Node_Str" + priority + "String_Node_Str" + reliability + "String_Node_Str" + label + "String_Node_Str" + protocol);
        if (channels.containsKey(sid)) {
            logger.error("String_Node_Str" + sid + "String_Node_Str");
        }
        WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true);
        channels.put(sid, newChannel);
        sendOpenChannelAck(sid);
        notifyChannelOpened(newChannel);
    } else {
        logger.error("String_Node_Str" + messageType);
    }
}

Output:
 private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
-    java.nio.ByteBuffer buffer = java.nio.ByteBuffer.wrap(data);
-    int messageType = buffer.get();
+    ByteBuffer buffer = ByteBuffer.wrap(data);
+    int messageType = 0xFF & buffer.get();
     if (messageType == MSG_CHANNEL_ACK) {


Input:
public boolean onIsland(Location target) {
    if (world != null) {
        if (target.getWorld().equals(world) || (Settings.createNether && Settings.newNether && target.getWorld().equals(ASkyBlock.getNetherWorld()))) {
            if (target.getBlockX() >= minProtectedX && target.getBlockX() < (minProtectedX + protectionRange) && target.getBlockZ() >= minProtectedZ && target.getBlockZ() < (minProtectedZ + protectionRange)) {
                return true;
            }
        }
    }
    return false;
}

Output:
     if (world != null) {
-        if (target.getWorld().equals(world) || (Settings.createNether && Settings.newNether && target.getWorld().equals(ASkyBlock.getNetherWorld()))) {
+        if (target.getWorld().equals(world) || (Settings.createNether && Settings.newNether && ASkyBlock.getNetherWorld() != null && target.getWorld().equals(ASkyBlock.getNetherWorld()))) {
             if (target.getBlockX() >= minProtectedX && target.getBlockX() < (minProtectedX + protectionRange) && target.getBlockZ() >= minProtectedZ && target.getBlockZ() < (minProtectedZ + protectionRange)) {


Input:
public List<NewProperty> getPropertiesOfCluster(String applicationName, String clusterId) throws RegistryException {
    Registry tempRegistry = ServiceReferenceHolder.getRegistryService().getRegistry();
    String resourcePath = mainResource + applicationName + "String_Node_Str" + clusterId;
    if (!tempRegistry.resourceExists(resourcePath)) {
        return null;
    }
    Resource regResource = tempRegistry.get(resourcePath);
    ArrayList<NewProperty> newProperties = new ArrayList<NewProperty>();
    Properties props = regResource.getProperties();
    Enumeration<?> x = props.propertyNames();
    while (x.hasMoreElements()) {
        String key = (String) x.nextElement();
        List<String> values = regResource.getPropertyValues(key);
        NewProperty property = new NewProperty();
        property.setKey(key);
        String[] valueArr = new String[values.size()];
        property.setValues(values.toArray(valueArr));
        newProperties.add(property);
    }
    return newProperties;
}

Output:
 public List<NewProperty> getPropertiesOfCluster(String applicationName, String clusterId) throws RegistryException {
-    Registry tempRegistry = ServiceReferenceHolder.getRegistryService().getRegistry();
+    Registry tempRegistry = ServiceReferenceHolder.getInstance().getRegistryService().getRegistry();
     String resourcePath = mainResource + applicationName + "String_Node_Str" + clusterId;


Input:
private void parseProperties(XMLExtendedStreamReader reader, final ModelNode address, final List<ModelNode> list) throws XMLStreamException {
    while (reader.nextTag() != END_ELEMENT) {
        reader.require(START_ELEMENT, Namespace.CURRENT.getUriString(), Element.PROPERTY.getLocalName());
        final Property property = readProperty(reader);
        ModelNode propertyOp = new ModelNode();
        propertyOp.get(OP).set(ADD);
        propertyOp.get(OP_ADDR).set(address).add(PROPERTY, property.getName());
        propertyOp.get(VALUE).set(property.getValue());
        list.add(propertyOp);
    }
}

Output:
     while (reader.nextTag() != END_ELEMENT) {
-        reader.require(START_ELEMENT, Namespace.CURRENT.getUriString(), Element.PROPERTY.getLocalName());
+        reader.require(START_ELEMENT, Namespace.REMOTING_1_0.getUriString(), Element.PROPERTY.getLocalName());
         final Property property = readProperty(reader);


Input:
public List<Execution> findExecutions(Map<String, Object> params, int limit) {
    ISqlTemplate template = databasePlatform.getSqlTemplate();
    StringBuilder whereClause = new StringBuilder();
    int i = params.size();
    for (String columnName : params.keySet()) {
        whereClause.append(StringUtils.join(StringUtils.splitByCharacterTypeCamelCase(columnName), "String_Node_Str")).append("String_Node_Str");
        if (--i > 0) {
            whereClause.append("String_Node_Str");
        }
    }
    return template.query(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + whereClause + "String_Node_Str" + limit, tablePrefix), new ISqlRowMapper<Execution>() {

        public Execution mapRow(Row row) {
            Execution e = new Execution();
            e.setId(row.getString("String_Node_Str"));
            e.setAgentId(row.getString("String_Node_Str"));
            e.setFlowId(row.getString("String_Node_Str"));
            e.setAgentName(row.getString("String_Node_Str"));
            e.setHostName(row.getString("String_Node_Str"));
            e.setFlowName(row.getString("String_Node_Str"));
            e.setDeploymentId(row.getString("String_Node_Str"));
            e.setDeploymentName(row.getString("String_Node_Str"));
            e.setStatus(row.getString("String_Node_Str"));
            e.setStartTime(row.getDateTime("String_Node_Str"));
            e.setEndTime(row.getDateTime("String_Node_Str"));
            e.setCreateBy(row.getString("String_Node_Str"));
            e.setLastUpdateBy(row.getString("String_Node_Str"));
            e.setParameters(row.getString("String_Node_Str"));
            return e;
        }
    }, params.values().toArray());
}

Output:
     }
-    return template.query(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + whereClause + "String_Node_Str" + limit, tablePrefix), new ISqlRowMapper<Execution>() {
+    return template.query(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + whereClause + "String_Node_Str", tablePrefix), limit, new ISqlRowMapper<Execution>() {


Input:
private static void toggleAll(Player player, HumanNPC npc, boolean on) {
    if (on) {
        for (CitizensNPC type : npc.types()) {
            if (!npc.isType(type.getType())) {
                toggleState(player, npc, type, false);
            }
        }
    } else {
        for (CitizensNPC type : npc.types()) {
            toggleState(player, npc, type, false);
        }
    }
}

Output:
     if (on) {
-        for (CitizensNPC type : npc.types()) {
-            if (!npc.isType(type.getType())) {
-                toggleState(player, npc, type, false);
+        for (Entry<String, CitizensNPC> entry : CitizensNPCManager.getTypes().entrySet()) {
+            if (!npc.isType(entry.getValue().getType())) {
+                toggleState(player, npc, entry.getValue());
             }


Input:
public void queryMetaContactSource(Pattern filterPattern, MetaContactGroup parentGroup, MetaContactQuery query, int resultCount) {
    Iterator<MetaContact> childContacts = parentGroup.getChildContacts();
    while (childContacts.hasNext() && !query.isCanceled()) {
        MetaContact metaContact = childContacts.next();
        if (isMatching(filterPattern, metaContact)) {
            resultCount++;
            if (resultCount <= INITIAL_CONTACT_COUNT) {
                UIGroup uiGroup = null;
                synchronized (parentGroup) {
                    uiGroup = MetaContactListSource.getUIGroup(parentGroup);
                }
                if (!MetaContactListSource.isRootGroup(parentGroup)) {
                    synchronized (parentGroup) {
                        if (uiGroup == null)
                            uiGroup = MetaContactListSource.createUIGroup(parentGroup);
                    }
                }
                UIContact newUIContact;
                synchronized (metaContact) {
                    newUIContact = MetaContactListSource.createUIContact(metaContact);
                }
                GuiActivator.getContactList().addContact(newUIContact, uiGroup, true, true);
                query.setInitialResultCount(resultCount);
            } else
                query.fireQueryEvent(metaContact);
        }
    }
    if (query.isCanceled())
        return;
    Iterator<MetaContactGroup> subgroups = parentGroup.getSubgroups();
    while (subgroups.hasNext() && !query.isCanceled()) {
        MetaContactGroup subgroup = subgroups.next();
        queryMetaContactSource(filterPattern, subgroup, query, resultCount);
    }
}

Output:
                 synchronized (metaContact) {
-                    newUIContact = MetaContactListSource.createUIContact(metaContact);
+                    newUIContact = MetaContactListSource.getUIContact(metaContact);
+                    if (newUIContact == null) {
+                        newUIContact = MetaContactListSource.createUIContact(metaContact);
+                        GuiActivator.getContactList().addContact(newUIContact, uiGroup, true, true);
+                    }
                 }


Input:
public Long getServiceOfferingId() {
    return this.serviceOfferingId;
}

Output:
 public Long getServiceOfferingId() {
-    return this.serviceOfferingId;
+    return serviceOfferingId;
 }


Input:
public void onKeyDown(KeyDownEvent event) {
    final int keyCode = event.getNativeKeyCode();
    Selection selection = getTextArea().getDocument().getSelection();
    if (selection.getRangeCount() > 0) {
        Range range = selection.getRangeAt(0);
        logRange(range);
        int pos = -1;
        Node startContainer = range.getStartContainer();
        Node endContainer = range.getEndContainer();
        List<Integer> path = TreeHelper.getLocator(range.getStartContainer());
        TreeOperation op = null;
        switch(keyCode) {
            case KeyCodes.KEY_BACKSPACE:
                {
                    pos = range.getStartOffset();
                    Node n;
                    Element rightParagraph;
                    Node leftParagraph;
                    if (Node.TEXT_NODE == startContainer.getNodeType()) {
                        n = getAncestorBelowParagraph(startContainer);
                        rightParagraph = n.getParentElement();
                        leftParagraph = rightParagraph.getPreviousSibling();
                        Text textNode = Text.as(startContainer);
                        if (pos == 0) {
                            if (leftParagraph != null) {
                                boolean merge = false;
                                if (textNode != n && textNode == n.getFirstChild()) {
                                    merge = true;
                                }
                                if (textNode == n && n == rightParagraph.getFirstChild()) {
                                    merge = true;
                                }
                                if (merge) {
                                    int brCount = rightParagraph.getElementsByTagName(BR).getLength();
                                    op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), leftParagraph.getChildCount(), rightParagraph.getChildCount() - brCount);
                                    op.setPath(TreeHelper.toIntArray(path));
                                } else {
                                    op = skipBackspaceOnEmptyTexts(textNode, path, rightParagraph, leftParagraph);
                                }
                            } else {
                                log.fine("String_Node_Str");
                                event.preventDefault();
                            }
                        } else {
                            pos = pos - 1;
                            op = new TreeDeleteText(clientJupiter.getSiteId(), pos, TreeHelper.toIntArray(path));
                        }
                    } else if (Node.ELEMENT_NODE == startContainer.getNodeType()) {
                        Element element = Element.as(startContainer);
                        boolean merge = false;
                        if ("String_Node_Str".equalsIgnoreCase(element.getNodeName())) {
                            rightParagraph = element;
                            leftParagraph = rightParagraph.getPreviousSibling();
                        } else {
                            n = getAncestorBelowParagraph(startContainer);
                            rightParagraph = n.getParentElement();
                            leftParagraph = rightParagraph.getPreviousSibling();
                            if (pos == 0 && "String_Node_Str".equalsIgnoreCase(element.getNodeName())) {
                                merge = (element == n && n == rightParagraph.getFirstChild());
                            }
                        }
                        merge = merge && (leftParagraph != null);
                        if (merge) {
                            int brCount = rightParagraph.getElementsByTagName(BR).getLength();
                            op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), leftParagraph.getChildCount(), rightParagraph.getChildCount() - brCount);
                            op.setPath(TreeHelper.toIntArray(path));
                        } else {
                            log.severe("String_Node_Str" + element.getTagName() + "String_Node_Str");
                            event.preventDefault();
                        }
                    }
                }
                break;
            case KeyCodes.KEY_DELETE:
                {
                    Element leftParagraph;
                    Element rightParagraph;
                    if (Node.TEXT_NODE == startContainer.getNodeType()) {
                        Text textNode = Text.as(startContainer);
                        leftParagraph = getAncestorBelowParagraph(startContainer).getParentElement();
                        rightParagraph = leftParagraph.getNextSiblingElement();
                        pos = range.getStartOffset();
                        if (textNode.getLength() == pos) {
                            if ((rightParagraph != null) && (!rightParagraph.getClassName().toLowerCase().contains("String_Node_Str"))) {
                                int brCount = rightParagraph.getElementsByTagName(BR).getLength();
                                path.set(0, path.get(0) + 1);
                                op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), leftParagraph.getChildCount(), rightParagraph.getChildCount() - brCount);
                                op.setPath(TreeHelper.toIntArray(path));
                            } else {
                                log.fine("String_Node_Str");
                                event.preventDefault();
                            }
                        } else {
                            op = new TreeDeleteText(clientJupiter.getSiteId(), pos, TreeHelper.toIntArray(path));
                        }
                    } else if (Node.ELEMENT_NODE == startContainer.getNodeType()) {
                        Element element = Element.as(startContainer);
                        if ("String_Node_Str".equalsIgnoreCase(element.getNodeName())) {
                            leftParagraph = element;
                        } else {
                            leftParagraph = getAncestorBelowParagraph(element).getParentElement();
                        }
                        rightParagraph = leftParagraph.getNextSiblingElement();
                        if (rightParagraph != null) {
                            int brCount = rightParagraph.getElementsByTagName(BR).getLength();
                            path.set(0, path.get(0) + 1);
                            op = new TreeMergeParagraph(clientJupiter.getSiteId(), path.get(0), leftParagraph.getChildCount(), rightParagraph.getChildCount() - brCount);
                            op.setPath(TreeHelper.toIntArray(path));
                        } else {
                            log.fine("String_Node_Str");
                            event.preventDefault();
                        }
                    }
                }
                break;
            case KeyCodes.KEY_ENTER:
                {
                    path = TreeHelper.getLocator(range.getEndContainer());
                    pos = range.getEndOffset();
                    if (Node.TEXT_NODE == endContainer.getNodeType()) {
                        Text textNode = Text.as(endContainer);
                        boolean isNewParagraph = false;
                        Node n = getAncestorBelowParagraph(textNode);
                        if (n.getPreviousSibling() == null && 0 == pos) {
                            isNewParagraph = true;
                            pos = path.get(0);
                        }
                        if ((n.getNextSibling() == null || BR.equalsIgnoreCase(n.getNextSibling().getNodeName())) && textNode.getLength() == pos) {
                            isNewParagraph = true;
                            pos = path.get(0) + 1;
                        }
                        if (isNewParagraph) {
                            op = new TreeNewParagraph(clientJupiter.getSiteId(), pos);
                            op.setPath(TreeHelper.toIntArray(path));
                        } else {
                            op = new TreeInsertParagraph(clientJupiter.getSiteId(), pos, TreeHelper.toIntArray(path));
                        }
                    } else if (Node.ELEMENT_NODE == endContainer.getNodeType()) {
                        Element element = Element.as(endContainer);
                        if (element.getPreviousSibling() == null && 0 == pos) {
                            op = new TreeNewParagraph(clientJupiter.getSiteId(), path.get(0));
                            op.setPath(TreeHelper.toIntArray(path));
                        } else {
                            int brCount = element.getElementsByTagName(BR).getLength();
                            int childCount = element.getChildCount();
                            boolean isBeforeLastBrTag = ((pos == (childCount - brCount)) && (BR.equalsIgnoreCase(element.getLastChild().getNodeName())));
                            boolean isAfterLastTag = (pos == childCount);
                            if (isBeforeLastBrTag || isAfterLastTag) {
                                pos = path.get(0) + 1;
                                op = new TreeNewParagraph(clientJupiter.getSiteId(), pos);
                                op.setPath(TreeHelper.toIntArray(path));
                            } else {
                                pos = range.getEndOffset();
                                op = new TreeInsertParagraph(clientJupiter.getSiteId(), pos, TreeHelper.toIntArray(path));
                            }
                        }
                    }
                }
                break;
            default:
                break;
        }
        if (op != null) {
            if (!(op instanceof TreeInsertText || op instanceof TreeDeleteText)) {
                event.preventDefault();
            }
            clientJupiter.generate(op);
        }
    }
}

Output:
                             rightParagraph = element;
-                            leftParagraph = rightParagraph.getPreviousSibling();
+                            merge = true;
                         } else {


Input:
protected boolean isUniqueName(JavaFXHierarchyContainer parent, String name, JavaFXHierarchyContainer container) {
    if (name == null) {
        return false;
    }
    if (parent == null) {
        return true;
    }
    List<JavaFXHierarchyContainer> compIDs = parent.getContainerList();
    for (JavaFXHierarchyContainer childContainer : compIDs) {
        String childName = childContainer.getName();
        if (name.equals(childName) && childContainer != container) {
            return false;
        }
    }
    return true;
}

Output:
         return false;
-    }
-    if (parent == null) {
+    } else if (otherNames.isEmpty()) {
         return true;


Input:
public boolean enough(Mana avail) {
    Mana compare = avail.copy();
    compare.subtract(this);
    if (compare.getRed() < 0) {
        compare.setAny(compare.getAny() + compare.getRed());
        if (compare.getAny() < 0)
            return false;
        compare.setRed(0);
    }
    if (compare.getGreen() < 0) {
        compare.setAny(compare.getAny() + compare.getGreen());
        if (compare.getAny() < 0)
            return false;
        compare.setGreen(0);
    }
    if (compare.getBlue() < 0) {
        compare.setAny(compare.getAny() + compare.getBlue());
        if (compare.getAny() < 0)
            return false;
        compare.setBlue(0);
    }
    if (compare.getBlack() < 0) {
        compare.setAny(compare.getAny() + compare.getBlack());
        if (compare.getAny() < 0)
            return false;
        compare.setBlack(0);
    }
    if (compare.getWhite() < 0) {
        compare.setAny(compare.getAny() + compare.getWhite());
        if (compare.getAny() < 0)
            return false;
        compare.setWhite(0);
    }
    if (compare.getColorless() < 0) {
        int remaining = compare.getRed() + compare.getGreen() + compare.getBlack() + compare.getBlue() + compare.getWhite() + compare.getAny();
        if (compare.getColorless() + remaining < 0)
            return false;
    }
    return true;
}

Output:
         compare.setAny(compare.getAny() + compare.getRed());
-        if (compare.getAny() < 0)
+        if (compare.getAny() < 0) {
             return false;


Input:
public void testCreateObjectGraphPut() throws RestCallFailedException, JAXBException {
    StaticBid bid = new StaticBid();
    bid.setId(777);
    bid.setAmount(510);
    bid.setTime(System.currentTimeMillis());
    bid = restCreate(bid, "String_Node_Str", StaticBid.class, false);
    StaticAuction auction = new StaticAuction();
    auction.setId(13012);
    auction.setName("String_Node_Str");
    auction.setStartPrice(500);
    auction.setImage("String_Node_Str");
    auction.setEndPrice(1000);
    auction.setDescription("String_Node_Str");
    auction = restCreate(auction, "String_Node_Str", StaticAuction.class, false);
    StaticUser user = new StaticUser();
    user.setId(466);
    user.setName("String_Node_Str");
    StaticAddress address = new StaticAddress();
    address.setCity("String_Node_Str");
    address.setId(123456);
    address.setStreet("String_Node_Str");
    address.setPostalCode("String_Node_Str");
    address.setType("String_Node_Str");
    user.setAddress(address);
    user = restCreate(user, "String_Node_Str", StaticUser.class, false);
    restUpdateBidirectionalRelationship(String.valueOf(777), "String_Node_Str", "String_Node_Str", auction, "String_Node_Str", MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE, "String_Node_Str", true);
    String bidJsonResponse = restUpdateBidirectionalRelationship(String.valueOf(777), "String_Node_Str", "String_Node_Str", user, "String_Node_Str", MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE, null, true);
    String expectedAuctionLink = "String_Node_Str";
    String expectedUserLink = "String_Node_Str";
    assertTrue(bidJsonResponse.toUpperCase().indexOf(expectedAuctionLink.toUpperCase()) != -1);
    assertTrue(bidJsonResponse.toUpperCase().indexOf(expectedUserLink.toUpperCase()) != -1);
    StaticAuction auctionByLink = restReadByHref(expectedAuctionLink, "String_Node_Str", MediaType.APPLICATION_JSON_TYPE);
    StaticUser userByLink = restReadByHref(expectedUserLink, "String_Node_Str", MediaType.APPLICATION_JSON_TYPE);
    assertTrue("String_Node_Str", userByLink.getName().equals(user.getName()));
    assertTrue("String_Node_Str", auctionByLink.getName().equals(auction.getName()));
}

Output:
     bid.setTime(System.currentTimeMillis());
-    bid = restCreate(bid, "String_Node_Str", StaticBid.class, false);
+    bid = restCreate(bid, "String_Node_Str", StaticBid.class);
     StaticAuction auction = new StaticAuction();


Input:
public static Object getPublicField(Object owner, String fieldName) {
    Object fieldValue = null;
    Class ownerClass = owner.getClass();
    try {
        Field field = ownerClass.getField(fieldName);
        fieldValue = field.get(owner);
    } catch (Exception e) {
        log.error("String_Node_Str", e);
    }
    return fieldValue;
}

Output:
     Class ownerClass = owner.getClass();
-    try {
-        Field field = ownerClass.getField(fieldName);
-        fieldValue = field.get(owner);
-    } catch (Exception e) {
-        log.error("String_Node_Str", e);
-    }
+    Field field = ownerClass.getField(fieldName);
+    fieldValue = field.get(owner);
     return fieldValue;


Input:
private static Set<String> extractSettings(Sign sign) {
    String toParse = sign.getText(0);
    if (sign.getText(1).startsWith("String_Node_Str"))
        toParse += "String_Node_Str" + sign.getText(1);
    if (sign.getText(2).startsWith("String_Node_Str"))
        toParse += "String_Node_Str" + sign.getText(2);
    Set<String> settings = new HashSet<String>();
    StringTokenizer tokeniser = new StringTokenizer(toParse);
    while (tokeniser.hasMoreTokens()) {
        String token = tokeniser.nextToken();
        if (token != null) {
            token = token.trim().toLowerCase();
            settings.add(token);
        }
    }
    return settings;
}

Output:
     String toParse = sign.getText(0);
-    if (sign.getText(1).startsWith("String_Node_Str"))
-        toParse += "String_Node_Str" + sign.getText(1);
-    if (sign.getText(2).startsWith("String_Node_Str"))
-        toParse += "String_Node_Str" + sign.getText(2);
+    if (sign.getText(1).startsWith("String_Node_Str") && sign.getText(1).length() > 1)
+        toParse += "String_Node_Str" + sign.getText(1).substring(1);
+    if (sign.getText(2).startsWith("String_Node_Str") && sign.getText(2).length() > 1)
+        toParse += "String_Node_Str" + sign.getText(2).substring(1);
+    if (sign.getText(3).startsWith("String_Node_Str") && sign.getText(3).length() > 1)
+        toParse += "String_Node_Str" + sign.getText(3).substring(1);
     Set<String> settings = new HashSet<String>();


Input:
private int findPosLogarthmicType(int type) {
    int minInter = 0;
    int maxInter = visibleLogs.size() - 1;
    int middle = 0;
    int maxType;
    int minType;
    boolean sortAscending = comparator.isSortAscending();
    do {
        maxType = cache.getLogType(maxInter);
        minType = cache.getLogType(minInter);
        if (maxInter - minInter <= 1) {
            if (sortAscending) {
                if (type > maxType) {
                    return maxInter + 1;
                } else if (type < minType) {
                    return minInter;
                } else {
                    return maxInter;
                }
            } else {
                if (type > minType) {
                    return minInter;
                } else if (type < maxType) {
                    return maxInter + 1;
                } else {
                    return maxInter;
                }
            }
        }
        middle = minInter + (maxInter - minInter) / 2;
        long typeShift = type - cache.getLogType(middle);
        if (sortAscending) {
            if (typeShift > 0) {
                minInter = middle;
                continue;
            } else if (typeShift < 0) {
                maxInter = middle;
                continue;
            } else {
                return middle;
            }
        } else {
            if (typeShift > 0) {
                maxInter = middle;
                continue;
            } else if (typeShift < 0) {
                minInter = middle;
                continue;
            } else {
                return middle;
            }
        }
    } while (true);
}

Output:
     do {
-        maxType = cache.getLogType(maxInter);
-        minType = cache.getLogType(minInter);
+        maxType = cache.getLogType(visibleLogs.get(maxInter));
+        minType = cache.getLogType(visibleLogs.get(minInter));
         if (maxInter - minInter <= 1) {


Input:
public List<TdColumn> returnColumns(IMetadataConnection metadataConnection, TableNode tableNode, boolean... dontCreateClose) {
    if (metadataConnection == null || tableNode == null || tableNode.getType() != TableNode.TABLE) {
        return Collections.emptyList();
    }
    NamedColumnSet table = tableNode.getTable();
    if (table == null) {
        table = tableNode.getView();
    }
    if (table == null) {
        return Collections.emptyList();
    }
    List<TdColumn> metadataColumns = new ArrayList<TdColumn>();
    boolean needCreateAndClose = dontCreateClose.length == 0 || !dontCreateClose[0];
    DriverShim wapperDriver = null;
    String dbType = "String_Node_Str";
    try {
        if (needCreateAndClose || ExtractMetaDataUtils.conn == null || ExtractMetaDataUtils.conn.isClosed()) {
            List list = ExtractMetaDataUtils.getConnection(metadataConnection.getDbType(), metadataConnection.getUrl(), metadataConnection.getUsername(), metadataConnection.getPassword(), metadataConnection.getDatabase(), metadataConnection.getSchema(), metadataConnection.getDriverClass(), metadataConnection.getDriverJarPath(), metadataConnection.getDbVersionString(), metadataConnection.getAdditionalParams());
            if (list != null && list.size() > 0) {
                for (int i = 0; i < list.size(); i++) {
                    if (list.get(i) instanceof DriverShim) {
                        wapperDriver = (DriverShim) list.get(i);
                    }
                }
            }
        }
        dbType = metadataConnection.getDbType();
        DatabaseMetaData dbMetaData = ExtractMetaDataUtils.getDatabaseMetaData(ExtractMetaDataUtils.conn, dbType, metadataConnection.isSqlMode(), metadataConnection.getDatabase());
        String tableLabel = tableNode.getValue();
        TableNode newNode = tableNode;
        String name = newNode.getItemType();
        if (name != null && StringUtils.trimToEmpty(name).equals(ETableTypes.TABLETYPE_SYNONYM.getName())) {
            String tableName = getTableNameBySynonyms(ExtractMetaDataUtils.conn, newNode.getValue());
            if (tableName != null && tableName.contains("String_Node_Str")) {
                tableName = tableName.replace("String_Node_Str", "String_Node_Str");
            }
            fillSynonyms(metadataConnection, metadataColumns, table, tableName, dbMetaData);
        } else {
            if (tableLabel.contains("String_Node_Str")) {
                tableLabel = tableLabel.replace("String_Node_Str", "String_Node_Str");
            }
            newNode.setValue(tableLabel);
            metadataColumns = MetadataFillFactory.getDBInstance().fillColumns(table, metadataConnection, dbMetaData, null);
        }
        ColumnSetHelper.addColumns(table, metadataColumns);
        if (needCreateAndClose) {
            ExtractMetaDataUtils.closeConnection();
        }
    } catch (Exception e) {
        ExceptionHandler.process(e);
        log.error(e);
    } finally {
        closeConnect(metadataConnection, wapperDriver);
    }
    return metadataColumns;
}

Output:
     } finally {
-        closeConnect(metadataConnection, wapperDriver);
+        closeConnection(metadataConnection, wapperDriver);
     }


Input:
boolean checkEquivalenceHelper(JSType that, EquivalenceMethod eqMethod) {
    if (this == that) {
        return true;
    }
    boolean thisUnknown = isUnknownType();
    boolean thatUnknown = that.isUnknownType();
    if (thisUnknown || thatUnknown) {
        if (eqMethod == EquivalenceMethod.INVARIANT) {
            return true;
        } else if (eqMethod == EquivalenceMethod.DATA_FLOW) {
            return thisUnknown && thatUnknown;
        } else if (thisUnknown && thatUnknown && (isNominalType() ^ that.isNominalType())) {
            return false;
        }
    }
    if (isUnionType() && that.isUnionType()) {
        return this.toMaybeUnionType().checkUnionEquivalenceHelper(that.toMaybeUnionType(), eqMethod);
    }
    if (isFunctionType() && that.isFunctionType()) {
        return this.toMaybeFunctionType().checkFunctionEquivalenceHelper(that.toMaybeFunctionType(), eqMethod);
    }
    if (isRecordType() && that.isRecordType()) {
        return this.toMaybeRecordType().checkRecordEquivalenceHelper(that.toMaybeRecordType(), eqMethod);
    }
    ParameterizedType thisParamType = toMaybeParameterizedType();
    ParameterizedType thatParamType = that.toMaybeParameterizedType();
    if (thisParamType != null || thatParamType != null) {
        boolean paramsMatch = false;
        if (thisParamType != null && thatParamType != null) {
            paramsMatch = thisParamType.getParameterType().checkEquivalenceHelper(thatParamType.getParameterType(), eqMethod);
        } else if (eqMethod == EquivalenceMethod.IDENTITY) {
            paramsMatch = false;
        } else {
            paramsMatch = true;
        }
        JSType thisRootType = thisParamType == null ? this : thisParamType.getReferencedTypeInternal();
        JSType thatRootType = thatParamType == null ? that : thatParamType.getReferencedTypeInternal();
        return paramsMatch && thisRootType.checkEquivalenceHelper(thatRootType, eqMethod);
    }
    if (isNominalType() && that.isNominalType()) {
        return toObjectType().getReferenceName().equals(that.toObjectType().getReferenceName());
    }
    if (this instanceof ProxyObjectType) {
        return ((ProxyObjectType) this).getReferencedTypeInternal().checkEquivalenceHelper(that, eqMethod);
    }
    if (that instanceof ProxyObjectType) {
        return checkEquivalenceHelper(((ProxyObjectType) that).getReferencedTypeInternal(), eqMethod);
    }
    return this == that;
}

Output:
     if (isUnionType() && that.isUnionType()) {
-        return this.toMaybeUnionType().checkUnionEquivalenceHelper(that.toMaybeUnionType(), eqMethod);
+        return toMaybeUnionType().checkUnionEquivalenceHelper(that.toMaybeUnionType(), eqMethod);
     }


Input:
public static void fixLinux(int trayIconSize) {
    if (isOracleVM()) {
        return;
    }
    if (isSwingTrayLoaded()) {
        throw new RuntimeException("String_Node_Str");
    }
    try {
        ClassPool pool = ClassPool.getDefault();
        CtField ctField;
        String className = "String_Node_Str";
        byte[] eFrameBytes;
        byte[] trayIconBytes;
        byte[] trayPeerBytes;
        {
            CtClass trayIconClass = pool.get(className);
            CtClass eFrameClass = null;
            CtClass trayPeerClass;
            CtClass[] nestedClasses = trayIconClass.getNestedClasses();
            for (CtClass nestedClass : nestedClasses) {
                String name = nestedClass.getName();
                if (name.equals(className + "String_Node_Str")) {
                    eFrameClass = nestedClass;
                }
            }
            if (eFrameClass == null) {
                throw new RuntimeException("String_Node_Str");
            }
            ctField = new CtField(pool.get("String_Node_Str"), "String_Node_Str", trayIconClass);
            ctField.setModifiers(Modifier.STATIC);
            trayIconClass.addField(ctField);
            ctField = new CtField(pool.get("String_Node_Str"), "String_Node_Str", trayIconClass);
            ctField.setModifiers(Modifier.STATIC);
            trayIconClass.addField(ctField);
            trayPeerClass = pool.get("String_Node_Str");
            CtConstructor constructor = trayIconClass.getDeclaredConstructors()[0];
            CtMethod method1 = trayIconClass.getDeclaredMethod("String_Node_Str");
            CtMethod method2 = trayPeerClass.getDeclaredMethod("String_Node_Str");
            CtBehavior[] methodInfos = new CtBehavior[] { constructor, method1, method2 };
            fixTraySize(methodInfos, 24, trayIconSize);
            constructor.getMethodInfo().rebuildStackMapForME(trayIconClass.getClassPool());
            method1.getMethodInfo().rebuildStackMapForME(trayIconClass.getClassPool());
            method2.getMethodInfo().rebuildStackMapForME(trayPeerClass.getClassPool());
            trayIconBytes = trayIconClass.toBytecode();
            trayPeerBytes = trayPeerClass.toBytecode();
            CtMethod methodVisible = CtNewMethod.make("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", eFrameClass);
            eFrameClass.addMethod(methodVisible);
            methodVisible.getMethodInfo().rebuildStackMapForME(eFrameClass.getClassPool());
            eFrameBytes = eFrameClass.toBytecode();
        }
        BootStrapClassLoader.defineClass(trayIconBytes);
        BootStrapClassLoader.defineClass(trayPeerBytes);
        BootStrapClassLoader.defineClass(eFrameBytes);
        if (SystemTray.DEBUG) {
            logger.debug("String_Node_Str");
        }
    } catch (Exception e) {
        logger.error("String_Node_Str", e);
    }
}

Output:
             trayPeerBytes = trayPeerClass.toBytecode();
-            CtMethod methodVisible = CtNewMethod.make("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", eFrameClass);
+            CtMethod methodVisible = CtNewMethod.make("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + className + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", eFrameClass);
             eFrameClass.addMethod(methodVisible);


Input:
public boolean put(K key, V value) {
    return chronicleMap.update(key, value) != UpdateResult.INSERT;
}

Output:
 public boolean put(K key, V value) {
-    return chronicleMap.update(key, value) != UpdateResult.INSERT;
+    try {
+        return chronicleMap.update(key, value) != UpdateResult.INSERT;
+    } catch (Exception e) {
+        System.err.println("String_Node_Str" + key + "String_Node_Str" + value);
+        throw e;
+    }
 }


Input:
public void checkXMLPersistence() throws NullPointerException, JAXBException, IOException {
    JobLauncherForm jobForm = new JobLauncherForm();
    JobLauncherForm loadedForm = new JobLauncherForm();
    ArrayList<String> actions = new ArrayList<String>();
    ICEJAXBHandler xmlHandler = new ICEJAXBHandler();
    ArrayList<Class> classList = new ArrayList<Class>();
    classList.add(JobLauncherForm.class);
    classList.addAll(new ICEJAXBClassProvider().getClasses());
    jobForm.setName("String_Node_Str");
    jobForm.setDescription("String_Node_Str");
    jobForm.setId(3);
    jobForm.enableMPI(2, 4, 2);
    jobForm.enableOpenMP(2, 4, 3);
    actions.add("String_Node_Str");
    jobForm.setActionList(actions);
    jobForm.setInputFiles("String_Node_Str", "String_Node_Str", new ArrayList<String>());
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    xmlHandler.write(jobForm, classList, outputStream);
    loadedForm = (JobLauncherForm) xmlHandler.read(classList, new ByteArrayInputStream(outputStream.toByteArray()));
    assertTrue(jobForm.equals(loadedForm));
}

Output:
     JobLauncherForm jobForm = new JobLauncherForm();
-    JobLauncherForm loadedForm = new JobLauncherForm();
+    Form loadedForm = new JobLauncherForm();
     ArrayList<String> actions = new ArrayList<String>();


Input:
public void bindData(TopicRelativeBean value) {
    mTopicTrace = value;
    mTxtDate.setText(value.getCreatedAt().toLocalDate().toString());
    mTxtContent.setText(value.getTitle());
    mDividerTop.setVisibility(getItemViewType() == TopicDetailFragment.VIEW_TYPE_TOP ? View.INVISIBLE : View.VISIBLE);
    mDividerBottom.setVisibility(getItemViewType() == TopicDetailFragment.VIEW_TYPE_BOTTOM ? View.INVISIBLE : View.VISIBLE);
}

Output:
     mTopicTrace = value;
-    mTxtDate.setText(value.getCreatedAt().toLocalDate().toString());
+    LocalDate date = value.getCreatedAt().toLocalDate();
+    int year = date.getYear();
+    int month = date.getMonthValue();
+    int day = date.getDayOfMonth();
+    if (year == OffsetDateTime.now().getYear()) {
+        mTxtDate.setText(mContext.getString(R.string.month__day, month, day));
+    } else {
+        SpannableString spannableTitle = SpannableString.valueOf(mContext.getString(R.string.month__day__year, month, day, year));
+        spannableTitle.setSpan(new ForegroundColorSpan(Color.parseColor("String_Node_Str")), 5, 9, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        mTxtDate.setText(spannableTitle);
+    }
     mTxtContent.setText(value.getTitle());


Input:
public boolean harvest(World world, int x, int y, int z) {
    if (!world.isRemote) {
        boolean update = false;
        TileEntityCrop crop = (TileEntityCrop) world.getTileEntity(x, y, z);
        if (crop.weed) {
            crop.clearWeed();
        } else if (crop.crossCrop) {
            crop.crossCrop = false;
            this.dropBlockAsItem(world, x, y, z, new ItemStack(Items.crops, 1));
            update = true;
        } else if (crop.isMature()) {
            crop.getWorldObj().setBlockMetadataWithNotify(crop.xCoord, crop.yCoord, crop.zCoord, 2, 2);
            update = true;
            ArrayList<ItemStack> drops = SeedHelper.getPlantFruits((ItemSeeds) crop.seed, world, x, y, z, crop.gain, crop.seedMeta);
            for (ItemStack drop : drops) {
                this.dropBlockAsItem(world, x, y, z, drop);
            }
        }
        if (update) {
            crop.markDirty();
        }
        return update;
    }
    return false;
}

Output:
         if (update) {
-            crop.markDirty();
+            crop.markDirtyAndMarkForUpdate();
         }


Input:
public boolean validatePartition(Partition partition) throws InvalidPartitionException {
    String provider = partition.getProvider();
    IaasProvider iaasProvider = dataHolder.getIaasProvider(provider);
    if (iaasProvider == null) {
        String msg = "String_Node_Str" + partition.toString() + "String_Node_Str" + provider;
        log.error(msg);
        throw new InvalidPartitionException(msg);
    }
    Iaas iaas = iaasProvider.getIaas();
    if (iaas == null) {
        try {
            iaas = (Iaas) Class.forName(iaasProvider.getClassName()).newInstance();
            ComputeServiceBuilderUtil.buildDefaultComputeService(iaasProvider);
            iaasProvider.setIaas(iaas);
        } catch (Exception e) {
            String msg = "String_Node_Str" + iaasProvider.getClassName();
            log.error(msg, e);
            throw new InvalidPartitionException(msg, e);
        }
    }
    PartitionValidator validator = iaas.getPartitionValidator();
    validator.setIaasProvider(iaasProvider);
    validator.validate(partition.getId(), CloudControllerUtil.toJavaUtilProperties(partition.getProperties()));
    return true;
}

Output:
     if (iaasProvider == null) {
-        String msg = "String_Node_Str" + partition.toString() + "String_Node_Str" + provider;
+        String msg = "String_Node_Str" + partition.toString() + "String_Node_Str" + "String_Node_Str" + provider;
         log.error(msg);


Input:
public static Condition format(String format, Object... args) {
    return new SimpleCondition(format, args);
}

Output:
 public static Condition format(String format, Object... args) {
-    return new SimpleCondition(format, args);
+    return Strings.isBlank(format) ? null : new SimpleCondition(format, args);
 }


Input:
private void overwriteExtraInfoIfExists(String key, String value) {
    boolean found = false;
    for (ExtraInfoHolder extraInfoHolder : ivyModuleDescriptor.getExtraInfos()) {
        if (extraInfoHolder.getName().equals(key)) {
            extraInfoHolder.setContent(value);
            found = false;
        }
    }
    if (!found) {
        ivyModuleDescriptor.getExtraInfos().add(new ExtraInfoHolder(key, value));
    }
}

Output:
             extraInfoHolder.setContent(value);
-            found = false;
+            found = true;
         }


Input:
public void setFieldDouble(double fieldDouble) {
    this.fieldDouble = fieldDouble;
}

Output:
 public void setFieldDouble(double fieldDouble) {
-    this.fieldDouble = fieldDouble;
+    realmSetter$fieldDouble(fieldDouble);
 }


Input:
public static void main(String[] args) throws Exception {
    if (args.length != 2) {
        System.err.println("String_Node_Str" + ProtographClient.class.getSimpleName() + "String_Node_Str");
        return;
    }
    String host = args[0];
    int port = Integer.parseInt(args[1]);
    ProtographClient client = new ProtographClient(host, port);
    ConsoleReader reader = new ConsoleReader();
    for (; ; ) {
        String line = reader.readLine();
        if (line == null) {
            break;
        }
        List<JSONObject> results = client.exec(line.trim() + "String_Node_Str");
        if (null == results) {
            log.info("String_Node_Str");
        } else {
            int c = 0;
            for (JSONObject result : results) {
                c++;
                log.info(c + "String_Node_Str" + result.toString(4));
            }
        }
        if (line.toLowerCase().equals("String_Node_Str")) {
            client.disconnect();
            break;
        }
    }
    client.disconnect();
}

Output:
         } else {
-            int c = 0;
-            for (JSONObject result : results) {
-                c++;
-                log.info(c + "String_Node_Str" + result.toString(4));
+            if (results.size() == 0) {
+                log.info("String_Node_Str");
+            } else {
+                int c = 0;
+                for (JSONObject result : results) {
+                    c++;
+                    log.info(c + "String_Node_Str" + result.toString(4));
+                }
             }


Input:
public Object[][] getVariants() {
    return new Object[][] { { new Variant(null) }, { new Variant("String_Node_Str") }, { new Variant(42) }, { new Variant(new Integer[] { 0, 1, 2, 3 }) }, { new Variant(new Integer[][] { { 0, 1 }, { 2, 3 } }) }, { new Variant(new Long[] { 0L, 1L, 2L, 3L }) }, { new Variant(new Long[][] { { 0L, 1L }, { 2L, 3L } }) }, { new Variant(new UInteger[] { Unsigned.uint(0), Unsigned.uint(1), Unsigned.uint(2), Unsigned.uint(3) }) }, { new Variant(new UInteger[][] { { Unsigned.uint(0), Unsigned.uint(1) }, { Unsigned.uint(2), Unsigned.uint(3) } }) } };
}

Output:
 public Object[][] getVariants() {
-    return new Object[][] { { new Variant(null) }, { new Variant("String_Node_Str") }, { new Variant(42) }, { new Variant(new Integer[] { 0, 1, 2, 3 }) }, { new Variant(new Integer[][] { { 0, 1 }, { 2, 3 } }) }, { new Variant(new Long[] { 0L, 1L, 2L, 3L }) }, { new Variant(new Long[][] { { 0L, 1L }, { 2L, 3L } }) }, { new Variant(new UInteger[] { Unsigned.uint(0), Unsigned.uint(1), Unsigned.uint(2), Unsigned.uint(3) }) }, { new Variant(new UInteger[][] { { Unsigned.uint(0), Unsigned.uint(1) }, { Unsigned.uint(2), Unsigned.uint(3) } }) } };
+    return new Object[][] { { new Variant(null) }, { new Variant("String_Node_Str") }, { new Variant(42) }, { new Variant(new Integer[] { 0, 1, 2, 3 }) }, { new Variant(new Integer[][] { { 0, 1 }, { 2, 3 } }) }, { new Variant(new Long[] { 0L, 1L, 2L, 3L }) }, { new Variant(new Long[][] { { 0L, 1L }, { 2L, 3L } }) }, { new Variant(new UInteger[] { Unsigned.uint(0), Unsigned.uint(1), Unsigned.uint(2), Unsigned.uint(3) }) }, { new Variant(new UInteger[][] { { Unsigned.uint(0), Unsigned.uint(1) }, { Unsigned.uint(2), Unsigned.uint(3) } }) }, { new Variant(new Variant[] { new Variant(0), new Variant(1), new Variant(2) }) } };
 }


Input:
public boolean getPadding(Rect padding) {
    final Rect r = mDrawableContainerState.getConstantPadding();
    boolean result = true;
    if (r != null) {
        padding.set(r);
    } else {
        if (mCurrDrawable != null) {
            result = mCurrDrawable.getPadding(padding);
        } else {
            result = super.getPadding(padding);
        }
    }
    if (needsMirroring()) {
        final int left = padding.left;
        final int right = padding.right;
        padding.left = right;
        padding.right = left;
    }
    return result;
}

Output:
     final Rect r = mDrawableContainerState.getConstantPadding();
-    boolean result = true;
+    boolean result;
     if (r != null) {


Input:
protected void search() {
    parseIntent();
    mStatuses.clear();
    doSearch(true);
    mPullToRefreshListView.setRefreshing();
}

Output:
     parseIntent();
-    mStatuses.clear();
+    maxId = null;
+    mStatusAdapter.clear();
     doSearch(true);


Input:
public boolean performFinish() {
    IProxyRepositoryFactory repositoryFactory = ProxyRepositoryFactory.getInstance();
    try {
        ILibrariesService service = CorePlugin.getDefault().getLibrariesService();
        URL templateUrl = service.getPigudfTemplate(mainPage.getSelectedTemplate());
        ByteArray byteArray = PropertiesFactory.eINSTANCE.createByteArray();
        InputStream stream = null;
        try {
            stream = templateUrl.openStream();
            byte[] innerContent = new byte[stream.available()];
            stream.read(innerContent);
            stream.close();
            byteArray.setInnerContent(innerContent);
        } catch (IOException e) {
            RuntimeExceptionHandler.process(e);
        }
        pigUDFItem.setContent(byteArray);
        updateItemContent();
        property.setId(repositoryFactory.getNextId());
        property.setLabel(property.getDisplayName());
        IMPORTType type = ComponentFactory.eINSTANCE.createIMPORTType();
        String jarName = "String_Node_Str";
        String relativePath = "String_Node_Str" + jarName;
        URI uri = new URI(relativePath);
        boolean libExist = false;
        ILibraryManagerService librairesService = (ILibraryManagerService) GlobalServiceRegister.getDefault().getService(ILibraryManagerService.class);
        try {
            URL url = FileLocator.toFileURL(uri.toURL());
            File file = new File(url.getFile());
            if (file.exists()) {
                libExist = true;
                CorePlugin.getDefault().getLibrariesService().deployLibrary(file.toURL());
            }
        } catch (Exception e) {
            if (GlobalServiceRegister.getDefault().isServiceRegistered(ILibraryManagerUIService.class)) {
                ILibraryManagerUIService libUiService = (ILibraryManagerUIService) GlobalServiceRegister.getDefault().getService(ILibraryManagerUIService.class);
                libUiService.installModules(new String[] { jarName });
            }
            if (librairesService.list(new NullProgressMonitor()).contains(repositoryFactory)) {
                libExist = true;
            }
        }
        if (libExist) {
            type.setMODULE(jarName);
            type.setREQUIRED(true);
            type.setUrlPath(librairesService.getJarPath(jarName));
            pigUDFItem.getImports().add(type);
        }
        repositoryFactory.create(pigUDFItem, mainPage.getDestinationPath());
        if (libExist) {
            CorePlugin.getDefault().getRunProcessService().updateLibraries(new HashSet<String>(), null);
        }
    } catch (PersistenceException e) {
        ExceptionHandler.process(e);
    } catch (URISyntaxException e) {
        ExceptionHandler.process(e);
    }
    return pigUDFItem != null;
}

Output:
         if (libExist) {
-            CorePlugin.getDefault().getRunProcessService().updateLibraries(new HashSet<String>(), null);
+            CorePlugin.getDefault().getRunProcessService().updateLibraries(new HashSet<ModuleNeeded>(), null);
         }


Input:
public void AssertNotObstruction(BlockRecord Record) throws CarriageMotionException {
    Debug.dbg("String_Node_Str");
    if (Body.contains(Record)) {
        return;
    }
    if (World.isAirBlock(Record.X, Record.Y, Record.Z)) {
        return;
    }
    if (World.getBlock(Record.X, Record.Y, Record.Z).getMaterial().isLiquid()) {
        if (ObstructedByLiquids) {
            FailBecauseObstructed(Record, "String_Node_Str");
        }
        return;
    }
    if (!World.getBlock(Record.X, Record.Y, Record.Z).canBeReplacedByLeaves(World, Record.X, Record.Y, Record.Z)) {
        if (ObstructedByFragileBlocks) {
            FailBecauseObstructed(Record, "String_Node_Str");
        }
        return;
    }
    FailBecauseObstructed(Record, "String_Node_Str");
}

Output:
 public void AssertNotObstruction(BlockRecord Record) throws CarriageMotionException {
-    Debug.dbg("String_Node_Str");
+    Debug.dbg("String_Node_Str" + Record);
     if (Body.contains(Record)) {


Input:
public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
    if (arg0 instanceof CommonViewer) {
        this.viewer = (CommonViewer) arg0;
    }
    super.inputChanged(arg0, arg1, arg2);
    topLevelNodeToPathMap.clear();
    addResourceChangeListener();
}

Output:
     topLevelNodeToPathMap.clear();
-    addResourceChangeListener();
+    addResourceVisitor(this.viewer);
 }


Input:
protected void drawGridBandsVertical(Graphics2D g2, Rectangle2D drawArea, Rectangle2D plotArea, boolean firstGridBandIsDark, List<ValueTick> ticks) {
    boolean currentGridBandIsDark = firstGridBandIsDark;
    double xx = plotArea.getX();
    double yy1, yy2;
    double outlineStrokeWidth;
    Stroke outlineStroke = getPlot().getOutlineStroke();
    if (outlineStroke != null && outlineStroke instanceof BasicStroke) {
        outlineStrokeWidth = ((BasicStroke) outlineStroke).getLineWidth();
    } else {
        outlineStrokeWidth = 1d;
    }
    for (ValueTick tick : ticks) {
        yy1 = valueToJava2D(tick.getValue() + 0.5d, plotArea, RectangleEdge.LEFT);
        yy2 = valueToJava2D(tick.getValue() - 0.5d, plotArea, RectangleEdge.LEFT);
        if (currentGridBandIsDark) {
            g2.setPaint(this.gridBandPaint);
        } else {
            g2.setPaint(this.gridBandAlternatePaint);
        }
        Rectangle2D band = new Rectangle2D.Double(xx + outlineStrokeWidth, yy1, plotArea.getMaxX() - xx - outlineStrokeWidth, yy2 - yy1);
        g2.fill(band);
        currentGridBandIsDark = !currentGridBandIsDark;
    }
    g2.setPaintMode();
}

Output:
     boolean currentGridBandIsDark = firstGridBandIsDark;
-    double xx = plotArea.getX();
+    double xx = dataArea.getX();
     double yy1, yy2;


Input:
public static Object allocateArray(int numElements, int logElementSize, int headerSize, Object[] tib, int allocator, int align, int offset, int site) throws UninterruptiblePragma, InlinePragma {
    SelectedMutatorContext mutator = SelectedMutatorContext.get();
    int elemBytes = numElements << logElementSize;
    if ((elemBytes >>> logElementSize) != numElements) {
        Assert.failWithOutOfMemoryErrorStatic();
    }
    int size = elemBytes + headerSize;
    allocator = mutator.checkAllocator(size, align, allocator);
    Address region = allocateSpace(mutator, size, align, offset, allocator, site);
    Object result = VM_ObjectModel.initializeArray(region, tib, numElements, size);
    mutator.postAlloc(ObjectReference.fromObject(result), ObjectReference.fromObject(tib), size, allocator);
    return result;
}

Output:
     int size = elemBytes + headerSize;
-    allocator = mutator.checkAllocator(size, align, allocator);
+    allocator = mutator.checkAllocator(VM_Memory.alignUp(size, MIN_ALIGNMENT), align, allocator);
     Address region = allocateSpace(mutator, size, align, offset, allocator, site);


Input:
public void shouldPingPong() {
    Server server = new Server(10000);
    server.addOperationHandler(new PingPong());
    try {
        server.open();
        Client client = new Client(server.getInetAddress(), 10000);
        String result = client.invoke(new PingPong());
        assertThat(result, Matchers.equalTo("String_Node_Str"));
    } catch (IOException e) {
    }
}

Output:
         server.open();
-        Client client = new Client(server.getInetAddress(), 10000);
+        Client client = new Client(server.getInetAddress(), server.getPort());
         String result = client.invoke(new PingPong());


Input:
public SemanticAnnotation disambiguate(Annotation annotation, Set<Entity> candidateEntities) {
    if (!candidateEntities.isEmpty()) {
        List<String> tokenContext = contextExtractor.extractContext(annotation);
        double maxScore = Double.MIN_VALUE;
        Entity bestEntity = null;
        for (Entity entity : candidateEntities) {
            Set<String> entityContext = StructuralEntityContext.getContextInNaturalLanguage(ontology, entity);
            double score = computeScore(tokenContext, entityContext);
            if (score > maxScore) {
                maxScore = score;
                bestEntity = entity;
            }
        }
        return new SemanticAnnotation(annotation, bestEntity);
    }
    return null;
}

Output:
         List<String> tokenContext = contextExtractor.extractContext(annotation);
-        double maxScore = Double.MIN_VALUE;
+        double maxScore = Double.NEGATIVE_INFINITY;
         Entity bestEntity = null;