Input:
public List<IBookmarkInfo> getBookmarkInfos(Locale locale) throws EngineException {
    if (!isComplete()) {
        return null;
    }
    ArrayList<IBookmarkInfo> results = new ArrayList<IBookmarkInfo>();
    loadCoreStreamLazily();
    if (indexReader != null) {
        try {
            List<BookmarkContent> bookmarks = indexReader.getBookmarkContents();
            if (bookmarks == null) {
                return null;
            }
            ReportDesignHandle report = this.getReportDesign();
            for (BookmarkContent bookmark : bookmarks) {
                long designId = bookmark.getElementId();
                DesignElementHandle handle = report.getElementByID(designId);
                if (handle == null)
                    continue;
                String elementType = handle.getName();
                String displayName = null;
                if (handle instanceof ReportItemHandle) {
                    displayName = ((ReportItemHandle) handle).getBookmarkDisplayName();
                }
                if (locale != null) {
                    if (handle instanceof ReportElementHandle) {
                        ReportElementHandle elementHandle = (ReportElementHandle) handle;
                        displayName = ModuleUtil.getExternalizedValue(elementHandle, bookmark.getBookmark(), displayName, ULocale.forLocale(locale));
                    }
                }
                results.add(new BookmarkInfo(bookmark.getBookmark(), displayName, elementType));
            }
        } catch (IOException ex) {
            throw new EngineException("String_Node_Str", ex);
        }
    }
    return results;
}

Output:
                     continue;
-                String elementType = handle.getName();
+                String elementType = handle.getDefn().getName();
                 String displayName = null;


Input:
public static Integer getNumberOfExperimentsPerIteration(ExplorationStrategy strategyConfig) {
    String value = strategyConfig.getConfiguration().get(NUMBER_OF_EXPERIMENTS_PER_ITERATION);
    if (value != null) {
        return Integer.valueOf(value);
    } else {
        return NUMBER_OF_EXPERIMENTS_PER_ITERATION_DEFAULT_VALUE;
    }
}

Output:
     String value = strategyConfig.getConfiguration().get(NUMBER_OF_EXPERIMENTS_PER_ITERATION);
-    if (value != null) {
+    if (value != null && !value.isEmpty()) {
         return Integer.valueOf(value);


Input:
public void widgetSelected(SelectionEvent e) {
    txtMaxDataSetRow.setEnabled(!noLimitBtn.getSelection(), noLimitBtn.getParent());
    if (!noLimitBtn.getSelection()) {
        txtMaxDataSetRow.setFocus();
    }
    txtMaxDataSetRow.checkState();
}

Output:
     }
-    txtMaxDataSetRow.checkState();
+    if (txtMaxDataSetRow.checkState()) {
+    }
 }


Input:
public void closeTransport() {
    try {
        if (transport != null) {
            transport.get().close();
            transport.set(null);
        }
    } catch (MessagingException e) {
    }
}

Output:
     try {
-        if (transport != null) {
+        if (transport.get() != null) {
             transport.get().close();


Input:
private void setupItemDecorator() {
    final RecyclerView.LayoutManager layoutManager = mRecyclerView.getLayoutManager();
    if (layoutManager instanceof GridLayoutManager) {
        int orientation = ((GridLayoutManager) layoutManager).getOrientation();
        switch(orientation) {
            case LinearLayoutManager.VERTICAL:
                mRecyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
                    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
                        super.getItemOffsets(outRect, view, parent, state);
                        int position = parent.getChildLayoutPosition(view);
                        if (position < ((GridLayoutManager) layoutManager).getSpanCount()) {
                            outRect.top = mHeightHeader;
                        }
                    }
                });
                break;
            case LinearLayoutManager.HORIZONTAL:
                break;
        }
    } else if (layoutManager instanceof LinearLayoutManager) {
        int orientation = ((LinearLayoutManager) layoutManager).getOrientation();
        switch(orientation) {
            case LinearLayoutManager.VERTICAL:
                mRecyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
                    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
                        super.getItemOffsets(outRect, view, parent, state);
                        int position = parent.getChildLayoutPosition(view);
                        if (position == 0) {
                            outRect.top = mHeightHeader;
                        }
                    }
                });
                break;
            case LinearLayoutManager.HORIZONTAL:
                break;
        }
    }
}

Output:
             case LinearLayoutManager.HORIZONTAL:
-                break;
+                throw new IllegalStateException("String_Node_Str");
         }


Input:
public ICompletionProposal[] getTagProposals(IAssistState state) {
    Assert.isNotNull(state, "String_Node_Str");
    Assert.isNotNull(this.sourceDict, "String_Node_Str");
    int offset = state.getOffset();
    IDocument doc = state.getIDocument();
    char invokerChar = state.getTriggerData();
    String tagLimiting = state.getDataSoFar().substring(1).toLowerCase().trim();
    if (invokerChar == '\"') {
        try {
            if (doc.getLength() > offset && doc.getChar(offset) == '\"' && doc.getChar(offset - 2) != '=') {
                doc.replace(offset, 1, "String_Node_Str");
                return new ICompletionProposal[0];
            }
        } catch (BadLocationException ex) {
            ex.printStackTrace();
            return new ICompletionProposal[0];
        }
    }
    return makeSetToProposal(((SyntaxDictionaryInterface) this.sourceDict).getFilteredElements(tagLimiting), offset, CFEContentAssist.TAGTYPE, tagLimiting.length());
}

Output:
     char invokerChar = state.getTriggerData();
-    String tagLimiting = state.getDataSoFar().substring(1).toLowerCase().trim();
+    boolean doubleQuoted = false;
+    boolean singleQuoted = false;
+    int tagStart = 1;
+    for (int i = state.getDataSoFar().length() - 1; i >= 0; i--) {
+        char c = state.getDataSoFar().charAt(i);
+        if (c == '"') {
+            if (!singleQuoted) {
+                doubleQuoted = !doubleQuoted;
+            }
+        }
+        if (c == '\'') {
+            if (!doubleQuoted) {
+                singleQuoted = !singleQuoted;
+            }
+        }
+        if (!doubleQuoted && !singleQuoted) {
+            if (c == '<') {
+                tagStart = i + 1;
+                break;
+            }
+        }
+    }
+    String tagLimiting = state.getDataSoFar().substring(tagStart).toLowerCase().trim();
     if (invokerChar == '\"') {


Input:
private void checkAndHandleBottomButtons() {
    if (adapter != null && bottomButtonsLinearLayout != null && clearButton != null) {
        if (adapter.getSelectedItemCount() > 0 || isPublicCall) {
            if (bottomButtonsLinearLayout.getVisibility() != View.VISIBLE) {
                bottomButtonsLinearLayout.setVisibility(View.VISIBLE);
            }
            if (isPublicCall && adapter.getSelectedItemCount() < 2) {
                clearButton.setVisibility(View.GONE);
            } else {
                clearButton.setVisibility(View.VISIBLE);
            }
        } else {
            bottomButtonsLinearLayout.setVisibility(View.GONE);
        }
    } else if (bottomButtonsLinearLayout != null) {
        bottomButtonsLinearLayout.setVisibility(View.GONE);
    }
}

Output:
             }
-            if (isPublicCall && adapter.getSelectedItemCount() < 2) {
+            if (adapter.getSelectedItemCount() == 0) {
                 clearButton.setVisibility(View.GONE);


Input:
protected void _arriveFirst(CSPReceiver receiver, ConditionalBranchController controller) throws InterruptedException {
    receiver._setConditionalSend(true, controller);
    getController()._branchBlocked(this.getReceiver());
    getReceiver()._checkFlagsAndWait();
    getController()._branchUnblocked(this.getReceiver());
    while (true) {
        if (!isAlive()) {
            receiver._setConditionalSend(false, null);
            controller._branchFailed(getID());
            receiver.notifyAll();
            return;
        } else if (receiver._isGetWaiting()) {
            if (controller._isBranchFirst(getID())) {
                receiver._setConditionalSend(false, null);
                receiver.put(getToken());
                controller._branchSucceeded(getID());
                return;
            }
        }
        getController()._branchBlocked(this.getReceiver());
        getReceiver()._checkFlagsAndWait();
        getController()._branchUnblocked(this.getReceiver());
    }
}

Output:
 protected void _arriveFirst(CSPReceiver receiver, ConditionalBranchController controller) throws InterruptedException {
-    receiver._setConditionalSend(true, controller);
+    receiver._setConditionalSend(true, controller, getID());
     getController()._branchBlocked(this.getReceiver());


Input:
public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
    Set<UUID> possibleTargets = new HashSet<UUID>();
    for (UUID playerId : game.getPlayer(sourceControllerId).getInRange()) {
        Player player = game.getPlayer(playerId);
        if (player != null && filter.match(player, game)) {
            possibleTargets.add(playerId);
        }
    }
    for (Permanent permanent : game.getBattlefield().getActivePermanents(new FilterCreaturePermanent(), sourceControllerId, game)) {
        if (filter.match(permanent, null, sourceControllerId, game)) {
            possibleTargets.add(permanent.getId());
        }
    }
    return possibleTargets;
}

Output:
 public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
-    Set<UUID> possibleTargets = new HashSet<UUID>();
+    Set<UUID> possibleTargets = new HashSet<>();
     for (UUID playerId : game.getPlayer(sourceControllerId).getInRange()) {


Input:
public void seek(int index) throws IOException {
    if (index >= length) {
        return;
    }
    if (index >= aggregationResultRow.size()) {
        for (int i = 0; i <= index - aggregationResultRow.size(); i++) {
            aggregationResultRow.add(AggregationResultSetSaveUtil.loadAggregationRow(inputStream));
        }
    }
    currentPosition = index;
    resultObject = (AggregationResultRow) aggregationResultRow.get(index);
}

Output:
     if (index >= length) {
-        return;
+        throw new IndexOutOfBoundsException("String_Node_Str" + index + "String_Node_Str" + length);
     }


Input:
public static String removeFromStart(String string, String... prefixes) {
    if (isEmpty(string))
        return string;
    for (String prefix : prefixes) if (string.startsWith(prefix))
        return string.substring(prefix.length());
    return string;
}

Output:
         return string;
-    for (String prefix : prefixes) if (string.startsWith(prefix))
+    for (String prefix : prefixes) if (prefix != null && string.startsWith(prefix))
         return string.substring(prefix.length());


Input:
public void mutableMethodsOutsideTransactions() {
    for (OrderedCollectionMutatorMethod method : OrderedCollectionMutatorMethod.values()) {
        Class<? extends Throwable> expected = IllegalStateException.class;
        if (collectionClass == ManagedCollection.REALMRESULTS || isSnapshot(collectionClass)) {
            switch(method) {
                case ADD_INDEX:
                case ADD_ALL_INDEX:
                case SET:
                case REMOVE_INDEX:
                    expected = UnsupportedOperationException.class;
                    break;
                default:
            }
        }
        try {
            switch(method) {
                case DELETE_INDEX:
                    collection.deleteFromRealm(0);
                    break;
                case DELETE_FIRST:
                    collection.deleteFirstFromRealm();
                    break;
                case DELETE_LAST:
                    collection.deleteLastFromRealm();
                    break;
                case ADD_INDEX:
                    collection.add(0, new AllJavaTypes());
                    break;
                case ADD_ALL_INDEX:
                    collection.addAll(0, Collections.singletonList(new AllJavaTypes()));
                    break;
                case SET:
                    collection.set(0, new AllJavaTypes());
                    break;
                case REMOVE_INDEX:
                    collection.remove(0);
                    break;
            }
            fail("String_Node_Str" + method);
        } catch (Throwable t) {
            if (!t.getClass().equals(expected)) {
                fail(method + "String_Node_Str" + t + "String_Node_Str" + expected);
            }
        }
    }
}

Output:
             fail("String_Node_Str" + method);
-        } catch (Throwable t) {
-            if (!t.getClass().equals(expected)) {
-                fail(method + "String_Node_Str" + t + "String_Node_Str" + expected);
-            }
+        } catch (IllegalStateException e) {
+            assertEquals(expected, e.getClass());
+        } catch (UnsupportedOperationException e) {
+            assertEquals(expected, e.getClass());
         }


Input:
protected Bitmap doInBackground(String... urls) {
    String urlDisplay = urls[0];
    if (urlDisplay == null)
        return null;
    Bitmap mIcon11 = null;
    try {
        InputStream in = new URL(urlDisplay).openStream();
        mIcon11 = BitmapFactory.decodeStream(in);
    } catch (Exception e) {
        Log.e(TAG, e.getMessage(), e);
    }
    return mIcon11;
}

Output:
     try {
-        InputStream in = new URL(urlDisplay).openStream();
-        mIcon11 = BitmapFactory.decodeStream(in);
+        BufferedInputStream in = new BufferedInputStream(new URL(urlDisplay).openStream());
+        final FileOutputStream fos = new FileOutputStream(this.appIconFile);
+        final byte[] writeBuffer = new byte[BUFFER_SIZE];
+        int byteCount;
+        do {
+            byteCount = in.read(writeBuffer);
+            if (byteCount > -1) {
+                fos.write(writeBuffer, 0, byteCount);
+                fos.flush();
+            }
+        } while (byteCount != -1);
+        fos.close();
+        mIcon11 = BitmapFactory.decodeFile(this.appIconFile.getAbsolutePath());
     } catch (Exception e) {


Input:
public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity) {
    if (!dense || entity == null)
        return;
    entity.motionY = Math.min(0.0, entity.motionY);
    if (entity.motionY < -0.05) {
        entity.motionY *= 0.05;
    }
    entity.motionX = Math.max(-0.05, Math.min(0.05, entity.motionX * 0.05));
    entity.motionY -= 0.05;
    entity.motionZ = Math.max(-0.05, Math.min(0.05, entity.motionZ * 0.05));
}

Output:
 public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity) {
-    if (!dense || entity == null)
+    if (!dense || entity == null) {
         return;


Input:
public void parse(IParserManager pm, IToken token) throws SyntaxError {
    int type = token.type();
    if (this.mode == NAME) {
        if (ParserUtil.isIdentifier(type)) {
            Name name = token.nameValue();
            if (name == Name.plus || name == Name.minus) {
                IToken next = token.next();
                if (ParserUtil.isIdentifier(next.type())) {
                    Variance v = name == Name.minus ? Variance.CONTRAVARIANT : Variance.CONTRAVARIANT;
                    this.variable = new TypeVariable(next, this.generic, next.nameValue(), v);
                    this.mode = TYPE_VARIABLE;
                    pm.skip();
                    return;
                }
            }
            this.variable = new TypeVariable(token, this.generic, token.nameValue(), Variance.INVARIANT);
            this.mode = TYPE_VARIABLE;
            return;
        }
        throw new SyntaxError(token, "String_Node_Str");
    }
    if (this.mode == TYPE_VARIABLE) {
        if (ParserUtil.isTerminator(type)) {
            if (this.variable != null) {
                this.generic.addTypeVariable(this.variable);
            }
            pm.popParser(true);
            return;
        }
        if (!ParserUtil.isIdentifier(type)) {
            if (this.variable != null) {
                this.generic.addTypeVariable(this.variable);
            }
            pm.popParser(true);
            throw new SyntaxError(token, "String_Node_Str");
        }
        Name name = token.nameValue();
        if (this.boundMode == 0) {
            if (name == Name.gtcolon) {
                pm.pushParser(new TypeParser(this));
                this.boundMode = LOWER;
                return;
            }
            if (name == Name.ltcolon) {
                pm.pushParser(new TypeParser(this));
                this.boundMode = UPPER;
                return;
            }
        } else if (this.boundMode == UPPER) {
            if (name == Name.amp) {
                pm.pushParser(new TypeParser(this));
                return;
            }
        }
        this.generic.addTypeVariable(this.variable);
        pm.popParser(true);
        return;
    }
}

Output:
                 if (ParserUtil.isIdentifier(next.type())) {
-                    Variance v = name == Name.minus ? Variance.CONTRAVARIANT : Variance.CONTRAVARIANT;
+                    Variance v = name == Name.minus ? Variance.CONTRAVARIANT : Variance.COVARIANT;
                     this.variable = new TypeVariable(next, this.generic, next.nameValue(), v);


Input:
private void doCommand(ExecutionContext inv, AdminCommand command, final Subject subject, final Job commandInstance) {
    CommandModel model;
    try {
        CommandModelProvider c = CommandModelProvider.class.cast(command);
        model = c.getModel();
    } catch (ClassCastException e) {
        model = new CommandModelImpl(command.getClass());
    }
    UploadedFilesManager ufm = null;
    ActionReport report = inv.report();
    ParameterMap parameters;
    final AdminCommandContext context = new AdminCommandContextImpl(logger, report, inv.inboundPayload(), inv.outboundPayload(), commandInstance.getEventBroker());
    context.setSubject(subject);
    List<RuntimeType> runtimeTypes = new ArrayList<RuntimeType>();
    FailurePolicy fp = null;
    Set<CommandTarget> targetTypesAllowed = new HashSet<CommandTarget>();
    ActionReport.ExitCode preSupplementalReturn = ActionReport.ExitCode.SUCCESS;
    ActionReport.ExitCode postSupplementalReturn = ActionReport.ExitCode.SUCCESS;
    CommandRunnerProgressHelper progressHelper = new CommandRunnerProgressHelper(command, model.getCommandName(), commandInstance, inv.progressStatusChild);
    boolean doReplication = false;
    if ((domain.getServers().getServer().size() > 1) || (!domain.getClusters().getCluster().isEmpty())) {
        doReplication = true;
    } else {
        logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
    }
    try {
        Collection<SupplementalCommand> suplementalCommands = supplementalExecutor.listSuplementalCommands(model.getCommandName());
        try {
            ufm = new UploadedFilesManager(inv.report, logger, inv.inboundPayload());
            if (inv.typedParams() != null) {
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                InjectionResolver<Param> injectionTarget = new DelegatedInjectionResolver(model, inv.typedParams(), ufm.optionNameToFileMap());
                if (injectParameters(model, command, injectionTarget, context).equals(ActionReport.ExitCode.SUCCESS)) {
                    inv.setReport(doCommand(model, command, context, progressHelper));
                }
                return;
            }
            parameters = inv.parameters();
            if (parameters == null) {
                parameters = new ParameterMap();
            }
            if (isSet(parameters, "String_Node_Str") || isSet(parameters, "String_Node_Str")) {
                BufferedReader in = getManPage(model.getCommandName(), model);
                String manPage = encodeManPage(in);
                if (manPage != null && isSet(parameters, "String_Node_Str")) {
                    inv.report().getTopMessagePart().addProperty("String_Node_Str", manPage);
                } else {
                    report.getTopMessagePart().addProperty(AdminCommandResponse.GENERATED_HELP, "String_Node_Str");
                    getHelp(command, report);
                }
                return;
            }
            try {
                if (!skipValidation(command)) {
                    validateParameters(model, parameters);
                }
            } catch (MultiException e) {
                Exception exception = e;
                for (Throwable cause : e.getErrors()) {
                    if (cause != null && (cause instanceof UnacceptableValueException)) {
                        exception = (Exception) cause;
                        break;
                    }
                }
                logger.log(Level.SEVERE, KernelLoggerInfo.invocationException, exception);
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                report.setMessage(exception.getMessage());
                report.setFailureCause(exception);
                ActionReport.MessagePart childPart = report.getTopMessagePart().addChild();
                childPart.setMessage(getUsageText(command, model));
                return;
            }
            MapInjectionResolver injectionMgr = new MapInjectionResolver(model, parameters, ufm.optionNameToFileMap());
            injectionMgr.setContext(context);
            if (!injectParameters(model, command, injectionMgr, context).equals(ActionReport.ExitCode.SUCCESS)) {
                return;
            }
            CommandSupport.init(habitat, command, context, commandInstance);
            final Map<String, Object> env = buildEnvMap(parameters);
            try {
                if (!commandSecurityChecker.authorize(context.getSubject(), env, command, context)) {
                    return;
                }
            } catch (SecurityException ex) {
                report.setFailureCause(ex);
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                return;
            } catch (Exception ex) {
                report.setFailureCause(ex);
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                return;
            }
            logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
            org.glassfish.api.admin.ExecuteOn clAnnotation = model.getClusteringAttributes();
            if (clAnnotation == null) {
                runtimeTypes.add(RuntimeType.DAS);
                runtimeTypes.add(RuntimeType.INSTANCE);
                fp = FailurePolicy.Error;
            } else {
                if (clAnnotation.value().length == 0) {
                    runtimeTypes.add(RuntimeType.DAS);
                    runtimeTypes.add(RuntimeType.INSTANCE);
                } else {
                    runtimeTypes.addAll(Arrays.asList(clAnnotation.value()));
                }
                if (clAnnotation.ifFailure() == null) {
                    fp = FailurePolicy.Error;
                } else {
                    fp = clAnnotation.ifFailure();
                }
            }
            TargetType tgtTypeAnnotation = command.getClass().getAnnotation(TargetType.class);
            if (runtimeTypes.contains(RuntimeType.SINGLE_INSTANCE)) {
                if (tgtTypeAnnotation != null) {
                    report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", model.getCommandName()));
                    return;
                }
                doReplication = false;
            }
            String targetName = parameters.getOne("String_Node_Str");
            if (targetName == null || model.getModelFor("String_Node_Str").getParam().obsolete()) {
                if (command instanceof DeploymentTargetResolver) {
                    targetName = ((DeploymentTargetResolver) command).getTarget(parameters);
                } else {
                    targetName = "String_Node_Str";
                }
            }
            logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", targetName));
            if (serverEnv.isDas()) {
                if (tgtTypeAnnotation != null) {
                    targetTypesAllowed.addAll(Arrays.asList(tgtTypeAnnotation.value()));
                }
                if (targetTypesAllowed.isEmpty()) {
                    targetTypesAllowed.add(CommandTarget.DAS);
                    targetTypesAllowed.add(CommandTarget.STANDALONE_INSTANCE);
                    targetTypesAllowed.add(CommandTarget.CLUSTER);
                    targetTypesAllowed.add(CommandTarget.CONFIG);
                }
                if (CommandTarget.DAS.isValid(habitat, targetName) && !runtimeTypes.contains(RuntimeType.DAS)) {
                    runtimeTypes.add(RuntimeType.DAS);
                }
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", runtimeTypes.toString()));
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", targetTypesAllowed.toString()));
                if ((!CommandTarget.DOMAIN.isValid(habitat, targetName)) && (domain.getServerNamed(targetName) == null) && (domain.getClusterNamed(targetName) == null) && (domain.getConfigNamed(targetName) == null)) {
                    report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", targetName));
                    return;
                }
                boolean isTargetValidType = false;
                Iterator<CommandTarget> it = targetTypesAllowed.iterator();
                while (it.hasNext()) {
                    if (it.next().isValid(habitat, targetName)) {
                        isTargetValidType = true;
                        break;
                    }
                }
                if (!isTargetValidType) {
                    StringBuilder validTypes = new StringBuilder();
                    it = targetTypesAllowed.iterator();
                    while (it.hasNext()) {
                        validTypes.append(it.next().getDescription()).append("String_Node_Str");
                    }
                    report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", targetName, model.getCommandName(), validTypes.toString()));
                    return;
                }
                if ((CommandTarget.CLUSTERED_INSTANCE.isValid(habitat, targetName)) && (!targetTypesAllowed.contains(CommandTarget.CLUSTERED_INSTANCE))) {
                    Cluster c = domain.getClusterForInstance(targetName);
                    report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", model.getCommandName(), targetName, c.getName()));
                    return;
                }
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
            }
            Lock lock = null;
            boolean lockTimedOut = false;
            try {
                lock = adminLock.getLock(command, "String_Node_Str");
                for (SupplementalCommand supplementalCommand : suplementalCommands) {
                    progressHelper.addProgressStatusToSupplementalCommand(supplementalCommand);
                }
                if (command instanceof UndoableCommand) {
                    UndoableCommand uCmd = (UndoableCommand) command;
                    logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                    if (!uCmd.prepare(context, parameters).equals(ActionReport.ExitCode.SUCCESS)) {
                        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                        report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str" + "String_Node_Str", model.getCommandName(), report.getMessage()));
                        return;
                    }
                }
                ClusterOperationUtil.clearInstanceList();
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                preSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.Before, context, parameters, ufm.optionNameToFileMap());
                if (preSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
                    report.setActionExitCode(preSupplementalReturn);
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                    return;
                }
                if ((runtimeTypes.contains(RuntimeType.ALL)) || (serverEnv.isDas() && (CommandTarget.DOMAIN.isValid(habitat, targetName) || runtimeTypes.contains(RuntimeType.DAS))) || runtimeTypes.contains(RuntimeType.SINGLE_INSTANCE) || (serverEnv.isInstance() && runtimeTypes.contains(RuntimeType.INSTANCE))) {
                    logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                    report = doCommand(model, command, context, progressHelper);
                    inv.setReport(report);
                }
                if (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) {
                    logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                    postSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.After, context, parameters, ufm.optionNameToFileMap());
                    if (postSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
                        report.setActionExitCode(postSupplementalReturn);
                        report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                        return;
                    }
                }
            } catch (AdminCommandLockTimeoutException ex) {
                lockTimedOut = true;
                String lockTime = formatSuspendDate(ex.getTimeOfAcquisition());
                String logMsg = "String_Node_Str" + model.getCommandName() + "String_Node_Str" + "String_Node_Str" + lockTime + "String_Node_Str";
                String msg = adminStrings.getLocalString("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", lockTime);
                report.setMessage(msg);
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            } catch (AdminCommandLockException ex) {
                lockTimedOut = true;
                String lockTime = formatSuspendDate(ex.getTimeOfAcquisition());
                String lockMsg = ex.getMessage();
                String logMsg;
                logMsg = "String_Node_Str" + model.getCommandName() + "String_Node_Str" + "String_Node_Str" + lockTime;
                if (lockMsg != null && !lockMsg.isEmpty()) {
                    logMsg += "String_Node_Str" + lockMsg;
                }
                String msg = adminStrings.getLocalString("String_Node_Str", "String_Node_Str" + "String_Node_Str", lockTime);
                if (lockMsg != null && !lockMsg.isEmpty()) {
                    msg += "String_Node_Str" + adminStrings.getLocalString("String_Node_Str", "String_Node_Str") + "String_Node_Str" + lockMsg;
                }
                report.setMessage(msg);
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            } finally {
                if (lock != null && lockTimedOut == false) {
                    lock.unlock();
                }
            }
        } catch (Exception ex) {
            logger.log(Level.SEVERE, KernelLoggerInfo.invocationException, ex);
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            report.setMessage(ex.getMessage());
            report.setFailureCause(ex);
            ActionReport.MessagePart childPart = report.getTopMessagePart().addChild();
            childPart.setMessage(getUsageText(command, model));
            return;
        }
        if (processEnv.getProcessType().isEmbedded()) {
            return;
        }
        if (preSupplementalReturn == ActionReport.ExitCode.WARNING || postSupplementalReturn == ActionReport.ExitCode.WARNING) {
            report.setActionExitCode(ActionReport.ExitCode.WARNING);
        }
        if (doReplication && (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) && (serverEnv.isDas()) && (runtimeTypes.contains(RuntimeType.INSTANCE) || runtimeTypes.contains(RuntimeType.ALL))) {
            logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
            ClusterExecutor executor = null;
            try {
                if (model.getClusteringAttributes() != null && model.getClusteringAttributes().executor() != null) {
                    executor = habitat.getService(model.getClusteringAttributes().executor());
                } else {
                    executor = habitat.getService(ClusterExecutor.class, "String_Node_Str");
                }
            } catch (UnsatisfiedDependencyException usdepex) {
                logger.log(Level.WARNING, KernelLoggerInfo.cantGetClusterExecutor, usdepex);
            }
            if (executor != null) {
                report.setActionExitCode(executor.execute(model.getCommandName(), command, context, parameters));
                if (report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                } else {
                    if (!FailurePolicy.applyFailurePolicy(fp, report.getActionExitCode()).equals(ActionReport.ExitCode.FAILURE)) {
                        logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                        ActionReport.ExitCode afterReplicationSupplementalReturn = supplementalExecutor.execute(suplementalCommands, Supplemental.Timing.AfterReplication, context, parameters, ufm.optionNameToFileMap());
                        if (afterReplicationSupplementalReturn.equals(ActionReport.ExitCode.FAILURE)) {
                            report.setActionExitCode(afterReplicationSupplementalReturn);
                            report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
                            return;
                        }
                    }
                }
            }
        }
        if (report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
            if (command instanceof UndoableCommand) {
                UndoableCommand uCmd = (UndoableCommand) command;
                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", inv.name()));
                uCmd.undo(context, parameters, ClusterOperationUtil.getCompletedInstances());
            }
        } else {
            if ("String_Node_Str".equals(model.getCommandName())) {
                state.addServerToStateService(parameters.getOne("String_Node_Str"));
            }
            if ("String_Node_Str".equals(model.getCommandName())) {
                state.removeInstanceFromStateService(parameters.getOne("String_Node_Str"));
            }
        }
    } finally {
        if (ufm != null) {
            ufm.close();
        }
    }
}

Output:
                     report.setActionExitCode(preSupplementalReturn);
-                    report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
+                    if (!StringUtils.ok(report.getTopMessagePart().getMessage())) {
+                        report.setMessage(adminStrings.getLocalString("String_Node_Str", "String_Node_Str"));
+                    }
                     return;


Input:
public void produceMobi(Path currentPath, String kindlegenDir) {
    try {
        indikatorService.startCycle();
        ProcessExecutor processExecutor = new ProcessExecutor();
        processExecutor.readOutput(true);
        processExecutor.directory(new File(kindlegenDir));
        String message = processExecutor.command("String_Node_Str", currentPath.resolve("String_Node_Str").toString()).execute().outputUTF8();
        logger.info(message);
        indikatorService.completeCycle();
        Platform.runLater(() -> {
            asciiDocController.getRecentFiles().remove(currentPath.resolve("String_Node_Str").toString());
            asciiDocController.getRecentFiles().add(0, currentPath.resolve("String_Node_Str").toString());
        });
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    } finally {
        indikatorService.hideIndikator();
    }
}

Output:
         processExecutor.readOutput(true);
-        processExecutor.directory(new File(kindlegenDir));
-        String message = processExecutor.command("String_Node_Str", currentPath.resolve("String_Node_Str").toString()).execute().outputUTF8();
+        Path kindleGenPath = Paths.get(kindlegenDir);
+        String message = processExecutor.command(kindleGenPath.resolve("String_Node_Str").toString(), currentPath.resolve("String_Node_Str").toString()).execute().outputUTF8();
         logger.info(message);


Input:
public void addInterruptListener(InterruptListener listener) {
    super.addInterruptListener(listener);
    if (areInterruptsEnabled() && interruptControl.isRunning()) {
        interruptControl.start();
    }
}

Output:
     super.addInterruptListener(listener);
-    if (areInterruptsEnabled() && interruptControl.isRunning()) {
+    if (areInterruptsEnabled() && !interruptControl.isRunning()) {
         interruptControl.start();


Input:
public static Event createSpongeEvent(net.minecraftforge.fml.common.eventhandler.Event forgeEvent) {
    if (forgeEvent instanceof BlockEvent.MultiPlaceEvent) {
        return createChangeBlockEventPlace((BlockEvent.MultiPlaceEvent) forgeEvent);
    }
    if (forgeEvent instanceof BlockEvent.PlaceEvent) {
        return createChangeBlockEventPlace((BlockEvent.PlaceEvent) forgeEvent);
    }
    if (forgeEvent instanceof BlockEvent.BreakEvent) {
        return createChangeBlockEventPre((BlockEvent.BreakEvent) forgeEvent);
    }
    if (forgeEvent instanceof ServerChatEvent) {
        return createMessageChannelEventChat((ServerChatEvent) forgeEvent);
    }
    if (forgeEvent instanceof PlayerSleepInBedEvent) {
        return createSleepingEventPre((PlayerSleepInBedEvent) forgeEvent);
    }
    if (forgeEvent instanceof ChunkEvent.Load) {
        return createLoadChunkEvent((ChunkEvent.Load) forgeEvent);
    }
    if (forgeEvent instanceof ChunkEvent.Unload) {
        return createUnloadChunkEvent((ChunkEvent.Unload) forgeEvent);
    }
    return null;
}

Output:
 public static Event createSpongeEvent(net.minecraftforge.fml.common.eventhandler.Event forgeEvent) {
-    if (forgeEvent instanceof BlockEvent.MultiPlaceEvent) {
-        return createChangeBlockEventPlace((BlockEvent.MultiPlaceEvent) forgeEvent);
-    }
-    if (forgeEvent instanceof BlockEvent.PlaceEvent) {
-        return createChangeBlockEventPlace((BlockEvent.PlaceEvent) forgeEvent);
-    }
-    if (forgeEvent instanceof BlockEvent.BreakEvent) {
-        return createChangeBlockEventPre((BlockEvent.BreakEvent) forgeEvent);
-    }
-    if (forgeEvent instanceof ServerChatEvent) {
-        return createMessageChannelEventChat((ServerChatEvent) forgeEvent);
-    }
-    if (forgeEvent instanceof PlayerSleepInBedEvent) {
-        return createSleepingEventPre((PlayerSleepInBedEvent) forgeEvent);
-    }
-    if (forgeEvent instanceof ChunkEvent.Load) {
-        return createLoadChunkEvent((ChunkEvent.Load) forgeEvent);
-    }
-    if (forgeEvent instanceof ChunkEvent.Unload) {
-        return createUnloadChunkEvent((ChunkEvent.Unload) forgeEvent);
-    }
-    return null;
+    return propgateCancellation(createSpongeEventImpl(forgeEvent), forgeEvent);
 }


Input:
public View configureView(View view) {
    final CommentUserNoteBlockHolder noteBlockHolder = (CommentUserNoteBlockHolder) view.getTag();
    noteBlockHolder.nameTextView.setText(getNoteText().toString());
    if (hasImageMediaItem()) {
        noteBlockHolder.avatarImageView.setImageUrl(getNoteMediaItem().optString("String_Node_Str", "String_Node_Str"), WordPress.imageLoader);
        if (!TextUtils.isEmpty(getUserUrl())) {
            noteBlockHolder.avatarImageView.setOnTouchListener(mOnGravatarTouchListener);
        } else {
            noteBlockHolder.avatarImageView.setOnTouchListener(null);
        }
    } else {
        noteBlockHolder.avatarImageView.setImageResource(R.drawable.placeholder);
        noteBlockHolder.avatarImageView.setOnTouchListener(null);
    }
    if (mTextViewIndent == 0) {
        Context context = view.getContext();
        if (context != null) {
            mTextViewIndent = context.getResources().getDimensionPixelSize(R.dimen.avatar_sz_small) + context.getResources().getDimensionPixelSize(R.dimen.margin_medium);
        }
    }
    CommentUtils.indentTextViewFirstLine(noteBlockHolder.commentTextView, NotificationUtils.getSpannableTextFromIndices(getNoteData().optJSONObject("String_Node_Str"), getOnNoteBlockTextClickListener()), mTextViewIndent);
    return view;
}

Output:
         if (context != null) {
-            mTextViewIndent = context.getResources().getDimensionPixelSize(R.dimen.avatar_sz_small) + context.getResources().getDimensionPixelSize(R.dimen.margin_medium);
+            mTextViewIndent = context.getResources().getDimensionPixelSize(R.dimen.comment_avatar_size) + DisplayUtils.dpToPx(context, 6);
         }


Input:
public <T> T executeScriptsForEvent(String event, String basePath, Map<String, Object> payload, Class<T> clazz) {
    List<ScriptPathNameHash> activePaths = getActiveScriptsForEvent(event, basePath, false);
    T res = null;
    Map<String, Object> input = new HashMap<>(payload);
    input.put("String_Node_Str", event);
    for (ScriptPathNameHash activePath : activePaths) {
        String path = activePath.getPath();
        String name = activePath.getName();
        res = scriptingExecutionService.executeScript(path, name, activePath.getHash(), () -> getScript(path, name) + "String_Node_Str", input, clazz);
        input.put("String_Node_Str", res);
    }
    return res;
}

Output:
         String name = activePath.getName();
-        res = scriptingExecutionService.executeScript(path, name, activePath.getHash(), () -> getScript(path, name) + "String_Node_Str", input, clazz);
+        res = scriptingExecutionService.executeScript(name, activePath.getHash(), () -> getScript(path, name) + "String_Node_Str", input, clazz);
         input.put("String_Node_Str", res);


Input:
public ProjectBuildingRequest getRequest() {
    return request;
}

Output:
 public ProjectBuildingRequest getRequest() {
-    return request;
+    try {
+        String localRepositoryPath = OSUtils.getUserHomeDir().getAbsolutePath() + "String_Node_Str";
+        request = new DefaultProjectBuildingRequest();
+        ArtifactRepository localRepository = new MavenArtifactRepository("String_Node_Str", new File(localRepositoryPath).toURI().toURL().toString(), container.lookup(ArtifactRepositoryLayout.class), new ArtifactRepositoryPolicy(true, ArtifactRepositoryPolicy.UPDATE_POLICY_NEVER, ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN), new ArtifactRepositoryPolicy(true, ArtifactRepositoryPolicy.UPDATE_POLICY_NEVER, ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN));
+        request.setLocalRepository(localRepository);
+        request.setRemoteRepositories(new ArrayList<ArtifactRepository>());
+        DefaultRepositorySystemSession repositorySession = new DefaultRepositorySystemSession();
+        repositorySession.setLocalRepositoryManager(new SimpleLocalRepositoryManager(localRepositoryPath));
+        repositorySession.setOffline(true);
+        request.setRepositorySession(repositorySession);
+        request.setProcessPlugins(false);
+        request.setPluginArtifactRepositories(Arrays.asList(localRepository));
+        request.setResolveDependencies(true);
+        return request;
+    } catch (Exception e) {
+        throw new ProjectModelException("String_Node_Str", e);
+    }
 }


Input:
public static long[] deserializeLong(List<MPIBuffer> buffers, int byteLength) {
    int noOfDoubles = byteLength / 8;
    long[] returnDoubles = new long[noOfDoubles];
    int bufferIndex = 0;
    for (int i = 0; i < noOfDoubles; i++) {
        ByteBuffer byteBuffer = buffers.get(bufferIndex).getByteBuffer();
        int remaining = byteBuffer.remaining();
        if (remaining > 8) {
            returnDoubles[i] = byteBuffer.getLong();
        } else {
            bufferIndex = getReadBuffer(buffers, 8, bufferIndex);
            if (bufferIndex < 0) {
                throw new RuntimeException("String_Node_Str");
            }
        }
    }
    return returnDoubles;
}

Output:
         int remaining = byteBuffer.remaining();
-        if (remaining > 8) {
+        if (remaining >= 8) {
             returnDoubles[i] = byteBuffer.getLong();


Input:
private void checkValidArrayType(String paramId, Object value, ElementCache elementCache) throws InPUTException {
    Value<?> current = elementCache.get(paramId);
    Object flag = value;
    if (current != null && current.getValue() != null) {
        Object currentValue = current.getInputValue(null);
        while (currentValue.getClass().isArray()) {
            currentValue = Array.get(currentValue, 0);
            if (!flag.getClass().isArray())
                throw new InPUTException("String_Node_Str" + paramId + "String_Node_Str");
            flag = Array.get(flag, 0);
        }
        if (flag.getClass().isArray())
            throw new InPUTException("String_Node_Str" + paramId + "String_Node_Str");
    }
}

Output:
         Object currentValue = current.getInputValue(null);
-        while (currentValue.getClass().isArray()) {
-            currentValue = Array.get(currentValue, 0);
-            if (!flag.getClass().isArray())
-                throw new InPUTException("String_Node_Str" + paramId + "String_Node_Str");
-            flag = Array.get(flag, 0);
-        }
-        if (flag.getClass().isArray())
-            throw new InPUTException("String_Node_Str" + paramId + "String_Node_Str");
+        checkDimensionalityValidity(paramId, newValue, currentValue);
     }


Input:
private void refreshPluginVersionViews() {
    String pluginVersion = TextUtils.isEmpty(mPlugin.getInstalledVersion()) ? "String_Node_Str" : mPlugin.getInstalledVersion();
    String availableVersion = mPlugin.getWPOrgPluginVersion();
    String versionTopText = "String_Node_Str";
    String versionBottomText = "String_Node_Str";
    if (mPlugin.isInstalled()) {
        if (PluginUtils.isUpdateAvailable(mPlugin)) {
            versionTopText = String.format(getString(R.string.plugin_available_version), availableVersion);
            versionBottomText = String.format(getString(R.string.plugin_installed_version), pluginVersion);
        } else {
            versionTopText = String.format(getString(R.string.plugin_version), pluginVersion);
        }
    } else if (!TextUtils.isEmpty(availableVersion)) {
        versionTopText = String.format(getString(R.string.plugin_version), availableVersion);
    }
    mVersionTopTextView.setText(versionTopText);
    mVersionBottomTextView.setVisibility(TextUtils.isEmpty(versionBottomText) ? View.GONE : View.VISIBLE);
    mVersionBottomTextView.setText(versionBottomText);
    refreshUpdateVersionViews();
}

Output:
     String versionBottomText = "String_Node_Str";
-    if (mPlugin.isInstalled()) {
+    if (mPlugin.isInstalled() && isNotAutoManaged()) {
         if (PluginUtils.isUpdateAvailable(mPlugin)) {


Input:
public void extractVolume(UploadVO uploadVolumeObj, HostVO sserver, VolumeVO volume, String url, Long dataCenterId, String installPath, long eventId, long asyncJobId, AsyncJobManager asyncMgr) {
    uploadVolumeObj.setUploadState(Upload.Status.NOT_UPLOADED);
    _uploadDao.update(uploadVolumeObj.getId(), uploadVolumeObj);
    start();
    UploadCommand ucmd = new UploadCommand(url, volume.getId(), volume.getSize(), installPath, Type.VOLUME);
    UploadListener ul = new UploadListener(sserver, _timer, _uploadDao, uploadVolumeObj.getId(), this, ucmd, volume.getAccountId(), volume.getName(), Type.VOLUME, eventId, asyncJobId, asyncMgr);
    _listenerMap.put(uploadVolumeObj, ul);
    long result = send(sserver.getId(), ucmd, ul);
    if (result == -1) {
        s_logger.warn("String_Node_Str" + volume.getName() + "String_Node_Str" + sserver.getName() + "String_Node_Str" + url);
        ul.setDisconnected();
        ul.scheduleStatusCheck(RequestType.GET_OR_RESTART);
    }
}

Output:
     UploadCommand ucmd = new UploadCommand(url, volume.getId(), volume.getSize(), installPath, Type.VOLUME);
-    UploadListener ul = new UploadListener(sserver, _timer, _uploadDao, uploadVolumeObj.getId(), this, ucmd, volume.getAccountId(), volume.getName(), Type.VOLUME, eventId, asyncJobId, asyncMgr);
+    UploadListener ul = new UploadListener(sserver, _timer, _uploadDao, uploadVolumeObj, this, ucmd, volume.getAccountId(), volume.getName(), Type.VOLUME, eventId, asyncJobId, asyncMgr);
     _listenerMap.put(uploadVolumeObj, ul);


Input:
public ExecutionResult prepareCommand(NetworkElementCommand cmd) {
    cmd.setRouterAccessIp(ROUTER_IP);
    _currentCmd = cmd;
    if (cmd instanceof IpAssocVpcCommand) {
        return prepareNetworkElementCommand((IpAssocVpcCommand) cmd);
    } else if (cmd instanceof IpAssocCommand) {
        return prepareNetworkElementCommand((IpAssocCommand) cmd);
    } else if (cmd instanceof SetupGuestNetworkCommand) {
        return prepareNetworkElementCommand((SetupGuestNetworkCommand) cmd);
    } else if (cmd instanceof SetSourceNatCommand) {
        return prepareNetworkElementCommand((SetSourceNatCommand) cmd);
    } else if (cmd instanceof SetNetworkACLCommand) {
        return prepareNetworkElementCommand((SetNetworkACLCommand) cmd);
    }
    return new ExecutionResult(true, null);
}

Output:
 public ExecutionResult prepareCommand(NetworkElementCommand cmd) {
-    cmd.setRouterAccessIp(ROUTER_IP);
+    cmd.setRouterAccessIp(ROUTERIP);
     _currentCmd = cmd;


Input:
public void write(Message message) throws IOException {
    byte[] messageBytes = message.toByteString().toByteArray();
    int size = messageBytes.length;
    final int INT_SIZE = 4;
    ByteBuffer buffer = ByteBuffer.allocate(INT_SIZE);
    byte[] messageBytesSize = buffer.putInt(size).array();
    outputStream.write(messageBytesSize);
    outputStream.write(messageBytes);
}

Output:
     int size = messageBytes.length;
-    final int INT_SIZE = 4;
-    ByteBuffer buffer = ByteBuffer.allocate(INT_SIZE);
-    byte[] messageBytesSize = buffer.putInt(size).array();
+    final int LONG_SIZE = 8;
+    ByteBuffer buffer = ByteBuffer.allocate(LONG_SIZE);
+    byte[] messageBytesSize = buffer.putLong(size).array();
     outputStream.write(messageBytesSize);


Input:
public boolean noAttackers() {
    if (groups.isEmpty() || getAttackers().isEmpty())
        return true;
    return false;
}

Output:
 public boolean noAttackers() {
-    if (groups.isEmpty() || getAttackers().isEmpty())
+    if (groups.isEmpty() || getAttackers().isEmpty()) {
         return true;


Input:
public boolean isShifted() {
    if (isPopupShowing())
        return mMiniKeyboard.isShifted();
    return mKeyboard != null && mKeyboard.isShifted();
}

Output:
 public boolean isShifted() {
-    if (isPopupShowing())
+    if (mMiniKeyboardPopup.isShowing())
         return mMiniKeyboard.isShifted();


Input:
public boolean sameAs(AEColor color, ItemStack comparableItem) {
    ItemStack is = colors[color.ordinal()];
    if (comparableItem == null)
        return false;
    return comparableItem.getItem() == is.getItem() && comparableItem.getItemDamage() == is.getItemDamage();
}

Output:
 public boolean sameAs(AEColor color, ItemStack comparableItem) {
-    ItemStack is = colors[color.ordinal()];
+    ItemStackSrc is = colors[color.ordinal()];
     if (comparableItem == null)


Input:
private void processAllocation(Attributes atts) {
    Language lang = scope.getLanguage(governingLoader.getLanguage());
    SSAInstructionFactory insts = lang.instructionFactory();
    String classString = atts.getValue(A_CLASS);
    final TypeReference type = TypeReference.findOrCreate(governingLoader, TypeName.string2TypeName(classString));
    String defVar = atts.getValue(A_DEF);
    if (symbolTable.keySet().contains(defVar)) {
        Assertions.UNREACHABLE("String_Node_Str" + defVar + "String_Node_Str" + governingMethod);
    }
    if (defVar == null) {
        defVar = "String_Node_Str" + nextLocal;
    }
    int defNum = nextLocal;
    symbolTable.put(defVar, new Integer(nextLocal++));
    NewSiteReference ref = NewSiteReference.make(governingMethod.getNextProgramCounter(), type);
    SSANewInstruction a = null;
    if (type.isArrayType()) {
        String size = atts.getValue(A_SIZE);
        Assertions.productionAssertion(size != null);
        Integer sNumber = symbolTable.get(size);
        Assertions.productionAssertion(sNumber != null);
        Assertions.productionAssertion(type.getDerivedMask() == ArrayMask || type.getDerivedMask() == ((ArrayMask << 2) | PrimitiveMask));
        a = insts.NewInstruction(defNum, ref, new int[] { sNumber.intValue() });
    } else {
        a = insts.NewInstruction(defNum, ref);
    }
    governingMethod.addStatement(a);
}

Output:
         Assertions.productionAssertion(sNumber != null);
-        Assertions.productionAssertion(type.getDerivedMask() == ArrayMask || type.getDerivedMask() == ((ArrayMask << 2) | PrimitiveMask));
+        Assertions.productionAssertion(type.getDerivedMask() == ArrayMask || type.getDerivedMask() == ((ArrayMask << ElementBits) | PrimitiveMask));
         a = insts.NewInstruction(defNum, ref, new int[] { sNumber.intValue() });


Input:
private static MetricsContext createMetricsContext(Program program, String runId, MetricsCollectionService service, WorkflowProgramInfo workflowProgramInfo) {
    Map<String, String> tags = Maps.newHashMap();
    tags.putAll(getMetricsContext(program, runId));
    MetricsContext programMetricsContext = service.getContext(tags);
    if (workflowProgramInfo == null) {
        return programMetricsContext;
    }
    tags = Maps.newHashMap();
    tags.put(Constants.Metrics.Tag.NAMESPACE, program.getNamespaceId());
    tags.put(Constants.Metrics.Tag.APP, program.getApplicationId());
    tags.put(Constants.Metrics.Tag.WORKFLOW, workflowProgramInfo.getName());
    tags.put(Constants.Metrics.Tag.RUN_ID, workflowProgramInfo.getRunId().getId());
    tags.put(Constants.Metrics.Tag.NODE, workflowProgramInfo.getNodeId());
    return new MultiMetricsContext(programMetricsContext, service.getContext(tags));
}

Output:
     tags.putAll(getMetricsContext(program, runId));
-    MetricsContext programMetricsContext = service.getContext(tags);
-    if (workflowProgramInfo == null) {
-        return programMetricsContext;
+    if (workflowProgramInfo != null) {
+        tags.put(Constants.Metrics.Tag.WORKFLOW, workflowProgramInfo.getName());
+        tags.put(Constants.Metrics.Tag.WORKFLOW_RUN_ID, workflowProgramInfo.getRunId().getId());
+        tags.put(Constants.Metrics.Tag.NODE, workflowProgramInfo.getNodeId());
     }


Input:
public static void flushPrintWriters() {
    if (receivedMessagePrintWriter != null) {
        receivedMessagePrintWriter.flush();
    }
    if (statisticsPrintWriter != null) {
        statisticsPrintWriter.flush();
    }
}

Output:
 public static void flushPrintWriters() {
-    if (receivedMessagePrintWriter != null) {
+    if (null != receivedMessagePrintWriter) {
         receivedMessagePrintWriter.flush();


Input:
private void indexItem(ItemMetadataProxy item) throws BrowseException {
    Map<String, String> itemMDMap = new HashMap<String, String>();
    try {
        dao.deleteCommunityMappings(item.getID());
        Map<Integer, String> sortMap = getSortValues(item, itemMDMap);
        if (item.isArchived() && !item.isWithdrawn()) {
            if (!dao.updateIndex(BrowseIndex.getItemBrowseIndex().getTableName(), item.getID(), sortMap)) {
                removeIndex(item.getID(), BrowseIndex.getWithdrawnBrowseIndex().getTableName());
                dao.insertIndex(BrowseIndex.getItemBrowseIndex().getTableName(), item.getID(), sortMap);
            }
            dao.insertCommunityMappings(item.getID());
        } else if (item.isWithdrawn()) {
            if (!dao.updateIndex(BrowseIndex.getWithdrawnBrowseIndex().getTableName(), item.getID(), sortMap)) {
                removeIndex(item.getID(), BrowseIndex.getItemBrowseIndex().getTableName());
                dao.insertIndex(BrowseIndex.getWithdrawnBrowseIndex().getTableName(), item.getID(), sortMap);
            }
        } else {
            removeIndex(item.getID(), BrowseIndex.getItemBrowseIndex().getTableName());
            removeIndex(item.getID(), BrowseIndex.getWithdrawnBrowseIndex().getTableName());
        }
        for (int i = 0; i < bis.length; i++) {
            log.debug("String_Node_Str" + item.getID() + "String_Node_Str" + bis[i].getTableName());
            if (bis[i].isMetadataIndex()) {
                boolean itemMapped = false;
                if (item.isArchived() && !item.isWithdrawn()) {
                    for (int mdIdx = 0; mdIdx < bis[i].getMetadataCount(); mdIdx++) {
                        String[] md = bis[i].getMdBits(mdIdx);
                        DCValue[] values = item.getMetadata(md[0], md[1], md[2], Item.ANY);
                        if (values != null) {
                            for (int x = 0; x < values.length; x++) {
                                if (StringUtils.isEmpty(values[x].value)) {
                                    log.error("String_Node_Str" + item.getID() + "String_Node_Str" + values[x].schema + "String_Node_Str" + values[x].element + (values[x].qualifier == null ? "String_Node_Str" : "String_Node_Str" + values[x].qualifier));
                                } else {
                                    String nVal = OrderFormat.makeSortString(values[x].value, values[x].language, bis[i].getDataType());
                                    int distinctID = dao.getDistinctID(bis[i].getDistinctTableName(), values[x].value, nVal);
                                    if (!dao.updateDistinctMapping(bis[i].getMapTableName(), item.getID(), distinctID))
                                        dao.createDistinctMapping(bis[i].getMapTableName(), item.getID(), distinctID);
                                    itemMapped = true;
                                }
                            }
                        }
                    }
                }
                if (!itemMapped)
                    removeIndex(item.getID(), bis[i].getMapTableName());
            }
        }
    } catch (SQLException e) {
        log.error("String_Node_Str", e);
        throw new BrowseException(e);
    }
}

Output:
     try {
-        dao.deleteCommunityMappings(item.getID());
+        boolean reqCommunityMappings = false;
         Map<Integer, String> sortMap = getSortValues(item, itemMDMap);


Input:
private void printStructure(Structure struc) {
    System.out.println(struc);
    String pdbid = struc.getPDBCode();
    for (int i = 0; i < struc.nrModels(); i++) {
        for (Chain ch : struc.getModel(i)) {
            if (!ch.getChainID().equals("String_Node_Str"))
                continue;
            System.out.println(pdbid + "String_Node_Str" + ch.getChainID() + "String_Node_Str" + ch.getAtomSequence());
            System.out.println(pdbid + "String_Node_Str" + ch.getChainID() + "String_Node_Str" + ch.getSeqResSequence());
            List<Group> group = ch.getSeqResGroups();
            int seqPos = 0;
            for (Group gp : group) {
                System.out.println(ch.getChainID() + "String_Node_Str" + seqPos + "String_Node_Str" + gp.getResidueNumber() + "String_Node_Str" + gp.getPDBName() + "String_Node_Str" + gp.getType());
                seqPos++;
            }
        }
    }
}

Output:
         for (Chain ch : struc.getModel(i)) {
-            if (!ch.getChainID().equals("String_Node_Str"))
+            if (!ch.getName().equals("String_Node_Str"))
                 continue;


Input:
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    traceRequest(req);
    String pathInfo = req.getPathInfo();
    IPath path = new Path(pathInfo == null ? "String_Node_Str" : pathInfo);
    if (path.segmentCount() > 0) {
        String hostedHost = path.segment(0);
        URL url = this.getMappedURL(path.removeFirstSegments(1));
        serve(req, resp, url);
    } else {
        super.doGet(req, resp);
    }
}

Output:
         String hostedHost = path.segment(0);
-        URL url = this.getMappedURL(path.removeFirstSegments(1));
-        serve(req, resp, url);
+        HostedSite site = HostingActivator.getDefault().getHostingService().get(hostedHost);
+        if (site != null) {
+            URL url = getMappedURL(site, path.removeFirstSegments(1).makeAbsolute());
+            serve(req, resp, url);
+        } else {
+        }
     } else {


Input:
public void deleteLast() {
    final int size = size();
    if (size > 0) {
        final int lastPos = size - 1;
        char lastChar = mTypedWord.charAt(lastPos);
        mCodes.remove(lastPos);
        mTypedWord.deleteCharAt(lastPos);
        if (Character.isUpperCase(lastChar))
            mCapsCount--;
    }
    if (size() == 0) {
        mIsFirstCharCapitalized = false;
    }
    if (mTrailingSingleQuotesCount > 0) {
        --mTrailingSingleQuotesCount;
    } else {
        for (int i = mTypedWord.offsetByCodePoints(mTypedWord.length(), -1); i >= 0; i = mTypedWord.offsetByCodePoints(i, -1)) {
            if (Keyboard.CODE_SINGLE_QUOTE != mTypedWord.codePointAt(i))
                break;
            ++mTrailingSingleQuotesCount;
        }
    }
    mAutoCorrection = null;
}

Output:
     } else {
-        for (int i = mTypedWord.offsetByCodePoints(mTypedWord.length(), -1); i >= 0; i = mTypedWord.offsetByCodePoints(i, -1)) {
+        int i = mTypedWord.length();
+        while (i > 0) {
+            i = mTypedWord.offsetByCodePoints(i, -1);
             if (Keyboard.CODE_SINGLE_QUOTE != mTypedWord.codePointAt(i))


Input:
public void run() {
    try {
        IWorkbenchWindow ww = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        ReceiveAuthorizeRequestDialog authRequest = new ReceiveAuthorizeRequestDialog(ww.getShell(), fromID.getName(), localUser.getName());
        authRequest.setBlockOnOpen(true);
        authRequest.open();
        int res = authRequest.getButtonPressed();
        if (res == ReceiveAuthorizeRequestDialog.AUTHORIZE_AND_ADD) {
            if (presenceSender != null) {
                presenceSender.sendPresenceUpdate(localUser, fromID, new Presence(IPresence.Type.SUBSCRIBED));
                if (rosterView != null) {
                    String[] groupNames = rosterView.getGroupNames();
                    List g = Arrays.asList(groupNames);
                    String selectedGroup = rosterView.getSelectedGroupName();
                    int selected = (selectedGroup == null) ? -1 : g.indexOf(selectedGroup);
                    AddBuddyDialog sg = new AddBuddyDialog(ww.getShell(), fromID.getName(), groupNames, selected);
                    sg.open();
                    if (sg.getReturnCode() == Window.OK) {
                        String group = sg.getGroup();
                        String user = sg.getUser();
                        String nickname = sg.getNickname();
                        sg.close();
                        if (!g.contains(group)) {
                            rosterView.addGroup(group);
                        }
                        presenceSender.sendRosterAdd(localUser, user, nickname, new String[] { group });
                    }
                }
            }
        } else if (res == ReceiveAuthorizeRequestDialog.AUTHORIZE_ID) {
            if (presenceSender != null) {
                presenceSender.sendPresenceUpdate(localUser, fromID, new Presence(IPresence.Type.SUBSCRIBED));
            }
        } else if (res == ReceiveAuthorizeRequestDialog.REFUSE_ID) {
            System.out.println("String_Node_Str");
        } else {
            System.out.println("String_Node_Str");
        }
    } catch (Exception e) {
        IStatus status = new Status(IStatus.ERROR, ClientPlugin.PLUGIN_ID, IStatus.OK, "String_Node_Str", e);
        ClientPlugin.getDefault().getLog().log(status);
    }
}

Output:
                     sg.open();
-                    if (sg.getReturnCode() == Window.OK) {
+                    if (sg.getResult() == Window.OK) {
                         String group = sg.getGroup();


Input:
public boolean setLoggerLevel(final String name, final String level) {
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger logger = lc.getLogger(name);
    if (logger != null) {
        logger.setLevel(Level.valueOf(level));
    }
    return logger != null;
}

Output:
     if (logger != null) {
-        logger.setLevel(Level.valueOf(level));
+        logger.setLevel(level.getLevel());
     }


Input:
public void newRevision(final Long poid, final Long roid, Long soid, String serviceIdentifier, String profileIdentifier, String token, String apiUrl) throws UserException, ServerException {
    ServiceMapInterface serviceMapInterface = new ServiceMap(bimServer, null, AccessMethod.JSON);
    serviceMapInterface.add(Bimsie1RemoteServiceInterface.class, internalRemoteServiceInterfaces.get(serviceIdentifier));
    final InternalChannel internalChannel = new InternalChannel(bimServer.getServiceFactory(), bimServer.getServicesMap());
    try {
        internalChannel.connect(new SimpleTokenHolder());
    } catch (ChannelConnectionException e2) {
        e2.printStackTrace();
    }
    try {
        final ServiceInterface serviceInterface = bimServer.getService(ServiceInterface.class);
        final SService service = serviceInterface.getService(Long.parseLong(profileIdentifier));
        final SObjectType settings = internalChannel.getPluginInterface().getPluginSettings(service.getInternalServiceId());
        final BimServerClient bimServerClient = bimServer.getBimServerClientFactory().create(new TokenAuthentication(token));
        new Thread() {

            public void run() {
                try {
                    newRevisionHandler.newRevision(bimServerClient, poid, roid, service.getOid(), settings);
                } catch (ServerException e) {
                    LOGGER.error("String_Node_Str", e);
                } catch (UserException e) {
                    LOGGER.error("String_Node_Str", e);
                }
            }
        }.start();
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
    }
}

Output:
     try {
-        final ServiceInterface serviceInterface = bimServer.getService(ServiceInterface.class);
-        final SService service = serviceInterface.getService(Long.parseLong(profileIdentifier));
-        final SObjectType settings = internalChannel.getPluginInterface().getPluginSettings(service.getInternalServiceId());
-        final BimServerClient bimServerClient = bimServer.getBimServerClientFactory().create(new TokenAuthentication(token));
-        new Thread() {
+        DatabaseSession session = bimServer.getDatabase().createSession();
+        try {
+            final InternalServicePluginConfiguration internalServicePluginConfiguration = session.get(Long.parseLong(profileIdentifier), Query.getDefault());
+            final SObjectType settings = bimServer.getSConverter().convertToSObject(internalServicePluginConfiguration.getSettings());
+            final BimServerClient bimServerClient = bimServer.getBimServerClientFactory().create(new TokenAuthentication(token));
+            new Thread() {


Input:
protected void onUpdateChatDialog() {
    if (!messagesAdapter.isEmpty()) {
        startUpdateChatDialog();
    }
}

Output:
 protected void onUpdateChatDialog() {
-    if (!messagesAdapter.isEmpty()) {
+    if (messagesAdapter != null && !messagesAdapter.isEmpty()) {
         startUpdateChatDialog();


Input:
public static Chain getMatchingAtomRes(Chain seqRes, List<Chain> atomList) {
    Iterator<Chain> iter = atomList.iterator();
    while (iter.hasNext()) {
        Chain atomChain = iter.next();
        if (atomChain.getId().equals(seqRes.getId())) {
            return atomChain;
        }
    }
    logger.info("String_Node_Str" + seqRes.getId() + "String_Node_Str" + seqRes.getName() + "String_Node_Str" + atomList.size());
    return null;
}

Output:
         Chain atomChain = iter.next();
-        if (atomChain.getId().equals(seqRes.getId())) {
+        if (atomChain.getName().equals(seqRes.getName())) {
             return atomChain;


Input:
private void restoreStatus() {
    final Scope scope = _comp != null ? (Scope) _comp : _page;
    if (_status.previous != null)
        scope.setAttribute("String_Node_Str", _status.previous);
    else
        scope.removeAttribute("String_Node_Str");
    if (_oldEach != null)
        scope.setAttribute("String_Node_Str", _oldEach);
    else
        scope.removeAttribute("String_Node_Str");
    _it = null;
    _status = null;
}

Output:
 private void restoreStatus() {
-    final Scope scope = _comp != null ? (Scope) _comp : _page;
+    final Scope scope = getScope();
     if (_status.previous != null)


Input:
public void render(float lineThickness) {
    ShaderManager.getInstance().enableDefault();
    glPushMatrix();
    Vector3d cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
    glTranslated(getPosition().x - cameraPosition.x, -cameraPosition.y, getPosition().z - cameraPosition.z);
    renderLocally(lineThickness);
    glPopMatrix();
}

Output:
     glPushMatrix();
-    Vector3d cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
+    Vector3f cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
     glTranslated(getPosition().x - cameraPosition.x, -cameraPosition.y, getPosition().z - cameraPosition.z);


Input:
public final void onEnable() {
    instance = this;
    try {
        saveDefaultConfig();
        for (Player player : Bukkit.getOnlinePlayers()) {
            player.kickPlayer("String_Node_Str");
        }
        databaseConfiguration = new YAMLConfigurationFile(this, "String_Node_Str");
        databaseConfiguration.reloadConfig();
        databaseConfiguration.saveDefaultConfig();
        try {
            provider = (Provider) Class.forName(getConfig().getString("String_Node_Str")).newInstance();
        } catch (Exception e) {
            provider = new DefaultProvider();
        }
        this.playerManager = provider.getNewPlayerManager(this);
        this.networkManager = provider.getNewNetworkManager(this);
        this.permissionsManager = provider.getNewPermissionsManager(this, this.playerManager.getDatabase(), this.playerManager);
        this.netFileManager = provider.getNewNetFileManager(this);
        this.modelManager = provider.getNewModelManager(this.playerManager.getDatabase());
    } catch (Throwable t) {
        t.printStackTrace();
        Bukkit.getPluginManager().disablePlugin(this);
    }
}

Output:
         this.networkManager = provider.getNewNetworkManager(this);
-        this.permissionsManager = provider.getNewPermissionsManager(this, this.playerManager.getDatabase(), this.playerManager);
+        this.permissionsManager = provider.getNewPermissionsManager(this, this.playerManager);
         this.netFileManager = provider.getNewNetFileManager(this);


Input:
public void onTextChanged(CharSequence s, int start, int before, int end) {
    if (start == 0 && before == 1 && s.length() == 0) {
        if (delegate != null) {
            delegate.focusOnPreviousField(this);
        }
    } else if (!s.equals(lastValue)) {
        lastValue = s;
        textChanged(s, start, before, end);
    }
}

Output:
         }
-    } else if (!s.equals(lastValue)) {
-        lastValue = s;
-        textChanged(s, start, before, end);
+    } else {
+        String tmp = String.valueOf(s);
+        if (!tmp.equals(lastValue)) {
+            lastValue = tmp;
+            textChanged(s, start, before, end);
+        }
     }


Input:
public static void scrollDown(StapGraph graph) {
    if (graph.getDrawMode() == StapGraph.CONSTANT_DRAWMODE_LEVEL) {
        if (graph.getTopLevel() + StapGraph.levelBuffer < graph.getLowestLevelOfNodesAdded()) {
            int newLevel = graph.getTopLevel() + 1;
            if (graph.levels.get(newLevel).get(0) == null)
                return;
            graph.setTopLevelTo(newLevel);
            int animMode = graph.getAnimationMode();
            graph.setAnimationMode(StapGraph.CONSTANT_ANIMATION_FASTEST);
            graph.draw(graph.getDrawMode(), StapGraph.CONSTANT_ANIMATION_FASTEST, graph.levels.get(newLevel).get(0));
            graph.setAnimationMode(animMode);
        }
    } else if (graph.getDrawMode() == StapGraph.CONSTANT_DRAWMODE_TREE) {
        graph.extendTree();
    }
}

Output:
     if (graph.getDrawMode() == StapGraph.CONSTANT_DRAWMODE_LEVEL) {
-        if (graph.getTopLevel() + StapGraph.levelBuffer < graph.getLowestLevelOfNodesAdded()) {
+        if (graph.getTopLevel() + graph.levelBuffer < graph.getLowestLevelOfNodesAdded()) {
             int newLevel = graph.getTopLevel() + 1;


Input:
public static Graph<ISSABasicBlock> sanitize(IR ir, IClassHierarchy cha) throws IllegalArgumentException, WalaException {
    if (ir == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    ControlFlowGraph<SSAInstruction, ISSABasicBlock> cfg = ir.getControlFlowGraph();
    Graph<ISSABasicBlock> g = SlowSparseNumberedGraph.make();
    for (Iterator<? extends ISSABasicBlock> it = cfg.iterator(); it.hasNext(); ) {
        g.addNode(it.next());
    }
    for (Iterator it = cfg.iterator(); it.hasNext(); ) {
        ISSABasicBlock b = (ISSABasicBlock) it.next();
        for (Iterator it2 = cfg.getSuccNodes(b); it2.hasNext(); ) {
            ISSABasicBlock b2 = (ISSABasicBlock) it2.next();
            if (!b2.isExitBlock()) {
                g.addEdge(b, b2);
            }
        }
    }
    ISSABasicBlock exit = cfg.exit();
    for (Iterator it = cfg.getPredNodes(exit); it.hasNext(); ) {
        ISSABasicBlock b = (ISSABasicBlock) it.next();
        SSAInstruction s = ir.getInstructions()[b.getLastInstructionIndex()];
        if (s == null) {
            continue;
        }
        if (s instanceof SSAReturnInstruction || s instanceof SSAThrowInstruction) {
            g.addEdge(b, exit);
        } else {
            TypeReference[] exceptions = null;
            try {
                exceptions = computeExceptions(cha, ir, s);
            } catch (InvalidClassFileException e1) {
                e1.printStackTrace();
                Assertions.UNREACHABLE();
            }
            for (Iterator it2 = cfg.getSuccNodes(b); it2.hasNext(); ) {
                IBasicBlock c = (IBasicBlock) it2.next();
                if (c.isCatchBlock()) {
                    SSACFG.ExceptionHandlerBasicBlock cb = (ExceptionHandlerBasicBlock) c;
                    for (Iterator it3 = cb.getCaughtExceptionTypes(); it3.hasNext(); ) {
                        TypeReference ex = (TypeReference) it3.next();
                        IClass exClass = cha.lookupClass(ex);
                        if (exClass == null) {
                            throw new WalaException("String_Node_Str" + ex);
                        }
                        for (int i = 0; i < exceptions.length; i++) {
                            if (exceptions[i] != null) {
                                IClass exi = cha.lookupClass(exceptions[i]);
                                if (exi == null) {
                                    throw new WalaException("String_Node_Str" + exceptions[i]);
                                }
                                if (cha.isSubclassOf(exi, exClass)) {
                                    exceptions[i] = null;
                                }
                            }
                        }
                    }
                }
            }
            TypeReference[] declared = null;
            try {
                declared = ir.getMethod().getDeclaredExceptions();
            } catch (InvalidClassFileException e) {
                e.printStackTrace();
                Assertions.UNREACHABLE();
            }
            if (declared != null && exceptions != null) {
                for (int i = 0; i < exceptions.length; i++) {
                    boolean isDeclared = false;
                    if (exceptions[i] != null) {
                        IClass exi = cha.lookupClass(exceptions[i]);
                        if (exi == null) {
                            throw new WalaException("String_Node_Str" + exceptions[i]);
                        }
                        for (int j = 0; j < declared.length; j++) {
                            IClass dc = cha.lookupClass(declared[j]);
                            if (dc == null) {
                                throw new WalaException("String_Node_Str" + declared[j]);
                            }
                            if (cha.isSubclassOf(exi, dc)) {
                                isDeclared = true;
                                break;
                            }
                        }
                        if (isDeclared) {
                            g.addEdge(b, exit);
                        }
                    }
                }
            }
        }
    }
    return g;
}

Output:
         }
-        if (s instanceof SSAReturnInstruction || s instanceof SSAThrowInstruction) {
+        if (s instanceof SSAReturnInstruction || s instanceof SSAThrowInstruction || cfg.getSuccNodeCount(b) == 1) {
             g.addEdge(b, exit);


Input:
protected void runHighPriorityTask(TaskWrapper task) throws InterruptedException {
    Worker w = null;
    synchronized (workersLock) {
        if (!isShutdown()) {
            synchronized (highPriorityWorkerAvailable.getModificationLock()) {
                highPriorityWorkerAvailable.add(!availableWorkers.isEmpty());
                trimList(highPriorityWorkerAvailable);
            }
            if (getCurrentPoolSize() >= getMaxPoolSize()) {
                w = getExistingWorker(Long.MAX_VALUE);
            } else {
                if (availableWorkers.isEmpty()) {
                    w = makeNewWorker();
                } else {
                    w = availableWorkers.removeFirst();
                }
            }
        }
    }
    if (w != null) {
        Clock.accurateTime();
        long executionDelay = task.getDelayEstimateInMillis();
        if (executionDelay <= 0) {
            synchronized (highPriorityExecutionDelay.getModificationLock()) {
                highPriorityExecutionDelay.add(executionDelay * -1);
                trimList(highPriorityExecutionDelay);
            }
        }
        w.nextTask(task);
    }
}

Output:
     synchronized (workersLock) {
-        if (!isShutdown()) {
+        if (!getShutdownFinishing()) {
             synchronized (highPriorityWorkerAvailable.getModificationLock()) {


Input:
public Object proceed() throws Throwable {
    try {
        index++;
        return index == interceptors.length ? methodProxy.invokeSuper(proxy, arguments) : interceptors[index].invoke(this);
    } catch (Throwable t) {
        pruneStacktrace(t);
        throw t;
    } finally {
        index--;
    }
}

Output:
     try {
-        index++;
-        return index == interceptors.length ? methodProxy.invokeSuper(proxy, arguments) : interceptors[index].invoke(this);
+        return index == interceptors.length ? methodProxy.invokeSuper(proxy, arguments) : interceptors[index].invoke(new InterceptedMethodInvocation(proxy, methodProxy, arguments, index + 1));
     } catch (Throwable t) {


Input:
public void translate(boolean isStatic, int scriptIndex, int classIndex, java.util.HashMap<Integer, GraphTargetItem> localRegs, Stack<GraphTargetItem> stack, java.util.Stack<GraphTargetItem> scopeStack, ConstantPool constants, AVM2Instruction ins, MethodInfo[] method_info, List<GraphTargetItem> output, com.jpexs.decompiler.flash.abc.types.MethodBody body, com.jpexs.decompiler.flash.abc.ABC abc, HashMap<Integer, String> localRegNames, List<String> fullyQualifiedNames) {
    int regIndex = ins.operands[0];
    output.add(new DecLocalTreeItem(ins, regIndex));
    if (localRegs.containsKey(regIndex)) {
        localRegs.put(regIndex, new NotCompileTimeTreeItem(ins, new SubtractTreeItem(ins, localRegs.get(regIndex), new IntegerValueTreeItem(ins, new Long(1)))));
    } else {
        localRegs.put(regIndex, new SubtractTreeItem(ins, localRegs.get(regIndex), new IntegerValueTreeItem(ins, new Long(1))));
    }
}

Output:
     } else {
-        localRegs.put(regIndex, new SubtractTreeItem(ins, localRegs.get(regIndex), new IntegerValueTreeItem(ins, new Long(1))));
+        localRegs.put(regIndex, new SubtractTreeItem(ins, new IntegerValueTreeItem(ins, new Long(0)), new IntegerValueTreeItem(ins, new Long(1))));
     }


Input:
void decPending(int uid, String pkg, long now) {
    PackageEntry pe = getOrCreateEntry(uid, pkg);
    if (pe.pendingCount == 1) {
        pe.pastPendingTime += now - pe.pendingStartTime;
    }
    pe.pendingCount--;
}

Output:
     PackageEntry pe = getOrCreateEntry(uid, pkg);
-    if (pe.pendingCount == 1) {
+    if (pe.pendingNesting == 1) {
         pe.pastPendingTime += now - pe.pendingStartTime;


Input:
private void _removeEditorIcons() {
    for (Object editorIconObject : attributeList(EditorIcon.class)) {
        EditorIcon editorIcon = (EditorIcon) editorIconObject;
        String moml = "String_Node_Str" + editorIcon.getName() + "String_Node_Str";
        MoMLChangeRequest request = new MoMLChangeRequest(this, AtomicActorMatcher.this, moml);
        request.execute();
    }
}

Output:
         String moml = "String_Node_Str" + editorIcon.getName() + "String_Node_Str";
-        MoMLChangeRequest request = new MoMLChangeRequest(this, AtomicActorMatcher.this, moml);
+        MoMLChangeRequest request = new MoMLChangeRequest(this, this, moml);
         request.execute();


Input:
public SSAInstruction copyForSSA(int[] defs, int[] uses) {
    return new SSAComparisonInstruction(opcode, defs == null || defs.length == 0 ? result : defs[0], uses == null ? val1 : uses[0], uses == null ? val2 : uses[1]);
}

Output:
 public SSAInstruction copyForSSA(int[] defs, int[] uses) {
-    return new SSAComparisonInstruction(opcode, defs == null || defs.length == 0 ? result : defs[0], uses == null ? val1 : uses[0], uses == null ? val2 : uses[1]);
+    return new SSAComparisonInstruction(opcode, defs == null || defs.length == 0 ? result : defs[0], uses == null || uses.length == 0 ? val1 : uses[0], uses == null ? val2 : uses[1]);
 }


Input:
public void testInvalidEmployeeValidation() {
    if (shouldGenerateSchema) {
        outputResolver = generateSchema(CONTEXT_PATH, 1);
        shouldGenerateSchema = false;
    }
    String src = PATH + "String_Node_Str";
    String result = validateAgainstSchema(src, "String_Node_Str", outputResolver);
    assertTrue("String_Node_Str", result != null);
}

Output:
     if (shouldGenerateSchema) {
-        outputResolver = generateSchema(CONTEXT_PATH, 1);
+        outputResolver = generateSchema(CONTEXT_PATH, PATH, 1);
         shouldGenerateSchema = false;


Input:
public void testInsertAtEnd() {
    root.insertAt(0, "String_Node_Str");
    root.insertAt(1, "String_Node_Str");
    assertEquals(2, root.getSubtreeSize());
    assertEquals("String_Node_Str", root.getContent());
}

Output:
 public void testInsertAtEnd() {
-    root.insertAt(0, "String_Node_Str");
-    root.insertAt(1, "String_Node_Str");
+    root.insertAt(0, "String_Node_Str", REPLICA_ID);
+    root.insertAt(1, "String_Node_Str", REPLICA_ID);
     assertEquals(2, root.getSubtreeSize());


Input:
public boolean containsEdge(N from, N to, L label) {
    DGEdge<N> edge = new DGEdge<N>(from, to);
    if (edgeToLabels.get(edge) != null && edgeToLabels.get(edge).contains(label)) {
        return true;
    }
    return false;
}

Output:
 public boolean containsEdge(N from, N to, L label) {
-    DGEdge<N> edge = new DGEdge<N>(from, to);
-    if (edgeToLabels.get(edge) != null && edgeToLabels.get(edge).contains(label)) {
-        return true;
-    }
-    return false;
+    List<L> labels = edgeToLabels.get(new DGEdge<>(from, to));
+    return labels != null && labels.contains(label);
 }


Input:
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    mFullIndicator = view.findViewById(R.id.selected_page_indicator);
    mWizardPager = (ViewPager) view.findViewById(R.id.wizard_pages_pager);
    if (mWizardPager != null) {
        mWizardPager.setAdapter(new WizardPagesAdapter(getChildFragmentManager()));
        mWizardPager.setOnPageChangeListener(onPageChangedListener);
    }
}

Output:
     mWizardPager = (ViewPager) view.findViewById(R.id.wizard_pages_pager);
-    if (mWizardPager != null) {
+    isInTabletUi = (mWizardPager == null);
+    if (isInTabletUi) {
+        FragmentManager fragmentManager = getChildFragmentManager();
+        fragmentManager.beginTransaction().add(R.id.wizard_step_one, new WizardPageEnableKeyboardFragment()).add(R.id.wizard_step_two, new WizardPageSwitchToKeyboardFragment()).add(R.id.wizard_step_three, new WizardPageDoneAndMoreSettingsFragment()).commit();
+    } else {
         mWizardPager.setAdapter(new WizardPagesAdapter(getChildFragmentManager()));


Input:
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
    Player player;
    if (sender instanceof Player) {
        player = (Player) sender;
    } else {
        player = null;
    }
    if (PlotMain.hasPermission(player, "String_Node_Str")) {
        return no_permission(player);
    }
    if ((args.length < 1) || ((args.length >= 1) && (args[0].equalsIgnoreCase("String_Node_Str") || args[0].equalsIgnoreCase("String_Node_Str")))) {
        if (args.length < 2) {
            StringBuilder builder = new StringBuilder();
            builder.append(C.HELP_INFO.s());
            for (SubCommand.CommandCategory category : SubCommand.CommandCategory.values()) {
                builder.append("String_Node_Str" + C.HELP_INFO_ITEM.s().replaceAll("String_Node_Str", category.toString().toLowerCase()).replaceAll("String_Node_Str", category.toString()));
            }
            PlayerFunctions.sendMessage(player, builder.toString());
            return true;
        }
        String cat = args[1];
        SubCommand.CommandCategory cato = null;
        for (SubCommand.CommandCategory category : SubCommand.CommandCategory.values()) {
            if (cat.equalsIgnoreCase(category.toString())) {
                cato = category;
                break;
            }
        }
        if (cato == null) {
            StringBuilder builder = new StringBuilder();
            builder.append(C.HELP_INFO.s());
            for (SubCommand.CommandCategory category : SubCommand.CommandCategory.values()) {
                builder.append("String_Node_Str" + C.HELP_INFO_ITEM.s().replaceAll("String_Node_Str", category.toString().toLowerCase()).replaceAll("String_Node_Str", category.toString()));
            }
            PlayerFunctions.sendMessage(player, builder.toString());
            return true;
        }
        StringBuilder help = new StringBuilder();
        for (String string : helpMenu(player, cato)) {
            help.append(string + "String_Node_Str");
        }
        PlayerFunctions.sendMessage(player, help.toString());
        return true;
    } else {
        for (SubCommand command : subCommands) {
            if (command.cmd.equalsIgnoreCase(args[0]) || command.alias.equalsIgnoreCase(args[0])) {
                String[] arguments = new String[args.length - 1];
                for (int x = 1; x < args.length; x++) {
                    arguments[x - 1] = args[x];
                }
                if (command.permission.hasPermission(player)) {
                    if (player != null || !command.isPlayer) {
                        return command.execute(player, arguments);
                    } else {
                        PlayerFunctions.sendMessage(player, C.IS_CONSOLE);
                        return false;
                    }
                } else {
                    return no_permission(player);
                }
            }
        }
        PlayerFunctions.sendMessage(player, C.NOT_VALID_SUBCOMMAND);
    }
    return false;
}

Output:
     }
-    if (PlotMain.hasPermission(player, "String_Node_Str")) {
+    if (!PlotMain.hasPermission(player, "String_Node_Str")) {
         return no_permission(player);


Input:
public void testUpdateItem() throws InterruptedException {
    TodoListItem item = new TodoListItem("String_Node_Str", 0, new Deadline(), false, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    repository.insert(item);
    Thread.sleep(200);
    repository.update(item.update("String_Node_Str", 0, new Deadline(), false, "String_Node_Str", "String_Node_Str", "String_Node_Str"));
    TodoListItem fromDb = repository.getItemById(item.getUuid());
    assertEquals(item.getCreatedAt(), fromDb.getCreatedAt());
    assertNotEquals(item.getChangedAt(), fromDb.getChangedAt());
    assertNotEquals(item.getTitle(), fromDb.getTitle());
}

Output:
 public void testUpdateItem() throws InterruptedException {
-    TodoListItem item = new TodoListItem("String_Node_Str", 0, new Deadline(), false, "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    TodoListItem item = createItem();
     repository.insert(item);


Input:
public float getMonthsOfStock() {
    return (float) getStockOnHand() / commodity.getAMC();
}

Output:
 public float getMonthsOfStock() {
-    return (float) getStockOnHand() / commodity.getAMC();
+    int AMC = commodity.getAMC();
+    return AMC == 0 ? 1 : (float) commodity.getStockOnHand() / AMC;
 }


Input:
public void waitForExists(final String typeName, long timeout, TimeUnit timeoutUnit) throws IOException, UnAuthorizedAccessTokenException, TimeoutException, InterruptedException {
    try {
        ProgramFlowUtil.waitFor(true, new Callable<Boolean>() {
            public Boolean call() throws Exception {
                return exists(typeName);
            }
        }, timeout, timeoutUnit.toSeconds(1), timeoutUnit);
    } catch (ExecutionException e) {
        Throwables.propagateIfPossible(e.getCause(), IOException.class, UnAuthorizedAccessTokenException.class);
    }
}

Output:
             }
-        }, timeout, timeoutUnit.toSeconds(1), timeoutUnit);
+        }, timeout, timeoutUnit, 1, TimeUnit.SECONDS);
     } catch (ExecutionException e) {


Input:
public boolean isWorkCompleted() {
    for (final Map.Entry<Tile, TileProcessingRecord> entry : this.tileRecords.entrySet()) {
        final TileProcessingRecord tileProcessingRecord = entry.getValue();
        if (tileProcessingRecord.getState() != TileProcessingState.DONE_READING) {
            return false;
        } else {
            for (final TileBarcodeProcessingState barcodeProcessingState : tileProcessingRecord.barcodeToProcessingState.values()) {
                if (barcodeProcessingState != TileBarcodeProcessingState.WRITTEN) {
                    return false;
                }
            }
        }
    }
    return true;
}

Output:
         } else {
-            for (final TileBarcodeProcessingState barcodeProcessingState : tileProcessingRecord.barcodeToProcessingState.values()) {
+            for (final Map.Entry<String, TileBarcodeProcessingState> barcodeStateEntry : tileProcessingRecord.getBarcodeProcessingStates().entrySet()) {
+                TileBarcodeProcessingState barcodeProcessingState = barcodeStateEntry.getValue();
                 if (barcodeProcessingState != TileBarcodeProcessingState.WRITTEN) {


Input:
private void importMesh(int index) {
    LoopL<Point3d> polies = blocks.get(index);
    List<Vector2D> verts = polies.stream().flatMap(ll -> ll.streamAble()).map(x -> {
        Line3d l = new Line3d(x.get(), x.getNext().get());
        l.move(perp(l.dir(), EXPAND_MESH));
        return new Vector2D(l.start.x, l.start.z);
    }).collect(Collectors.toList());
    ConvexHull2D chull = new MonotoneChain(false, 0.0001).generate(verts);
    Loop<Point3d> hull = new Loop<Point3d>((Arrays.stream(chull.getLineSegments()).map(x -> new Point3d(x.getStart().getX(), 0, x.getStart().getY())).collect(Collectors.toList())));
    File root = new File(Tweed.SCRATCH + "String_Node_Str" + File.separator);
    int i = 0;
    File l;
    while ((l = new File(root, "String_Node_Str" + i)).exists()) i++;
    l.mkdirs();
    File croppedFile = new File(l, CROPPED_OBJ);
    boolean found = false;
    for (Gen gen : tweed.frame.gens(MiniGen.class)) {
        ((MiniGen) gen).clip(hull, croppedFile);
        found = true;
    }
    if (!found)
        for (Gen gen : tweed.frame.gens(ObjGen.class)) {
            ObjGen objg = (ObjGen) gen;
            try {
                Files.asByteSource(objg.getFile()).copyTo(Files.asByteSink(croppedFile));
                objg.setVisible(false);
                found = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    if (found) {
        Graph2D g2 = new Graph2D();
        polies.stream().flatMap(ll -> ll.streamAble()).forEach(x -> g2.add(new Point2d(x.get().x, x.get().z), new Point2d(x.getNext().get().x, x.getNext().get().z)));
        g2.removeInnerEdges();
        UnionWalker uw = new UnionWalker();
        for (Point2d p : g2.map.keySet()) for (Line line : g2.map.get(p)) uw.addEdge(line.end, line.start);
        Loopz.writeXZObj(uw.findAll(), new File(l, "String_Node_Str"), true);
        Loopz.writeXZObj(Loopz.to2dLoop(polies, 1, null), new File(l, "String_Node_Str"), false);
        BlockGen bg = new BlockGen(l, tweed, polies);
        lastMesh.put(index, bg);
        tweed.frame.addGen(bg, true);
    } else
        JOptionPane.showMessageDialog(tweed.frame(), "String_Node_Str");
}

Output:
     if (!found)
-        for (Gen gen : tweed.frame.gens(ObjGen.class)) {
+        for (Gen gen : tweed.frame.gens(MeshGen.class)) {
             ObjGen objg = (ObjGen) gen;


Input:
public synchronized void leaveTable(UUID userId) {
    if (table == null) {
        logger.error("String_Node_Str" + userId);
        return;
    }
    if (table.isTournament() && tournament == null) {
        logger.error("String_Node_Str" + userId + "String_Node_Str" + table.getId());
        return;
    }
    if (table != null && this.userId != null && this.userId.equals(userId) && (table.getState().equals(TableState.WAITING) || table.getState().equals(TableState.READY_TO_START))) {
        TableManager.getInstance().removeTable(table.getId());
    } else {
        UUID playerId = userPlayerMap.get(userId);
        if (playerId != null) {
            if (table.getState() == TableState.WAITING || table.getState() == TableState.READY_TO_START) {
                table.leaveNotStartedTable(playerId);
                if (table.isTournament()) {
                    tournament.removePlayer(playerId);
                } else {
                    match.quitMatch(playerId);
                }
                User user = UserManager.getInstance().getUser(userId);
                if (user != null) {
                    ChatManager.getInstance().broadcast(chatId, user.getName(), "String_Node_Str", ChatMessage.MessageColor.BLUE, true, ChatMessage.MessageType.STATUS, ChatMessage.SoundToPlay.PlayerLeft);
                    user.removeTable(playerId);
                } else {
                    logger.debug("String_Node_Str" + userId + "String_Node_Str" + table.getId());
                }
                userPlayerMap.remove(userId);
            } else if (!table.getState().equals(TableState.FINISHED)) {
                if (table.isTournament()) {
                    logger.debug("String_Node_Str" + userId);
                    TableManager.getInstance().userQuitTournamentSubTables(tournament.getId(), userId);
                    logger.debug("String_Node_Str" + table.getTournament().getId() + "String_Node_Str" + table.getTournament().getTournamentState() + "String_Node_Str");
                    TournamentManager.getInstance().quit(tournament.getId(), userId);
                } else {
                    MatchPlayer matchPlayer = match.getPlayer(playerId);
                    if (matchPlayer != null && !match.hasEnded() && !matchPlayer.hasQuit()) {
                        Game game = match.getGame();
                        if (game != null && !game.hasEnded()) {
                            Player player = match.getPlayer(playerId).getPlayer();
                            if (player != null && player.isInGame()) {
                                GameManager.getInstance().quitMatch(game.getId(), userId);
                            }
                            match.quitMatch(playerId);
                        } else {
                            if (table.getState().equals(TableState.SIDEBOARDING)) {
                                if (!matchPlayer.isDoneSideboarding()) {
                                    matchPlayer.submitDeck(matchPlayer.getDeck());
                                }
                            }
                            match.quitMatch(playerId);
                        }
                    }
                }
            }
        } else {
            logger.error("String_Node_Str" + userId);
        }
    }
}

Output:
                     ChatManager.getInstance().broadcast(chatId, user.getName(), "String_Node_Str", ChatMessage.MessageColor.BLUE, true, ChatMessage.MessageType.STATUS, ChatMessage.SoundToPlay.PlayerLeft);
-                    user.removeTable(playerId);
+                    if (!table.isTournamentSubTable()) {
+                        user.removeTable(playerId);
+                    }
                 } else {