Input:
public Object getValueAt(int rowIndex, int columnIndex) {
    VariableMapping mapping = null;
    if (rowIndex == 0) {
        mapping = this.population.getContext().getResult();
    } else {
        mapping = this.population.getContext().getDefinedVariables().get(rowIndex - 1);
    }
    switch(columnIndex) {
        case 0:
            return "String_Node_Str" + rowIndex;
        case 1:
            if (rowIndex == 0) {
                return "String_Node_Str";
            } else {
                return mapping.getName();
            }
        case 2:
            return mapping.getVariableType().toString();
        case 3:
            return "String_Node_Str" + mapping.isEnum();
        case 4:
            return "String_Node_Str" + mapping.getEnumType();
        case 5:
            return "String_Node_Str" + mapping.getEnumValueCount();
        default:
            return "String_Node_Str";
    }
}

Output:
             return "String_Node_Str" + mapping.getEnumType();
-        case 5:
+        case 4:
             return "String_Node_Str" + mapping.getEnumValueCount();


Input:
public static void modifyPattern(IOPort port, String[] dims, int[] dimSizes) {
    Attribute pattern = port.getAttribute(PATTERN);
    if (port.getAttribute(PATTERN) == null) {
        try {
            pattern = new Parameter(port, PATTERN);
        } catch (IllegalActionException e) {
            e.printStackTrace();
        } catch (NameDuplicationException e) {
            e.printStackTrace();
        }
    }
    String s = "String_Node_Str";
    if (pattern instanceof Parameter) {
        for (int i = 0; i < dims.length; i++) {
            s += dims[i] + "String_Node_Str" + dimSizes[i] + "String_Node_Str";
            if (i < dims.length - 1) {
                s += "String_Node_Str";
            }
        }
    }
    s += "String_Node_Str";
    ((Parameter) pattern).setExpression(s);
}

Output:
     }
-    String s = "String_Node_Str";
+    StringBuffer s = new StringBuffer("String_Node_Str");
     if (pattern instanceof Parameter) {


Input:
private Operand visitArithComp(Operand left, ExprOps op, Operand right, TypeSymbol type) {
    Operand leftVal = getVal(left);
    Operand rightVal = getVal(right);
    if (leftVal instanceof Literal && rightVal instanceof Literal) {
        return literalCalc(leftVal, op, rightVal);
    }
    Var dst = Var.tmpBuilder(op.toString(), op.isCompare());
    if (type != BaseTypeSymbol.STRING_TYPE_SYMBOL) {
        return currentBasicBlock.pushBack(new BinaryExprInst(dst, leftVal, op, rightVal), valTag);
    }
    List<Operand> args = new ArrayList<>(Arrays.asList(leftVal, rightVal));
    if (op == ADD) {
        if (left.equals(EMPTY_STRING))
            return right;
        else if (right.equals(EMPTY_STRING))
            return left;
        return currentBasicBlock.pushBack(new FunctionCallInst(Function.STR_ADD, args, dst), valTag);
    }
    currentBasicBlock.pushBack(new FunctionCallInst(Function.STR_CMP, args, dst), valTag);
    Var cmp = Var.tmpBuilder("String_Node_Str" + op.toString(), true);
    switch(op) {
        case GT:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, GT, ZERO_LITERAL), valTag);
        case LT:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, LT, ZERO_LITERAL), valTag);
        case GTE:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, GTE, ZERO_LITERAL), valTag);
        case LTE:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, LTE, ZERO_LITERAL), valTag);
        case EQ:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, EQ, ZERO_LITERAL), valTag);
        case NEQ:
            return currentBasicBlock.pushBack(new BinaryExprInst(cmp, dst, NEQ, ZERO_LITERAL), valTag);
        default:
            throw new RuntimeException("String_Node_Str");
    }
}

Output:
     if (leftVal instanceof Literal && rightVal instanceof Literal) {
-        return literalCalc(leftVal, op, rightVal);
+        try {
+            return literalCalc(leftVal, op, rightVal);
+        } catch (ArithmeticException e) {
+            System.err.println("String_Node_Str" + e.getMessage());
+        }
     }


Input:
private void updateVisibleCount(Listitem item, boolean isRemove) {
    if (item instanceof Listgroup || item.isVisible()) {
        final Listgroup g = getListgroupAt(item.getIndex());
        if (item instanceof Listgroupfoot || item instanceof Listgroup || g == null || g.isOpen())
            addVisibleItemCount(isRemove ? -1 : 1);
        if (item instanceof Listgroup) {
            final Listgroup group = (Listgroup) item;
            if (item.getPreviousSibling() instanceof Listitem) {
                final Listitem preRow = (Listitem) item.getPreviousSibling();
                if (preRow == null) {
                    if (!group.isOpen()) {
                        addVisibleItemCount(isRemove ? group.getVisibleItemCount() : -group.getVisibleItemCount());
                    }
                } else {
                    final Listgroup preGroup = getListgroupAt(preRow.getIndex());
                    if (preGroup != null) {
                        if (!preGroup.isOpen() && group.isOpen())
                            addVisibleItemCount(isRemove ? -group.getVisibleItemCount() : group.getVisibleItemCount());
                        else if (preGroup.isOpen() && !group.isOpen())
                            addVisibleItemCount(isRemove ? group.getVisibleItemCount() : -group.getVisibleItemCount());
                    } else {
                        if (!group.isOpen())
                            addVisibleItemCount(isRemove ? group.getVisibleItemCount() : -group.getVisibleItemCount());
                    }
                }
            } else if (!group.isOpen()) {
                addVisibleItemCount(isRemove ? group.getVisibleItemCount() : -group.getVisibleItemCount());
            }
        }
    }
    if (inPagingMold())
        getPaginal().setTotalSize(getVisibleItemCount());
}

Output:
                 } else {
-                    final Listgroup preGroup = getListgroupAt(preRow.getIndex());
+                    final Listgroup preGroup = preRow instanceof Listgroup ? (Listgroup) preRow : getListgroupAt(preRow.getIndex());
                     if (preGroup != null) {


Input:
public List<BlockPopulator> getDefaultPopulators(World world) {
    PlotSquared.loadWorld(PlotSquared.GEN_WORLD, this);
    PlotWorld plotworld = PlotSquared.getPlotWorld(PlotSquared.GEN_WORLD);
    if (!plotworld.MOB_SPAWNING) {
        if (!plotworld.SPAWN_EGGS) {
            world.setSpawnFlags(false, false);
        }
        world.setAmbientSpawnLimit(0);
        world.setAnimalSpawnLimit(0);
        world.setMonsterSpawnLimit(0);
        world.setWaterAnimalSpawnLimit(0);
    } else {
        world.setSpawnFlags(true, true);
        world.setAmbientSpawnLimit(-1);
        world.setAnimalSpawnLimit(-1);
        world.setMonsterSpawnLimit(-1);
        world.setWaterAnimalSpawnLimit(-1);
    }
    return getPopulators(PlotSquared.GEN_WORLD);
}

Output:
 public List<BlockPopulator> getDefaultPopulators(World world) {
-    PlotSquared.loadWorld(PlotSquared.GEN_WORLD, this);
-    PlotWorld plotworld = PlotSquared.getPlotWorld(PlotSquared.GEN_WORLD);
+    PlotSquared.loadWorld(world.getName(), this);
+    PlotWorld plotworld = PlotSquared.getPlotWorld(world.getName());
     if (!plotworld.MOB_SPAWNING) {


Input:
public void setFont(String spec) {
    if (!properties.containsKey(PROPERTY.FONT)) {
        properties.put(PROPERTY.FONT, renderable.getFont());
    }
    renderable.setFont(spec);
}

Output:
 public void setFont(String spec) {
-    if (!properties.containsKey(PROPERTY.FONT)) {
-        properties.put(PROPERTY.FONT, renderable.getFont());
+    if (!properties.containsKey(PROPERTY_FONT)) {
+        properties.put(PROPERTY_FONT, renderable.getFont());
     }


Input:
public void run() {
    String url = link.getDownloadURL();
    if (url != null) {
        url = HTMLParser.getHttpLinkList(url);
        try {
            url = URLDecoder.decode(url, "String_Node_Str");
        } catch (Exception e) {
            logger.warning("String_Node_Str");
        }
    }
    boolean coulddecrypt = false;
    for (DecryptPluginWrapper pDecrypt : DecryptPluginWrapper.getDecryptWrapper()) {
        if (pDecrypt.usePlugin() && pDecrypt.canHandle(url)) {
            try {
                PluginForDecrypt plg = (PluginForDecrypt) pDecrypt.getNewPluginInstance();
                CryptedLink[] decryptableLinks = plg.getDecryptableLinks(url);
                url = plg.cutMatches(url);
                for (CryptedLink cLink : decryptableLinks) {
                    cLink.setDecrypterPassword(link.getDecrypterPassword());
                }
                ArrayList<DownloadLink> dLinks = plg.decryptLinks(decryptableLinks);
                for (DownloadLink dLink : dLinks) {
                    dLink.addSourcePluginPasswords(link.getSourcePluginPasswords());
                }
                coulddecrypt = true;
                if (dLinks != null && dLinks.size() > 0) {
                    newdecryptedLinks.addAll(dLinks);
                }
                break;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    if (coulddecrypt == false) {
        newdecryptedLinks.add(link);
    }
}

Output:
     if (coulddecrypt == false) {
-        newdecryptedLinks.add(link);
+        notdecryptedLinks.add(link);
     }


Input:
public void endElement(String uri, String localName, String qName) throws SAXException {
    if (indexTermSpecList.contains(localName)) {
        IndexTerm term = (IndexTerm) termStack.pop();
        if (term.getTermName() == null) {
            term.setTermName("String_Node_Str");
            javaLogger.logWarn(MessageUtils.getMessage("String_Node_Str").toString());
        }
        if (term.getTermKey() == null) {
            term.setTermKey(term.getTermName());
        }
        if (termStack.empty()) {
            indexTermList.add(term);
        } else {
            IndexTerm parentTerm = (IndexTerm) termStack.peek();
            parentTerm.addSubTerm(term);
        }
    }
    if (indexSeeSpecList.contains(localName) || indexSeeAlsoSpecList.contains(localName)) {
        IndexTerm term = (IndexTerm) termStack.pop();
        IndexTerm parentTerm = (IndexTerm) termStack.peek();
        if (term.getTermKey() == null) {
            term.setTermKey(term.getTermFullName());
        }
        term.addTargets(parentTerm.getTargetList());
        parentTerm.addSubTerm(term);
    }
    if (Constants.ELEMENT_NAME_TITLE.equals(localName)) {
        inTitleElement = false;
        if (!titleMap.containsKey(topicIdStack.peek())) {
            if (titleMap.size() == 0)
                defaultTitle = title;
            titleMap.put(topicIdStack.peek(), title);
        }
    }
    if (indexSortAsSpecList.contains(localName)) {
        insideSortingAs = false;
    }
    if (topicSpecList.contains(localName)) {
        topicIdStack.pop();
    }
}

Output:
         }
-        term.addTargets(parentTerm.getTargetList());
+        term.addTarget(genTarget());
         parentTerm.addSubTerm(term);


Input:
private synchronized void flushScriptVariables() {
    scopeCacheByName = null;
    globalProviders.clear();
}

Output:
     scopeCacheByName = null;
-    globalProviders.clear();
+    flushGlobalProviders();
 }


Input:
protected void createDataSet() {
    dataSet = getElementFactory().newOdaDataSet(DATA_SET_NAME);
    HashMap map = new HashMap();
    map.put(DesignerConstants.KEY_NEWOBJECT, dataSet);
    CreateCommand command = new CreateCommand(map);
    SlotHandle parent = getReportDesignHandle().getDataSets();
    command.setParent(parent);
    command.execute();
    if (dataSource1 == null)
        createDataSource1();
    try {
        dataSet.setDataSource(DATA_SOURCE_NAME);
    } catch (SemanticException e) {
        e.printStackTrace();
        fail("String_Node_Str");
    }
}

Output:
     command.execute();
-    if (dataSource1 == null)
-        createDataSource1();
+    if (dataSource == null)
+        createDataSource();
     try {


Input:
public byte[] toByteArray(Object obj) {
    if (obj == null) {
        return null;
    }
    try {
        this.bbos.reset();
        toByte(this.bbos, obj);
        final byte[] result = this.bbos.toByteArray();
        if (this.bbos.size() > OUTPUT_STREAM_BUFFER_SIZE) {
            this.bbos.set(new byte[OUTPUT_STREAM_BUFFER_SIZE]);
        }
        return result;
    } catch (final Throwable e) {
        logger.log(Level.SEVERE, e.getMessage(), e);
        throw new RuntimeException(e);
    }
}

Output:
         return result;
-    } catch (final Throwable e) {
+    } catch (Throwable e) {
         logger.log(Level.SEVERE, e.getMessage(), e);


Input:
private void placeComponents() {
    FillLayout flMain = new FillLayout();
    flMain.marginHeight = 0;
    flMain.marginWidth = 0;
    GridLayout glAttributes = new GridLayout();
    glAttributes.horizontalSpacing = 5;
    glAttributes.verticalSpacing = 5;
    glAttributes.marginHeight = 7;
    glAttributes.marginWidth = 7;
    GridLayout glGeneral = new GridLayout();
    glGeneral.numColumns = 2;
    glGeneral.horizontalSpacing = 5;
    glGeneral.verticalSpacing = 5;
    FillLayout flOutline = new FillLayout();
    this.setLayout(flMain);
    if (sGroupName == null || sGroupName.length() == 0) {
        grpAttributes = new Composite(this, SWT.NONE);
    } else {
        grpAttributes = new Group(this, SWT.NONE);
        ((Group) grpAttributes).setText(sGroupName);
    }
    grpAttributes.setLayout(glAttributes);
    cmpGeneral = new Composite(grpAttributes, SWT.NONE);
    GridData gdCMPGeneral = new GridData(GridData.FILL_HORIZONTAL);
    cmpGeneral.setLayoutData(gdCMPGeneral);
    cmpGeneral.setLayout(glGeneral);
    boolean bEnableUI = bEnabled && this.lblCurrent.isVisible();
    if (attributesContext.isVisibilityEnabled) {
        cbVisible = new Button(cmpGeneral, SWT.CHECK);
        GridData gdCBVisible = new GridData(GridData.FILL_HORIZONTAL);
        gdCBVisible.horizontalSpan = 2;
        cbVisible.setLayoutData(gdCBVisible);
        cbVisible.setSelection(this.lblCurrent.isVisible());
        cbVisible.setText(Messages.getString("String_Node_Str"));
        cbVisible.addSelectionListener(this);
        if (bEnabled) {
            bEnableUI = cbVisible.getSelection();
        }
    }
    if (attributesContext.isLabelEnabled) {
        lblLabel = new Label(cmpGeneral, SWT.NONE);
        {
            GridData gd = new GridData();
            lblLabel.setLayoutData(gd);
            lblLabel.setText(Messages.getString("String_Node_Str"));
        }
        txtLabel = new ExternalizedTextEditorComposite(cmpGeneral, SWT.BORDER | SWT.SINGLE, -1, -1, wizardContext.getUIServiceProvider().getRegisteredKeys(), wizardContext.getUIServiceProvider(), "String_Node_Str");
        {
            GridData gd = new GridData(GridData.FILL_BOTH);
            txtLabel.setLayoutData(gd);
            txtLabel.addListener(this);
        }
    }
    if (attributesContext.isPositionEnabled) {
        lblPosition = new Label(cmpGeneral, SWT.NONE);
        GridData gdLBLPosition = new GridData();
        lblPosition.setLayoutData(gdLBLPosition);
        lblPosition.setText(Messages.getString("String_Node_Str"));
        lblPosition.setEnabled(bEnableUI);
        cmbPosition = new Combo(cmpGeneral, SWT.DROP_DOWN | SWT.READ_ONLY);
        GridData gdCMBPosition = new GridData(GridData.FILL_BOTH);
        cmbPosition.setLayoutData(gdCMBPosition);
        cmbPosition.addSelectionListener(this);
        cmbPosition.setEnabled(bEnableUI);
    }
    if (attributesContext.isFontEnabled) {
        lblFont = new Label(cmpGeneral, SWT.NONE);
        GridData gdLFont = new GridData();
        lblFont.setLayoutData(gdLFont);
        lblFont.setText(Messages.getString("String_Node_Str"));
        lblFont.setEnabled(bEnableUI);
        fdcFont = new FontDefinitionComposite(cmpGeneral, SWT.NONE, wizardContext, this.fdCurrent, this.cdFont, attributesContext.isFontAlignmentEnabled);
        GridData gdFDCFont = new GridData(GridData.FILL_BOTH);
        gdFDCFont.widthHint = fdcFont.getPreferredSize().x;
        gdFDCFont.grabExcessVerticalSpace = false;
        fdcFont.setLayoutData(gdFDCFont);
        fdcFont.addListener(this);
        fdcFont.setEnabled(bEnableUI);
    }
    lblFill = new Label(cmpGeneral, SWT.NONE);
    GridData gdLFill = new GridData();
    lblFill.setLayoutData(gdLFill);
    lblFill.setText(Messages.getString("String_Node_Str"));
    lblFill.setEnabled(bEnableUI);
    fccBackground = new FillChooserComposite(cmpGeneral, SWT.NONE, wizardContext, fBackground, false, false);
    GridData gdFCCBackground = new GridData(GridData.FILL_BOTH);
    fccBackground.setLayoutData(gdFCCBackground);
    fccBackground.addListener(this);
    fccBackground.setEnabled(bEnableUI);
    if (attributesContext.isShadowEnabled) {
        lblShadow = new Label(cmpGeneral, SWT.NONE);
        GridData gdLBLShadow = new GridData();
        lblShadow.setLayoutData(gdLBLShadow);
        lblShadow.setText(Messages.getString("String_Node_Str"));
        lblShadow.setEnabled(bEnableUI);
        int iFillOption = FillChooserComposite.DISABLE_PATTERN_FILL | FillChooserComposite.ENABLE_TRANSPARENT | FillChooserComposite.ENABLE_TRANSPARENT_SLIDER;
        fccShadow = new FillChooserComposite(cmpGeneral, SWT.DROP_DOWN | SWT.READ_ONLY, iFillOption, wizardContext, cdShadow);
        GridData gdFCCShadow = new GridData(GridData.FILL_BOTH);
        fccShadow.setLayoutData(gdFCCShadow);
        fccShadow.addListener(this);
        fccShadow.setEnabled(bEnableUI);
    }
    grpOutline = new Group(grpAttributes, SWT.NONE);
    GridData gdGOutline = new GridData(GridData.FILL_HORIZONTAL);
    grpOutline.setLayoutData(gdGOutline);
    grpOutline.setText(Messages.getString("String_Node_Str"));
    grpOutline.setLayout(flOutline);
    grpOutline.setEnabled(bEnableUI);
    liacOutline = new LineAttributesComposite(grpOutline, SWT.NONE, wizardContext, laCurrent, true, true, true);
    liacOutline.addListener(this);
    liacOutline.setAttributesEnabled(bEnableUI);
    if (attributesContext.isInsetsEnabled) {
        icInsets = new InsetsComposite(grpAttributes, SWT.NONE, insets, sUnits, wizardContext.getUIServiceProvider());
        GridData gdICInsets = new GridData(GridData.FILL_HORIZONTAL);
        gdICInsets.grabExcessVerticalSpace = false;
        icInsets.addListener(this);
        icInsets.setLayoutData(gdICInsets);
        icInsets.setEnabled(bEnableUI);
    }
    populateLists();
}

Output:
     lblFill.setEnabled(bEnableUI);
-    fccBackground = new FillChooserComposite(cmpGeneral, SWT.NONE, wizardContext, fBackground, false, false);
+    fccBackground = new FillChooserComposite(cmpGeneral, SWT.NONE, wizardContext, fBackground, false, false, false);
     GridData gdFCCBackground = new GridData(GridData.FILL_BOTH);


Input:
public void buildAmbariCluster(Stack stack) {
    Cluster cluster = stack.getCluster();
    try {
        if (cluster.getCreationStarted() == null) {
            cluster.setCreationStarted(new Date().getTime());
            cluster = clusterRepository.save(cluster);
        }
        Set<HostGroup> hostGroups = hostGroupService.getByCluster(cluster.getId());
        Map<String, List<Map<String, String>>> hostGroupMappings = buildHostGroupAssociations(hostGroups);
        recipeEngine.executePostAmbariStartRecipes(stack, hostGroups);
        String blueprintText = generateBlueprintText(stack, cluster);
        AmbariClient ambariClient = getAmbariClient(stack);
        ambariRepositoryVersionService.setBaseRepoURL(stack.getName(), cluster.getId(), stack.getOrchestrator(), ambariClient);
        addBlueprint(stack, ambariClient, blueprintText, hostGroups);
        Set<HostMetadata> hostsInCluster = hostMetadataRepository.findHostsInCluster(cluster.getId());
        PollingResult waitForHostsResult = waitForHosts(stack, ambariClient, hostsInCluster);
        checkPollingResult(waitForHostsResult, cloudbreakMessagesService.getMessage(Msg.AMBARI_CLUSTER_HOST_JOIN_FAILED.code()));
        ambariClusterTemplateService.addClusterTemplate(cluster, hostGroupMappings, ambariClient);
        Pair<PollingResult, Exception> pollingResult = ambariOperationService.waitForOperationsToStart(stack, ambariClient, singletonMap("String_Node_Str", 1), START_OPERATION_STATE);
        String message = pollingResult.getRight() == null ? cloudbreakMessagesService.getMessage(Msg.AMBARI_CLUSTER_INSTALL_FAILED.code()) : pollingResult.getRight().getMessage();
        checkPollingResult(pollingResult.getLeft(), message);
        pollingResult = waitForClusterInstall(stack, ambariClient);
        checkPollingResult(pollingResult.getLeft(), cloudbreakMessagesService.getMessage(Msg.AMBARI_CLUSTER_INSTALL_FAILED.code()));
        recipeEngine.executePostInstall(stack);
        triggerSmartSenseCapture(ambariClient, blueprintText);
        cluster = ambariViewProvider.provideViewInformation(ambariClient, cluster);
        handleClusterCreationSuccess(stack, cluster);
    } catch (CancellationException cancellationException) {
        throw cancellationException;
    } catch (HttpResponseException hre) {
        String errorMessage = AmbariClientExceptionUtil.getErrorMessage(hre);
        throw new AmbariOperationFailedException("String_Node_Str" + errorMessage, hre);
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e.getMessage(), e);
        throw new AmbariOperationFailedException(e.getMessage(), e);
    }
}

Output:
         checkPollingResult(pollingResult.getLeft(), cloudbreakMessagesService.getMessage(Msg.AMBARI_CLUSTER_INSTALL_FAILED.code()));
-        recipeEngine.executePostInstall(stack);
+        recipeEngine.executePostInstallRecipes(stack, hostGroups);
         triggerSmartSenseCapture(ambariClient, blueprintText);


Input:
public static <T> T[] arrayUniq(T... eles) {
    if (null == eles || eles.length == 0)
        return null;
    HashSet<T> set = new HashSet<T>(eles.length);
    T[] arr = (T[]) Array.newInstance(eles[0].getClass(), set.size());
    int index = 0;
    for (int i = 0; i < eles.length; i++) {
        if (set.contains(eles[i])) {
            set.remove(eles[i]);
            arr[index++] = eles[i];
        }
    }
    return arr;
}

Output:
     int index = 0;
-    for (int i = 0; i < eles.length; i++) {
-        if (set.contains(eles[i])) {
-            set.remove(eles[i]);
-            arr[index++] = eles[i];
-        }
+    for (T ele : eles) {
+        if (set.remove(ele))
+            Array.set(arr, index++, ele);
     }


Input:
protected void onResume() {
    super.onResume();
    String uriString = getIntent().getStringExtra("String_Node_Str");
    Uri uri = Uri.parse(uriString);
    final boolean success = uri.getQueryParameter("String_Node_Str").equals("String_Node_Str");
    glideraService = GlideraService.getInstance();
    glideraService.status().observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<StatusResponse>() {
        public void onCompleted() {
        }
        public void onError(Throwable e) {
            handleError();
        }
        public void onNext(StatusResponse statusResponse) {
            if (statusResponse.isUserCanTransact()) {
                Intent intent = new Intent(GlideraSendToNextStep.this, GlideraMainActivity.class);
                startActivity(intent);
                finish();
            } else {
                if (success) {
                    String uri = glideraService.getSetupUrl();
                    Utils.openWebsite(GlideraSendToNextStep.this, uri);
                } else {
                    handleError();
                }
            }
        }
    });
}

Output:
     Uri uri = Uri.parse(uriString);
-    final boolean success = uri.getQueryParameter("String_Node_Str").equals("String_Node_Str");
+    final String status = uri.getQueryParameter("String_Node_Str");
     glideraService = GlideraService.getInstance();


Input:
private void addJavascript(UIViewRoot root, FacesContext context, boolean isProduction) {
    Application app = context.getApplication();
    ResourceHandler rh = app.getResourceHandler();
    String theme = null;
    theme = context.getExternalContext().getInitParameter(C.P_USETHEME);
    if (theme != null && theme.equals(C.TRUE)) {
        Resource themeResource = rh.createResource(C.BSF_CSS_TBSTHEME, C.BSF_LIBRARY);
        if (themeResource == null) {
            throw new FacesException("String_Node_Str" + C.BSF_CSS_TBSTHEME + "String_Node_Str" + C.BSF_LIBRARY + "String_Node_Str");
        } else {
            UIOutput output = new UIOutput();
            output.setRendererType("String_Node_Str");
            output.getAttributes().put("String_Node_Str", C.BSF_CSS_TBSTHEME);
            output.getAttributes().put("String_Node_Str", C.BSF_LIBRARY);
            output.getAttributes().put("String_Node_Str", "String_Node_Str");
            root.addComponentResource(context, output, "String_Node_Str");
        }
    }
    UIComponent header = findHeader(root);
    boolean usefa = (null == header) || (null == header.getFacet("String_Node_Str"));
    if (usefa) {
        InternalFALink output = new InternalFALink();
        output.getAttributes().put("String_Node_Str", C.FONTAWESOME_CDN_URL);
        root.addComponentResource(context, output, "String_Node_Str");
    }
    boolean loadJQuery = true;
    List<UIComponent> availableResources = root.getComponentResources(context, "String_Node_Str");
    for (UIComponent ava : availableResources) {
        String name = (String) ava.getAttributes().get("String_Node_Str");
        if (null != name)
            if (name.toLowerCase().contains("String_Node_Str") && name.toLowerCase().endsWith("String_Node_Str")) {
            } else if (name.toLowerCase().contains("String_Node_Str") && name.toLowerCase().endsWith("String_Node_Str")) {
                loadJQuery = false;
            }
    }
    Map<String, Object> viewMap = root.getViewMap();
    Map<String, String> resourceMap = (Map<String, String>) viewMap.get(RESOURCE_KEY);
    if (null != resourceMap) {
        if (loadJQuery) {
            boolean needsJQuery = false;
            for (Entry<String, String> entry : resourceMap.entrySet()) {
                String file = entry.getValue();
                if ("String_Node_Str".equals(file)) {
                    needsJQuery = true;
                }
            }
            if (needsJQuery) {
                UIOutput output = new UIOutput();
                output.setRendererType("String_Node_Str");
                output.getAttributes().put("String_Node_Str", "String_Node_Str");
                output.getAttributes().put("String_Node_Str", C.BSF_LIBRARY);
                output.getAttributes().put("String_Node_Str", "String_Node_Str");
                root.addComponentResource(context, output, "String_Node_Str");
            }
        }
        for (Entry<String, String> entry : resourceMap.entrySet()) {
            String file = entry.getValue();
            String library = entry.getKey().substring(0, entry.getKey().length() - file.length() - 1);
            if (!"String_Node_Str".equals(file)) {
                UIOutput output = new UIOutput();
                output.setRendererType("String_Node_Str");
                output.getAttributes().put("String_Node_Str", file);
                output.getAttributes().put("String_Node_Str", library);
                output.getAttributes().put("String_Node_Str", "String_Node_Str");
                root.addComponentResource(context, output, "String_Node_Str");
            }
        }
    }
    {
        InternalIE8CompatiblityLinks output = new InternalIE8CompatiblityLinks();
        root.addComponentResource(context, output, "String_Node_Str");
    }
}

Output:
     theme = context.getExternalContext().getInitParameter(C.P_USETHEME);
-    if (theme != null && theme.equals(C.TRUE)) {
+    if (isFontAwesomeComponentUsedAndRemoveIt() || (theme != null && theme.equals(C.TRUE))) {
         Resource themeResource = rh.createResource(C.BSF_CSS_TBSTHEME, C.BSF_LIBRARY);


Input:
public void getLog(LoggingContext loggingContext, long fromTimeMs, long toTimeMs, Filter filter, Callback callback) {
    long fromOffset = getOffset(fromTimeMs / 1000);
    long toOffset = getOffset(toTimeMs / 1000);
    getLogNext(loggingContext, new ReadRange(fromTimeMs, toTimeMs, fromOffset), (int) (toOffset - fromOffset), filter, callback);
}

Output:
     long toOffset = getOffset(toTimeMs / 1000);
-    getLogNext(loggingContext, new ReadRange(fromTimeMs, toTimeMs, fromOffset), (int) (toOffset - fromOffset), filter, callback);
+    getLogNext(loggingContext, new ReadRange(fromTimeMs, toTimeMs, fromOffset), (int) (toOffset - fromOffset), filter, collectingCallback);
+    final Iterator<LogEvent> iterator = collectingCallback.getLogEvents().iterator();
+    return new CloseableIterator<LogEvent>() {
+        public boolean hasNext() {
+            return iterator.hasNext();
+        }
+        public LogEvent next() {
+            return iterator.next();
+        }
+        public void remove() {
+            iterator.remove();
+        }
+        public void close() {
+        }
+    };
 }


Input:
public void bigInt2Bytes() {
    BigInteger bigInteger = BigInteger.valueOf(1000000000000L);
    String aa = Helper.toHexString(Helper.BigInt2Bytes(bigInteger));
    System.out.println(aa);
    BigInteger bb = Helper.BigIntFromBytes(Helper.hexToBytes(aa));
    assertTrue(bigInteger.equals(bb));
}

Output:
     BigInteger bigInteger = BigInteger.valueOf(1000000000000L);
-    String aa = Helper.toHexString(Helper.BigInt2Bytes(bigInteger));
+    String aa = Helper.toHexString(Helper.BigIntToNeoBytes(bigInteger));
     System.out.println(aa);


Input:
public void onAnimationEnd(Animator animation) {
    if (!mCanceled) {
        if (isForcedVisibility) {
            ViewUtils.setTransitionAlpha(finalViewToKeep, 0);
        } else {
            finalViewToKeep.setVisibility(finalVisibility);
        }
    }
}

Output:
     if (!mCanceled) {
-        if (isForcedVisibility) {
-            ViewUtils.setTransitionAlpha(finalViewToKeep, 0);
-        } else {
-            finalViewToKeep.setVisibility(finalVisibility);
+        if (!isForcedVisibility) {
+            mFinalViewToKeep = finalViewToKeep;
+            mFinalVisibility = finalVisibility;
         }


Input:
protected final void syncReloadDictionaryIfRequired() {
    if (mBinaryDictionary != null && !mLocalDictionaryController.isOutOfDate()) {
        return;
    }
    mSharedDictionaryController.lock();
    try {
        final long time = SystemClock.uptimeMillis();
        if (mSharedDictionaryController.isOutOfDate() || !dictionaryFileExists()) {
            if (hasContentChanged()) {
                mSharedDictionaryController.mLastUpdateTime = time;
                generateBinaryDictionary();
                loadBinaryDictionary();
            } else {
                mSharedDictionaryController.mLastUpdateRequestTime = mSharedDictionaryController.mLastUpdateTime;
            }
        } else if (mBinaryDictionary == null || mLocalDictionaryController.mLastUpdateTime < mSharedDictionaryController.mLastUpdateTime) {
            loadBinaryDictionary();
        }
        mLocalDictionaryController.mLastUpdateTime = time;
    } finally {
        mSharedDictionaryController.unlock();
    }
}

Output:
 protected final void syncReloadDictionaryIfRequired() {
-    if (mBinaryDictionary != null && !mLocalDictionaryController.isOutOfDate()) {
+    if (!isReloadRequired())
         return;


Input:
public void formBondsFromStructConn(List<StructConn> structConn) {
    final String symop = "String_Node_Str";
    List<Bond> ssbonds = new ArrayList<>();
    for (StructConn conn : structConn) {
        if (!BOND_TYPES_TO_PARSE.contains(conn.getConn_type_id()))
            continue;
        String chainId1;
        String chainId2;
        chainId1 = conn.getPtnr1_label_asym_id();
        chainId2 = conn.getPtnr2_label_asym_id();
        String insCode1 = "String_Node_Str";
        if (!conn.getPdbx_ptnr1_PDB_ins_code().equals("String_Node_Str"))
            insCode1 = conn.getPdbx_ptnr1_PDB_ins_code();
        String insCode2 = "String_Node_Str";
        if (!conn.getPdbx_ptnr2_PDB_ins_code().equals("String_Node_Str"))
            insCode2 = conn.getPdbx_ptnr2_PDB_ins_code();
        String seqId1 = conn.getPtnr1_auth_seq_id();
        String seqId2 = conn.getPtnr2_auth_seq_id();
        String resName1 = conn.getPtnr1_label_comp_id();
        String resName2 = conn.getPtnr2_label_comp_id();
        String atomName1 = conn.getPtnr1_label_atom_id();
        String atomName2 = conn.getPtnr2_label_atom_id();
        String altLoc1 = "String_Node_Str";
        if (!conn.getPdbx_ptnr1_label_alt_id().equals("String_Node_Str"))
            altLoc1 = conn.getPdbx_ptnr1_label_alt_id();
        String altLoc2 = "String_Node_Str";
        if (!conn.getPdbx_ptnr2_label_alt_id().equals("String_Node_Str"))
            altLoc2 = conn.getPdbx_ptnr2_label_alt_id();
        if (!conn.getPtnr1_symmetry().equals(symop) || !conn.getPtnr2_symmetry().equals(symop)) {
            logger.info("String_Node_Str", atomName1, seqId1, insCode1, atomName2, seqId2, insCode2);
            continue;
        }
        String altLocStr1 = altLoc1.isEmpty() ? "String_Node_Str" : "String_Node_Str" + altLoc1 + "String_Node_Str";
        String altLocStr2 = altLoc2.isEmpty() ? "String_Node_Str" : "String_Node_Str" + altLoc2 + "String_Node_Str";
        Map<Integer, Atom> a1 = null;
        Map<Integer, Atom> a2 = null;
        try {
            a1 = getAtomFromRecord(atomName1, altLoc1, resName1, chainId1, seqId1, insCode1);
        } catch (StructureException e) {
            logger.warn("String_Node_Str", seqId1, insCode1, resName1, chainId1, atomName1, altLocStr1);
            continue;
        }
        try {
            a2 = getAtomFromRecord(atomName2, altLoc2, resName2, chainId2, seqId2, insCode2);
        } catch (StructureException e) {
            logger.warn("String_Node_Str", seqId2, insCode2, resName2, chainId2, atomName2, altLocStr2);
            continue;
        }
        if (a1 == null) {
            logger.warn("String_Node_Str", atomName1, altLocStr1, seqId1, insCode1, resName1, chainId1);
            continue;
        }
        if (a2 == null) {
            logger.warn("String_Node_Str", atomName2, altLocStr2, seqId2, insCode2, resName2, chainId2);
            continue;
        }
        for (int i = 0; i < structure.nrModels(); i++) {
            Bond bond = null;
            if (a1.containsKey(i) && a2.containsKey(i)) {
                bond = new BondImpl(a1.get(i), a2.get(i), 1);
            }
            if (bond != null) {
                if (conn.getConn_type_id().equals("String_Node_Str")) {
                    ssbonds.add(bond);
                }
            }
        }
    }
    structure.setSSBonds(ssbonds);
}

Output:
             if (a1.containsKey(i) && a2.containsKey(i)) {
-                bond = new BondImpl(a1.get(i), a2.get(i), 1);
+                if (!a1.get(i).equals(a2.get(i))) {
+                    bond = new BondImpl(a1.get(i), a2.get(i), 1);
+                }
             }


Input:
public void setContainer(CompositeEntity container) throws IllegalActionException, NameDuplicationException {
    if (!(container instanceof CompositeActor) && (container != null)) {
        throw new IllegalActionException(this, container, "String_Node_Str");
    }
    Nameable oldContainer = getContainer();
    if (oldContainer instanceof CompositeActor) {
        Director director = ((CompositeActor) oldContainer).getDirector();
        if (director != null) {
            director.invalidateSchedule();
            director.invalidateResolvedTypes();
        }
    }
    if (container instanceof CompositeActor) {
        Director director = ((CompositeActor) container).getDirector();
        if (director != null) {
            director.invalidateSchedule();
            director.invalidateResolvedTypes();
        }
    }
    super.setContainer(container);
}

Output:
     }
-    if (container instanceof CompositeActor) {
+    if (container != null) {
         Director director = ((CompositeActor) container).getDirector();


Input:
public final static String getISO8601Date(long millis) {
    StringBuffer sb = new StringBuffer(19);
    Calendar cal = new GregorianCalendar();
    cal.setTimeInMillis(millis);
    sb.append(cal.get(Calendar.YEAR));
    sb.append('-');
    int month = cal.get(Calendar.MONTH) + 1;
    if (month < 10) {
        sb.append('0');
    }
    sb.append(month);
    sb.append('-');
    int date = cal.get(Calendar.DATE);
    if (date < 10) {
        sb.append('0');
    }
    sb.append(date);
    sb.append('T');
    int hour = cal.get(Calendar.HOUR_OF_DAY);
    if (hour < 10) {
        sb.append('0');
    }
    sb.append(hour);
    sb.append(':');
    int min = cal.get(Calendar.MINUTE);
    if (min < 10) {
        sb.append('0');
    }
    sb.append(min);
    sb.append(':');
    int sec = cal.get(Calendar.SECOND);
    if (sec < 10) {
        sb.append('0');
    }
    sb.append(sec);
    return sb.toString();
}

Output:
     StringBuffer sb = new StringBuffer(19);
-    Calendar cal = new GregorianCalendar();
+    Calendar cal = new GregorianCalendar(TIME_ZONE_UTC);
     cal.setTimeInMillis(millis);


Input:
public static void log(IStatus status) {
    getInstance().getLog().log(status);
}

Output:
 public static void log(IStatus status) {
-    getInstance().getLog().log(status);
+    Bundle bdl = FrameworkUtil.getBundle(EquinoxUIPlugin.class);
+    ILog log = bdl == null ? null : Platform.getLog(bdl);
+    if (log != null)
+        log.log(status);
 }


Input:
private void testDimensionCreate(IDocumentManager documentManager) throws IOException, BirtException, DataException {
    ILevelDefn[] levelDefs = new ILevelDefn[1];
    String[] attrs = { "String_Node_Str", "String_Node_Str" };
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, attrs);
    IDimension dimension = DimensionFactory.createDimension("String_Node_Str", documentManager, new OneLevelDataset(), levelDefs, false);
    IHierarchy hierarchy = dimension.getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    ILevel[] level = hierarchy.getLevels();
    assertEquals(level[0].getName(), "String_Node_Str");
    Dimension realDimension = (Dimension) dimension;
    for (int i = 0; i < OneLevelDataset.IDCol.length; i++) {
        IndexKey indexKey = realDimension.findFirst((Level) level[0], new Object[] { new Integer(OneLevelDataset.IDCol[i]) });
        assertEquals(indexKey.key[0], new Integer(OneLevelDataset.IDCol[i]));
        assertEquals(indexKey.dimensionPos, i);
        Member levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).members[0];
        assertEquals(levelMember.keyValues[0], new Integer(OneLevelDataset.IDCol[i]));
        assertEquals(levelMember.attributes[0], OneLevelDataset.NameCol[i]);
        assertEquals(levelMember.attributes[1], OneLevelDataset.AgeCol[i]);
        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).members[0];
        assertEquals(levelMember.keyValues[0], new Integer(OneLevelDataset.IDCol[i]));
        assertEquals(levelMember.attributes[0], OneLevelDataset.NameCol[i]);
        assertEquals(levelMember.attributes[1], OneLevelDataset.AgeCol[i]);
    }
}

Output:
         assertEquals(indexKey.dimensionPos, i);
-        Member levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).members[0];
-        assertEquals(levelMember.keyValues[0], new Integer(OneLevelDataset.IDCol[i]));
-        assertEquals(levelMember.attributes[0], OneLevelDataset.NameCol[i]);
-        assertEquals(levelMember.attributes[1], OneLevelDataset.AgeCol[i]);
-        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).members[0];
-        assertEquals(levelMember.keyValues[0], new Integer(OneLevelDataset.IDCol[i]));
-        assertEquals(levelMember.attributes[0], OneLevelDataset.NameCol[i]);
-        assertEquals(levelMember.attributes[1], OneLevelDataset.AgeCol[i]);
+        Member levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).getMembers()[0];
+        assertEquals(levelMember.getKeyValues()[0], new Integer(OneLevelDataset.IDCol[i]));
+        assertEquals(levelMember.getAttributes()[0], OneLevelDataset.NameCol[i]);
+        assertEquals(levelMember.getAttributes()[1], OneLevelDataset.AgeCol[i]);
+        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).getMembers()[0];
+        assertEquals(levelMember.getKeyValues()[0], new Integer(OneLevelDataset.IDCol[i]));
+        assertEquals(levelMember.getAttributes()[0], OneLevelDataset.NameCol[i]);
+        assertEquals(levelMember.getAttributes()[1], OneLevelDataset.AgeCol[i]);
     }


Input:
private static Permissions getPermissions(SolrDocument doc) {
    Permissions permissions = new Permissions();
    Map<PermissionType, Set<String>> userPermissions = new HashMap<>();
    for (PermissionType type : PermissionType.values()) {
        String key = RodaConstants.INDEX_PERMISSION_USERS_PREFIX + type;
        Set<String> users = new HashSet<>();
        users.addAll(objectToListString(doc.get(key)));
        userPermissions.put(type, users);
    }
    Map<PermissionType, Set<String>> groupPermissions = new HashMap<>();
    for (PermissionType type : PermissionType.values()) {
        String key = RodaConstants.INDEX_PERMISSION_GROUPS_PREFIX + type;
        Set<String> groups = new HashSet<>();
        groups.addAll(objectToListString(doc.get(key)));
        groupPermissions.put(type, groups);
    }
    permissions.setUsers(userPermissions);
    permissions.setGroups(groupPermissions);
    return permissions;
}

Output:
     Permissions permissions = new Permissions();
-    Map<PermissionType, Set<String>> userPermissions = new HashMap<>();
+    EnumMap<PermissionType, Set<String>> userPermissions = new EnumMap<>(PermissionType.class);
     for (PermissionType type : PermissionType.values()) {


Input:
private void internalRunTxnWithException(String mapName) {
    TransactionContext transactionContext = instance.newTransactionContext();
    transactionContext.beginTransaction();
    TransactionalMap<Object, Integer> txnMap = transactionContext.getMap(mapName);
    try {
        txnMap.values(TruePredicate.INSTANCE);
        failExpectedException("String_Node_Str");
    } catch (QueryResultSizeExceededException e) {
        EmptyStatement.ignore(e);
    }
    try {
        txnMap.keySet(TruePredicate.INSTANCE);
        failExpectedException("String_Node_Str");
    } catch (QueryResultSizeExceededException e) {
        EmptyStatement.ignore(e);
    }
    transactionContext.rollbackTransaction();
}

Output:
     try {
-        txnMap.values(TruePredicate.INSTANCE);
-        failExpectedException("String_Node_Str");
-    } catch (QueryResultSizeExceededException e) {
-        EmptyStatement.ignore(e);
+        transactionContext.beginTransaction();
+        TransactionalMap<Object, Integer> txnMap = transactionContext.getMap(mapName);
+        try {
+            txnMap.values(TruePredicate.INSTANCE);
+            failExpectedException("String_Node_Str");
+        } catch (QueryResultSizeExceededException e) {
+            checkException(e);
+        }
+        try {
+            txnMap.keySet(TruePredicate.INSTANCE);
+            failExpectedException("String_Node_Str");
+        } catch (QueryResultSizeExceededException e) {
+            checkException(e);
+        }
+    } finally {
+        transactionContext.rollbackTransaction();
     }


Input:
protected String determinePattern(String action) {
    if (action.equals("String_Node_Str")) {
        switch(type) {
            case INSTANCE:
                return String.format("String_Node_Str", type.getName(), ArgumentName.RUNTIME_ARGS);
            case NAMESPACE:
                return String.format("String_Node_Str", type.getName(), ArgumentName.RUNTIME_ARGS);
            case APP:
                return String.format("String_Node_Str", type.getName(), ArgumentName.RUNTIME_ARGS, type.getArgumentName());
            case FLOW:
            case MAPREDUCE:
            case WORKFLOW:
            case SERVICE:
            case SPARK:
                return String.format("String_Node_Str", type.getName(), ArgumentName.RUNTIME_ARGS, type.getArgumentName());
        }
    } else if (action.equals("String_Node_Str")) {
        switch(type) {
            case INSTANCE:
                return String.format("String_Node_Str", type.getName(), ArgumentName.LOCAL_FILE_PATH, ArgumentName.CONTENT_TYPE);
            case NAMESPACE:
                return String.format("String_Node_Str", type.getName(), ArgumentName.LOCAL_FILE_PATH, ArgumentName.CONTENT_TYPE);
            case APP:
                return String.format("String_Node_Str", type.getName(), ArgumentName.LOCAL_FILE_PATH, ArgumentName.CONTENT_TYPE, type.getArgumentName());
            case FLOW:
            case MAPREDUCE:
            case WORKFLOW:
            case SERVICE:
            case SPARK:
                return String.format("String_Node_Str", type.getName(), ArgumentName.LOCAL_FILE_PATH, ArgumentName.CONTENT_TYPE, type.getArgumentName());
        }
    }
    return "String_Node_Str";
}

Output:
 protected String determinePattern(String action) {
-    if (action.equals("String_Node_Str")) {
+    if ("String_Node_Str".equals(action)) {
         switch(type) {


Input:
private static void synchronizedComponent(List<JetBean> components, IProgressMonitor sub, List<JetBean> alreadyCompiledEmitters, TalendJetEmitter dummyEmitter, int monitorBuffer, IProgressMonitor monitorWrap) {
    for (JetBean jetBean : components) {
        if (!emitterPool.containsKey(jetBean)) {
            ComponentCompilations.deleteMarkers();
            TalendJetEmitter emitter = new TalendJetEmitter(getFullTemplatePath(jetBean), jetBean.getClassLoader(), jetBean.getFamily(), jetBean.getClassName(), jetBean.getLanguage(), jetBean.getCodePart(), dummyEmitter.getTalendEclipseHelper());
            if (monitorWrap.isCanceled()) {
                if (!CommonsPlugin.isHeadless()) {
                    Display.getDefault().syncExec(new Runnable() {
                        public void run() {
                            MessageDialog.openError(Display.getDefault().getActiveShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
                        }
                    });
                }
                return;
            }
            try {
                emitter.initialize(sub);
            } catch (JETException e) {
                log.error(Messages.getString("String_Node_Str") + e.getMessage(), e);
                continue;
            }
            if (emitter.getMethod() != null) {
                jetBean.setMethod(emitter.getMethod());
                jetBean.setClassName(emitter.getMethod().getDeclaringClass().getName());
                alreadyCompiledEmitters.add(jetBean);
            } else {
                jetFilesCompileFail.add(jetBean);
            }
            emitterPool.put(jetBean, emitter);
            monitorBuffer++;
            if (monitorBuffer % 100 == 0) {
                monitorWrap.worked(100);
                monitorBuffer = 0;
            }
        }
    }
}

Output:
             if (monitorWrap.isCanceled()) {
-                if (!CommonsPlugin.isHeadless()) {
+                if (!CommonUIPlugin.isFullyHeadless()) {
                     Display.getDefault().syncExec(new Runnable() {


Input:
private void appendCheckMusicsToPlayQ() {
    YTVideoSearchAdapter adpr = getAdapter();
    int[] checkedItems = adpr.getCheckItemSortedByTime();
    YTPlayer.Video[] vids = new YTPlayer.Video[checkedItems.length];
    int j = 0;
    for (int i : checkedItems) {
        vids[j++] = adpr.getYTPlayerVideo(i);
    }
    appendToPlayQ(vids);
    adpr.cleanChecked();
}

Output:
     int j = 0;
-    for (int i : checkedItems) {
-        vids[j++] = adpr.getYTPlayerVideo(i);
-    }
+    for (int i : checkedItems) vids[j++] = adpr.getYTPlayerVideo(i);
     appendToPlayQ(vids);


Input:
public void done(AVObject object, AVException e) {
    AVInstallation updatedInstallation = (AVInstallation) object;
    try {
        AVInstallation.writeInstallationFile(updatedInstallation);
    } catch (IOException e1) {
        if (AVOSCloud.showInternalDebugLog()) {
            e1.printStackTrace();
        }
    }
}

Output:
     try {
-        AVInstallation.writeInstallationFile(updatedInstallation);
+        AVInstallation.writeInstallationFile(AVOSCloud.applicationContext, updatedInstallation);
     } catch (IOException e1) {


Input:
public void add(final int arg0, final Object arg1) {
    eagerlyLoadDataCollection();
    List dataList = (List) dataCollection;
    if (dataList != null && !dataList.contains(arg1) && arg1 != null) {
        getPersistenceDelegator().persist(arg1);
        dataList.add(arg0, arg1);
    }
}

Output:
     List dataList = (List) dataCollection;
-    if (dataList != null && !dataList.contains(arg1) && arg1 != null) {
-        getPersistenceDelegator().persist(arg1);
+    if (dataList == null) {
+        dataList = new ArrayList();
+    }
+    if (arg1 != null && !dataList.contains(arg1)) {
         dataList.add(arg0, arg1);


Input:
public static boolean putServiceFunctionMonitor(MonitoringInfo monInfo, SfName sfName) {
    boolean ret = false;
    SfcSfDescMonBuilder sfDescMonBuilder = null;
    SfcSfDescMon sfDescMon = null;
    ServiceFunctionState dataSfcStateObject;
    printTraceStart(LOG);
    if (dataBroker != null) {
        sfDescMonBuilder = new SfcSfDescMonBuilder().setMonitoringInfo(monInfo);
        ServiceFunctionStateKey serviceFunctionStateKey = new ServiceFunctionStateKey(sfName);
        InstanceIdentifier<ServiceFunctionState> sfStateIID = InstanceIdentifier.builder(ServiceFunctionsState.class).child(ServiceFunctionState.class, serviceFunctionStateKey).build();
        dataSfcStateObject = SfcDataStoreAPI.readTransactionAPI(sfStateIID, LogicalDatastoreType.OPERATIONAL);
        if (dataSfcStateObject != null) {
            ServiceFunctionState1 sf1Temp = dataSfcStateObject.getAugmentation(ServiceFunctionState1.class);
            if (sf1Temp != null) {
                SfcSfDescMon sfDescMonTemp = sf1Temp.getSfcSfDescMon();
                sfDescMonBuilder.setDescriptionInfo(sfDescMonTemp.getDescriptionInfo());
            }
        }
        sfDescMon = sfDescMonBuilder.build();
        ServiceFunctionState1 sfState1 = new ServiceFunctionState1Builder().setSfcSfDescMon(sfDescMon).build();
        ServiceFunctionState serviceFunctionState = new ServiceFunctionStateBuilder().setKey(serviceFunctionStateKey).addAugmentation(ServiceFunctionState1.class, sfState1).build();
        if (dataSfcStateObject != null) {
            ret = SfcProviderServiceFunctionAPI.mergeServiceFunctionState(serviceFunctionState);
        } else {
            ret = SfcProviderServiceFunctionAPI.putServiceFunctionState(serviceFunctionState);
        }
    } else {
        LOG.error("String_Node_Str");
    }
    printTraceStop(LOG);
    return ret;
}

Output:
     boolean ret = false;
-    SfcSfDescMonBuilder sfDescMonBuilder = null;
-    SfcSfDescMon sfDescMon = null;
+    SfcSfDescMonBuilder sfDescMonBuilder;
+    SfcSfDescMon sfDescMon;
     ServiceFunctionState dataSfcStateObject;


Input:
synchronized static void release() {
    if (--count > 0) {
        LOGGER.trace("String_Node_Str", count);
        return;
    }
    final Disruptor<Log4jEventWrapper> temp = disruptor;
    if (temp == null) {
        LOGGER.trace("String_Node_Str", count);
        return;
    }
    LOGGER.trace("String_Node_Str", count);
    disruptor = null;
    temp.shutdown();
    final RingBuffer<Log4jEventWrapper> ringBuffer = temp.getRingBuffer();
    for (int i = 0; i < MAX_DRAIN_ATTEMPTS_BEFORE_SHUTDOWN; i++) {
        if (ringBuffer.hasAvailableCapacity(ringBuffer.getBufferSize())) {
            break;
        }
        try {
            Thread.sleep(HALF_A_SECOND);
        } catch (final InterruptedException e) {
        }
    }
    executor.shutdown();
    executor = null;
}

Output:
     disruptor = null;
-    temp.shutdown();
-    final RingBuffer<Log4jEventWrapper> ringBuffer = temp.getRingBuffer();
-    for (int i = 0; i < MAX_DRAIN_ATTEMPTS_BEFORE_SHUTDOWN; i++) {
-        if (ringBuffer.hasAvailableCapacity(ringBuffer.getBufferSize())) {
-            break;
-        }
+    for (int i = 0; hasBacklog(temp) && i < MAX_DRAIN_ATTEMPTS_BEFORE_SHUTDOWN; i++) {
         try {


Input:
String createSyslogMessage() {
    StringBuilder message = new StringBuilder();
    message.append(severityOfAlert(alertType)).append(MESSAGE_DELIMITER_STRING);
    InetAddress ip;
    try {
        ip = InetAddress.getLocalHost();
    } catch (UnknownHostException e) {
        ip = null;
    }
    if (ip != null) {
        message.append(ip.getHostName()).append(MESSAGE_DELIMITER_STRING);
    } else {
        message.append("String_Node_Str" + MESSAGE_DELIMITER_STRING);
    }
    if (alertType > 0) {
        message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(alertsMap.get(alertType)).append(MESSAGE_DELIMITER_STRING);
        if (dataCenterId != 0) {
            message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(dataCenterId).append(MESSAGE_DELIMITER_STRING);
        }
        if (podId != 0) {
            message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(podId).append(MESSAGE_DELIMITER_STRING);
        }
        if (clusterId != 0) {
            message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(clusterId).append(MESSAGE_DELIMITER_STRING);
        }
        if (sysMessage != null) {
            message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(sysMessage);
        } else {
            errorHandler.error("String_Node_Str");
        }
    } else {
        errorHandler.error("String_Node_Str");
    }
    return message.toString();
}

Output:
     }
-    if (alertType > 0) {
+    if (alertType >= 0) {
         message.append("String_Node_Str").append(_keyValueDelimiter).append("String_Node_Str").append(alertsMap.get(alertType)).append(MESSAGE_DELIMITER_STRING);


Input:
public void run(ProgressStatus progressStatus) {
    validationSuite.getValidationRules().forEach(validationRule -> validationRule.getViolations().clear());
    LocalSyncTransactionCommitListener localSyncTransactionCommitListener = LocalSyncProjectEventListenerAdapter.getProjectMapping(project).getLocalSyncTransactionCommitListener();
    if ((elementsToUpdate == null || elementsToUpdate.isEmpty()) && (elementsToDelete == null || elementsToDelete.isEmpty())) {
        Application.getInstance().getGUILog().log("String_Node_Str");
        return;
    }
    if (elementsToUpdate != null && !elementsToUpdate.isEmpty()) {
        boolean initialAutoNumbering = Application.getInstance().getProject().getOptions().isAutoNumbering();
        try {
            Application.getInstance().getGUILog().log("String_Node_Str" + NumberFormat.getInstance().format(elementsToUpdate.size()) + "String_Node_Str" + (elementsToUpdate.size() != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
            if (localSyncTransactionCommitListener != null) {
                localSyncTransactionCommitListener.setDisabled(true);
            }
            Application.getInstance().getProject().getOptions().isAutoNumbering();
            EMFBulkImporter emfBulkImporter = new EMFBulkImporter(NAME) {
                public void onSuccess() {
                    if (elementsToDelete != null && !elementsToDelete.isEmpty()) {
                        Application.getInstance().getGUILog().log("String_Node_Str" + NumberFormat.getInstance().format(elementsToDelete.size()) + "String_Node_Str" + (elementsToDelete.size() != 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
                        if (localSyncTransactionCommitListener != null) {
                            localSyncTransactionCommitListener.setDisabled(true);
                        }
                        if (!SessionManager.getInstance().isSessionCreated()) {
                            SessionManager.getInstance().createSession(UpdateClientElementAction.class.getName() + "String_Node_Str");
                        }
                        for (String id : elementsToDelete) {
                            Exception exception = null;
                            Element element = Converters.getIdToElementConverter().apply(id, project);
                            if (element == null) {
                                continue;
                            }
                            try {
                                ModelElementsManager.getInstance().removeElement(element);
                            } catch (ReadOnlyElementException | RuntimeException e) {
                                exception = e;
                            }
                            if (exception == null) {
                                successfulChangeValidationRule.addViolation(project.getPrimaryModel(), "String_Node_Str" + Changelog.ChangeType.DELETED.name() + "String_Node_Str" + element.getHumanName());
                            } else {
                                (exception instanceof ReadOnlyElementException ? editableValidationRule : failedChangeValidationRule).addViolation(element, "String_Node_Str" + exception.getMessage());
                                failedChangelog.addChange(id, null, Changelog.ChangeType.DELETED);
                            }
                        }
                        if (localSyncTransactionCommitListener != null) {
                            localSyncTransactionCommitListener.setDisabled(false);
                        }
                        if (SessionManager.getInstance().isSessionCreated()) {
                            SessionManager.getInstance().closeSession();
                        }
                    }
                }
                public void onFailure() {
                    onSuccess();
                }
            };
            Changelog<String, Pair<Element, ObjectNode>> changelog = emfBulkImporter.apply(elementsToUpdate, project, progressStatus);
            for (Map.Entry<Pair<Element, ObjectNode>, Exception> entry : emfBulkImporter.getFailedElementMap().entrySet()) {
                Element element = entry.getKey().getKey();
                ObjectNode objectNode = entry.getKey().getValue();
                Exception exception = entry.getValue();
                JsonNode sysmlIdJsonNode = objectNode.get(MDKConstants.ID_KEY);
                if (sysmlIdJsonNode == null || !sysmlIdJsonNode.isTextual()) {
                    continue;
                }
                String sysmlId = sysmlIdJsonNode.asText();
                String name = null;
                if (element == null || Project.isElementDisposed(element)) {
                    JsonNode nameJsonNode = objectNode.get(MDKConstants.NAME_KEY);
                    if (nameJsonNode != null && nameJsonNode.isTextual()) {
                        name = nameJsonNode.asText("String_Node_Str");
                    }
                    if (name == null || name.isEmpty()) {
                        name = "String_Node_Str";
                    }
                }
                ValidationRuleViolation validationRuleViolation = new ValidationRuleViolation(element != null && !Project.isElementDisposed(element) ? element : project.getPrimaryModel(), "String_Node_Str" + (element != null && !Project.isElementDisposed(element) ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + (element == null || Project.isElementDisposed(element) ? "String_Node_Str" + objectNode.get(MDKConstants.TYPE_KEY).asText("String_Node_Str") + "String_Node_Str" + name + "String_Node_Str" + sysmlId : "String_Node_Str") + ((element == null || Project.isElementDisposed(element)) && exception != null ? "String_Node_Str" : "String_Node_Str") + (exception != null ? "String_Node_Str" + (exception instanceof ReadOnlyElementException ? "String_Node_Str" : exception.getMessage()) : "String_Node_Str"));
                ActionsCategory copyActionsCategory = new ActionsCategory("String_Node_Str", "String_Node_Str");
                copyActionsCategory.setNested(true);
                validationRuleViolation.addAction(copyActionsCategory);
                copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", sysmlId));
                JsonNode diff = null;
                if (element != null) {
                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", "String_Node_Str" + element.getID()));
                    ObjectNode elementObjectNode = Converters.getElementToJsonConverter().apply(element, project);
                    if (elementObjectNode != null) {
                        try {
                            copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(elementObjectNode)));
                        } catch (JsonProcessingException ignored) {
                        }
                        diff = JsonPatchFunction.getInstance().apply(elementObjectNode, objectNode);
                    }
                }
                try {
                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(objectNode)));
                } catch (JsonProcessingException ignored) {
                }
                if (diff != null) {
                    try {
                        copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(diff)));
                    } catch (JsonProcessingException ignored) {
                    }
                }
                (exception instanceof ReadOnlyElementException ? editableValidationRule : failedChangeValidationRule).addViolation(validationRuleViolation);
                failedChangelog.addChange(sysmlId, objectNode, element != null && !Project.isElementDisposed(element) ? Changelog.ChangeType.UPDATED : Changelog.ChangeType.CREATED);
            }
            for (Map.Entry<Element, ObjectNode> entry : emfBulkImporter.getNonEquivalentElements().entrySet()) {
                Element element = entry.getKey();
                String sysmlId = element.getLocalID();
                ObjectNode clientElementObjectNode = Converters.getElementToJsonConverter().apply(element, project);
                ObjectNode serverElementObjectNode = entry.getValue();
                JsonNode diff = JsonPatchFunction.getInstance().apply(clientElementObjectNode, serverElementObjectNode);
                ValidationRuleViolation validationRuleViolation = new ValidationRuleViolation(entry.getKey(), "String_Node_Str");
                ActionsCategory copyActionsCategory = new ActionsCategory("String_Node_Str", "String_Node_Str");
                copyActionsCategory.setNested(true);
                validationRuleViolation.addAction(copyActionsCategory);
                copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", sysmlId));
                copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", "String_Node_Str" + element.getID()));
                try {
                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(clientElementObjectNode)));
                } catch (JsonProcessingException ignored) {
                }
                try {
                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(serverElementObjectNode)));
                } catch (JsonProcessingException ignored) {
                }
                try {
                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", JacksonUtils.getObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(diff)));
                } catch (JsonProcessingException ignored) {
                }
                equivalentElementValidationRule.addViolation(validationRuleViolation);
            }
            for (Changelog.ChangeType changeType : Changelog.ChangeType.values()) {
                for (Map.Entry<String, Pair<Element, ObjectNode>> entry : changelog.get(changeType).entrySet()) {
                    successfulChangeValidationRule.addViolation(new ValidationRuleViolation(entry.getValue().getKey(), "String_Node_Str" + SyncElement.Type.MMS.name() + "String_Node_Str" + changeType.name() + "String_Node_Str" + SyncElement.Type.LOCAL.name() + "String_Node_Str"));
                }
            }
        } finally {
            Application.getInstance().getProject().getOptions().setAutoNumbering(initialAutoNumbering);
            if (localSyncTransactionCommitListener != null) {
                localSyncTransactionCommitListener.setDisabled(false);
            }
        }
    }
    if (validationSuite.hasErrors()) {
        Utils.displayValidationWindow(project, validationSuite, validationSuite.getName());
    }
}

Output:
                 if (element != null) {
-                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", "String_Node_Str" + element.getID()));
+                    copyActionsCategory.addAction(new ClipboardAction("String_Node_Str", "String_Node_Str" + element.getLocalID()));
                     ObjectNode elementObjectNode = Converters.getElementToJsonConverter().apply(element, project);


Input:
protected String getCommandByTalendJob(String targetPlatform, IProcess process, String context, boolean needContext, int statisticPort, int tracePort, String... codeOptions) {
    String[] cmd = new String[] {};
    try {
        cmd = ProcessorUtilities.getCommandLine(targetPlatform, true, process, context, needContext, statisticPort, tracePort, codeOptions);
    } catch (ProcessorException e) {
        ExceptionHandler.process(e);
    }
    return ProcessorUtilities.generateCmdByTalendJob(cmd);
}

Output:
     try {
-        cmd = ProcessorUtilities.getCommandLine(targetPlatform, true, process, context, needContext, statisticPort, tracePort, codeOptions);
+        cmd = ProcessorUtilities.getCommandLine(true, targetPlatform, true, process, null, context, needContext, statisticPort, tracePort, codeOptions);
     } catch (ProcessorException e) {


Input:
public Promise<ResourceResponse, ResourceException> readInstance(Context serverContext, ReadRequest readRequest) {
    Map<String, String> uriVariables = getUriTemplateVariables(serverContext);
    final String tabName = getTabName(uriVariables);
    if (tabName == null) {
        return new BadRequestException("String_Node_Str").asPromise();
    }
    final String serverName = getServerName(uriVariables);
    if (serverName == null) {
        return new BadRequestException("String_Node_Str").asPromise();
    }
    try {
        ServiceConfigManager scm = getServiceConfigManager(serverContext);
        ServiceConfig serverConfigs = getServerConfigs(scm);
        Properties defaultAttributes = getAttributes(serverConfigs.getSubConfig(SERVER_DEFAULT_NAME));
        final ServiceConfig serverConfig = serverConfigs.getSubConfig(serverName);
        if (serverConfig == null) {
            return new BadRequestException("String_Node_Str" + serverName).asPromise();
        }
        Properties serverSpecificAttributes = getAttributes(serverConfig);
        Map<String, Object> defaultSection = new HashMap<>();
        JsonValue result = json(object());
        final boolean isServerDefault = serverName.equalsIgnoreCase(SERVER_DEFAULT_NAME);
        if (!isServerDefault) {
            result.put("String_Node_Str", defaultSection);
        }
        List<String> attributeNamesForTab;
        if (tabName.equalsIgnoreCase(DIRECTORY_CONFIGURATION_TAB_NAME)) {
            final String serverConfigXml = getServerConfigXml(serverConfig);
            if (serverConfigXml != null) {
                InputStream resourceStream = new StringInputStream(serverConfigXml);
                Document serverXml = dBuilder.parse(resourceStream);
                XPath xPath = XPathFactory.newInstance().newXPath();
                final String baseExpression = "String_Node_Str";
                String minConnections = (String) xPath.compile(baseExpression + "String_Node_Str" + DSConfigMgr.MIN_CONN_POOL).evaluate(serverXml, XPathConstants.STRING);
                String maxConnections = (String) xPath.compile(baseExpression + "String_Node_Str" + DSConfigMgr.MAX_CONN_POOL).evaluate(serverXml, XPathConstants.STRING);
                String dirDN = (String) xPath.compile(baseExpression + "String_Node_Str").evaluate(serverXml, XPathConstants.STRING);
                String directoryPassword = (String) xPath.compile(baseExpression + "String_Node_Str").evaluate(serverXml, XPathConstants.STRING);
                result.put("String_Node_Str", minConnections);
                result.put("String_Node_Str", maxConnections);
                result.put("String_Node_Str", dirDN);
                result.put("String_Node_Str", directoryPassword);
                NodeList serverNames = (NodeList) xPath.compile(baseExpression + "String_Node_Str").evaluate(serverXml, XPathConstants.NODESET);
                for (int i = 0; i < serverNames.getLength(); i++) {
                    final String directoryServerName = serverNames.item(i).getNodeValue();
                    final String serverExpression = baseExpression + "String_Node_Str" + directoryServerName + "String_Node_Str";
                    String hostExpression = serverExpression + "String_Node_Str";
                    String portExpression = serverExpression + "String_Node_Str";
                    String typeExpression = serverExpression + "String_Node_Str";
                    NodeList serverAttributes = (NodeList) xPath.compile(hostExpression + "String_Node_Str" + portExpression + "String_Node_Str" + typeExpression).evaluate(serverXml, XPathConstants.NODESET);
                    for (int a = 0; a < serverAttributes.getLength(); a++) {
                        final Node serverAttribute = serverAttributes.item(a);
                        result.addPermissive(new JsonPointer("String_Node_Str" + directoryServerName + "String_Node_Str" + serverAttribute.getNodeName()), serverAttribute.getNodeValue());
                    }
                }
            }
        } else {
            if (tabName.equalsIgnoreCase(ADVANCED_TAB_NAME)) {
                attributeNamesForTab = getAdvancedTabAttributeNames(serverConfig);
            } else {
                attributeNamesForTab = getDefaultValueNames(tabName);
            }
            Map<String, String> attributeNamesToSections = getAttributeNamesToSections(tabName);
            for (String attributeName : attributeNamesForTab) {
                final Object defaultAttribute = getValue(defaultAttributes, attributeName);
                final String sectionName = attributeNamesToSections.get(attributeName);
                if (defaultAttribute != null) {
                    defaultSection.put(sectionName + "String_Node_Str" + attributeName, defaultAttribute);
                }
                final Object serverSpecificAttribute = getValue(serverSpecificAttributes, attributeName);
                if (serverSpecificAttribute != null) {
                    result.putPermissive(new JsonPointer(sectionName + "String_Node_Str" + attributeName), serverSpecificAttribute);
                }
            }
        }
        return newResultPromise(newResourceResponse(serverName + "String_Node_Str" + tabName, String.valueOf(result.hashCode()), result));
    } catch (SMSException | SSOException | ParserConfigurationException | SAXException | IOException | XPathExpressionException e) {
        logger.error("String_Node_Str" + tabName, e);
    }
    return new BadRequestException("String_Node_Str" + tabName).asPromise();
}

Output:
             for (String attributeName : attributeNamesForTab) {
-                final Object defaultAttribute = getValue(defaultAttributes, attributeName);
-                final String sectionName = attributeNamesToSections.get(attributeName);
+                final String defaultAttribute = (String) defaultAttributes.get(attributeName);
+                final String sectionName = tabName.equals(ADVANCED_TAB_NAME) ? "String_Node_Str" : attributeNamesToSections.get(attributeName);
+                String attributePath = sectionName == null ? "String_Node_Str" : sectionName + "String_Node_Str";
                 if (defaultAttribute != null) {


Input:
private ServerSocket createSSLServerSocket(String type, InetSocketAddress inetSocketAddress) throws IOException {
    if (inetSocketAddress == null) {
        throw new IOException(getFormatMessage("String_Node_Str", new Object[] { null }));
    }
    int port = inetSocketAddress.getPort();
    Integer iport = new Integer(port);
    SSLInfo sslInfo = (SSLInfo) portToSSLInfo.get(iport);
    if (sslInfo == null) {
        throw new IOException(getFormatMessage("String_Node_Str", new Object[] { iport }));
    }
    SSLServerSocketFactory ssf = sslInfo.getContext().getServerSocketFactory();
    String[] ssl3TlsCiphers = sslInfo.getSsl3TlsCiphers();
    String[] ssl2Ciphers = sslInfo.getSsl2Ciphers();
    String[] ciphers = null;
    if (ssl3TlsCiphers != null || ssl2Ciphers != null) {
        String[] socketCiphers = ssf.getDefaultCipherSuites();
        ciphers = mergeCiphers(socketCiphers, ssl3TlsCiphers, ssl2Ciphers);
    }
    String[] cs = null;
    if (_logger.isLoggable(Level.FINE)) {
        cs = ssf.getSupportedCipherSuites();
        for (int i = 0; i < cs.length; ++i) {
            _logger.log(Level.FINE, "String_Node_Str" + cs[i]);
        }
    }
    ServerSocket ss = null;
    try {
        ss = ssf.createServerSocket(port, BACKLOG, inetSocketAddress.getAddress());
        if (ciphers != null) {
            ((SSLServerSocket) ss).setEnabledCipherSuites(ciphers);
        }
    } catch (IOException e) {
        _logger.log(Level.SEVERE, "String_Node_Str", new Object[] { type, String.valueOf(port) });
        _logger.log(Level.SEVERE, "String_Node_Str", e);
        throw e;
    }
    try {
        if (type.equals(SSL_MUTUALAUTH)) {
            _logger.log(Level.FINE, "String_Node_Str");
            ((SSLServerSocket) ss).setNeedClientAuth(true);
        }
    } catch (Exception e) {
        _logger.log(Level.SEVERE, "String_Node_Str", e);
        throw new IOException(e.getMessage());
    }
    if (_logger.isLoggable(Level.FINE)) {
        _logger.log(Level.FINE, "String_Node_Str" + ss);
    }
    return ss;
}

Output:
     int port = inetSocketAddress.getPort();
-    Integer iport = new Integer(port);
+    Integer iport = Integer.valueOf(port);
     SSLInfo sslInfo = (SSLInfo) portToSSLInfo.get(iport);


Input:
private void modifySourceMemberAccessesInTargetClass(MethodDeclaration newMethodDeclaration) {
    ExpressionExtractor extractor = new ExpressionExtractor();
    List<Expression> sourceMethodInvocations = extractor.getMethodInvocations(sourceMethod.getBody());
    List<Expression> newMethodInvocations = extractor.getMethodInvocations(newMethodDeclaration.getBody());
    List<Expression> expressionsToBeRemoved = new ArrayList<Expression>();
    int k = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            MethodDeclaration[] sourceMethodDeclarations = sourceTypeDeclaration.getMethods();
            for (MethodDeclaration sourceMethodDeclaration : sourceMethodDeclarations) {
                if (identicalSignature(sourceMethodDeclaration, methodInvocation)) {
                    MethodInvocation delegation = isDelegate(sourceMethodDeclaration);
                    if (delegation != null) {
                        ITypeBinding declaringClassTypeBinding = delegation.resolveMethodBinding().getDeclaringClass();
                        if (declaringClassTypeBinding.getQualifiedName().equals(targetTypeDeclaration.resolveBinding().getQualifiedName())) {
                            if (delegation.getExpression() != null) {
                                MethodInvocation newMethodInvocation = (MethodInvocation) ASTNode.copySubtree(newMethodDeclaration.getAST(), delegation);
                                targetRewriter.remove(newMethodInvocation.getExpression(), null);
                                targetRewriter.replace(newMethodInvocations.get(k), newMethodInvocation, null);
                            }
                            expressionsToBeRemoved.add(methodInvocation);
                        }
                    }
                }
            }
        }
        k++;
    }
    for (Expression expression : expressionsToBeRemoved) {
        int index = sourceMethodInvocations.indexOf(expression);
        sourceMethodInvocations.remove(index);
        newMethodInvocations.remove(index);
    }
    List<Expression> sourceFieldInstructions = extractor.getVariableInstructions(sourceMethod.getBody());
    List<Expression> newFieldInstructions = extractor.getVariableInstructions(newMethodDeclaration.getBody());
    SimpleName parameterName = null;
    int numberOfOccurences = 0;
    int i = 0;
    for (Expression expression : sourceMethodInvocations) {
        if (expression instanceof MethodInvocation) {
            MethodInvocation methodInvocation = (MethodInvocation) expression;
            IMethodBinding methodBinding = methodInvocation.resolveMethodBinding();
            if (methodBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding())) {
                numberOfOccurences++;
                if (numberOfOccurences == 1) {
                    parameterName = addSourceClassParameter(newMethodDeclaration);
                }
                MethodInvocation newMethodInvocation = (MethodInvocation) newMethodInvocations.get(i);
                targetRewriter.set(newMethodInvocation, MethodInvocation.EXPRESSION_PROPERTY, parameterName, null);
            }
        }
        i++;
    }
    int j = 0;
    for (Expression expression : sourceFieldInstructions) {
        SimpleName simpleName = (SimpleName) expression;
        IBinding binding = simpleName.resolveBinding();
        if (binding.getKind() == IBinding.VARIABLE) {
            IVariableBinding variableBinding = (IVariableBinding) binding;
            if (variableBinding.isField() && variableBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
                numberOfOccurences++;
                if (numberOfOccurences == 1) {
                    parameterName = addSourceClassParameter(newMethodDeclaration);
                }
                SimpleName expressionName = (SimpleName) newFieldInstructions.get(j);
                AST ast = newMethodDeclaration.getAST();
                if (expressionName.getParent() instanceof FieldAccess) {
                    SimpleName qualifier = ast.newSimpleName(parameterName.getIdentifier());
                    targetRewriter.set(expressionName.getParent(), FieldAccess.EXPRESSION_PROPERTY, qualifier, null);
                } else {
                    SimpleName newSimpleName = ast.newSimpleName(expressionName.getIdentifier());
                    SimpleName qualifier = ast.newSimpleName(parameterName.getIdentifier());
                    QualifiedName newQualifiedName = ast.newQualifiedName(qualifier, newSimpleName);
                    targetRewriter.replace(expressionName, newQualifiedName, null);
                }
            }
        }
        j++;
    }
}

Output:
             IVariableBinding variableBinding = (IVariableBinding) binding;
-            if (variableBinding.isField() && variableBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0) {
+            if (variableBinding.isField() && variableBinding.getDeclaringClass().equals(sourceTypeDeclaration.resolveBinding()) && (variableBinding.getModifiers() & Modifier.STATIC) == 0 && !targetClassVariableNames.contains(simpleName.getIdentifier())) {
                 numberOfOccurences++;


Input:
public void onReceive(Context context, Intent intent) {
    Tools.HangarLog("String_Node_Str");
    if (mContext == null)
        mContext = context;
    AppWidgetManager mgr = AppWidgetManager.getInstance(context);
    int[] ids = mgr.getAppWidgetIds(new ComponentName(context, AppsWidget.class));
    for (int id : ids) {
        Tools.HangarLog("String_Node_Str" + id);
        try {
            Bundle options = mgr.getAppWidgetOptions(id);
            updateAppWidget(context, mgr, id, options);
        } catch (NullPointerException e) {
            e.printStackTrace();
            Tools.HangarLog("String_Node_Str");
        }
    }
    super.onReceive(context, intent);
}

Output:
 public void onReceive(Context context, Intent intent) {
-    Tools.HangarLog("String_Node_Str");
+    Tools.HangarLog("String_Node_Str" + this.getClass().getCanonicalName() + "String_Node_Str");
     if (mContext == null)


Input:
public void ExpandTemplate__missing_template() {
    fxt.Init_page("String_Node_Str");
    fxt.Test_scrib_proc_err(lib, Scrib_lib_mw.Invk_expandTemplate, Object_.Ary("String_Node_Str", "String_Node_Str", Scrib_kv_utl_.flat_many_(1, "String_Node_Str")), "String_Node_Str");
}

Output:
     fxt.Init_page("String_Node_Str");
-    fxt.Test_scrib_proc_err(lib, Scrib_lib_mw.Invk_expandTemplate, Object_.Ary("String_Node_Str", "String_Node_Str", Scrib_kv_utl_.flat_many_(1, "String_Node_Str")), "String_Node_Str");
+    fxt.Test_scrib_proc_err(lib, Scrib_lib_mw.Invk_expandTemplate, Object_.Ary("String_Node_Str", "String_Node_Str", Scrib_kv_utl_.flat_many_(2, "String_Node_Str")), "String_Node_Str");
 }


Input:
public EventListElement render() {
    try {
        String eventKey = getEventKey(), eventName = getEventName(), location = getLocation();
        if (getShortName() == null || shortName.isEmpty()) {
            return new EventListElement(eventKey, eventName, getDateString(), location);
        } else {
            return new EventListElement(eventKey, getShortName(), getDateString(), location);
        }
    } catch (FieldNotDefinedException e) {
        Log.w(Constants.LOG_TAG, "String_Node_Str" + "String_Node_Str");
        return null;
    }
}

Output:
     try {
-        String eventKey = getEventKey(), eventName = getEventName(), location = getLocation();
+        String eventKey = getEventKey(), eventName = getShortName(), location = getLocation();
         if (getShortName() == null || shortName.isEmpty()) {


Input:
public T hasNoneOf(Iterable<?> vals) {
    return this.hasNoneOf(vals, this.query.isValidatingTypes());
}

Output:
 public T hasNoneOf(Iterable<?> vals) {
-    return this.hasNoneOf(vals, this.query.isValidatingTypes());
+    Assert.parametersNotNull("String_Node_Str", vals);
+    Assert.parameterNotEmpty(vals, "String_Node_Str");
+    return addCrit(FilterOperator.NOT_IN, vals);
 }


Input:
public void doWithAssociation(Association association) {
    PersistentProperty persistentProperty = association.getInverse();
    String mapKey = clazzName + "String_Node_Str" + persistentProperty.getName();
    Object fromVal = fromWrapper.getProperty(persistentProperty);
    Object defaultVal = defaultValues.get(mapKey);
    if (null != fromVal && !fromVal.equals(defaultVal)) {
        targetWrapper.setProperty(persistentProperty, fromVal);
    }
}

Output:
     Object fromVal = fromWrapper.getProperty(persistentProperty);
-    Object defaultVal = defaultValues.get(mapKey);
-    if (null != fromVal && !fromVal.equals(defaultVal)) {
+    if (null != fromVal && !fromVal.equals(targetWrapper.getProperty(persistentProperty))) {
         targetWrapper.setProperty(persistentProperty, fromVal);


Input:
public boolean parseCommand(String message) {
    if (closed) {
        return true;
    }
    if (message.equals(server.getCommandParser().commandPrefix() + "String_Node_Str"))
        message = lastCommand;
    PlayerCommand command = server.getCommandParser().getPlayerCommand(message);
    if (command == null) {
        return false;
    }
    boolean invalidCommand = command.getName() == null;
    if (invalidCommand && !commandAllowed(command.getName())) {
        addMessage("String_Node_Str");
        return true;
    }
    command.execute(this, message);
    lastCommand = message;
    return !((server.permissions.commandShouldPassThroughToMod(command.getName()) || server.options.getBoolean("String_Node_Str") || invalidCommand) && server.options.contains("String_Node_Str"));
}

Output:
     boolean invalidCommand = command.getName() == null;
-    if (invalidCommand && !commandAllowed(command.getName())) {
+    if (!invalidCommand && !commandAllowed(command.getName())) {
         addMessage("String_Node_Str");


Input:
private void updateShownCount() {
    float step = mMax / mStarCount / 2;
    int shown = Math.round(mRating / step);
    if (shown >= mStarCount * 2) {
        mShownStarCount = mStarCount;
        mShownStarHalfCount = 0;
        mShownStarOutlineCount = 0;
    } else {
        mShownStarCount = shown / 2;
        mShownStarHalfCount = shown % 2;
        mShownStarOutlineCount = mStarCount - mShownStarCount - mShownStarHalfCount;
    }
}

Output:
     float step = mMax / mStarCount / 2;
-    int shown = Math.round(mRating / step);
+    int shown = (int) Math.ceil(mRating / step);
     if (shown >= mStarCount * 2) {


Input:
public GainInfo computeImpurity(double[] stats, ColumnConfig config) {
    int numClasses = super.statsSize;
    double[] statsByClasses = new double[numClasses];
    for (int i = 0; i < stats.length / numClasses; i++) {
        for (int j = 0; j < numClasses; j++) {
            double oneStatValue = stats[i * super.statsSize + j];
            statsByClasses[j] += oneStatValue;
        }
    }
    InternalEntropyInfo info = getEntropyInterInfo(statsByClasses);
    Predict predict = new Predict(info.indexOfLargestElement, statsByClasses[1] / info.sumAll);
    double[] leftStatByClasses = new double[numClasses];
    double[] rightStatByClasses = new double[numClasses];
    List<GainInfo> internalGainList = new ArrayList<GainInfo>();
    Set<String> leftCategories = config.isCategorical() ? new HashSet<String>() : null;
    for (int i = 0; i < (stats.length / numClasses - 1); i++) {
        for (int j = 0; j < leftStatByClasses.length; j++) {
            leftStatByClasses[j] += stats[i * numClasses + j];
        }
        InternalEntropyInfo leftInfo = getEntropyInterInfo(leftStatByClasses);
        Predict leftPredict = new Predict(leftInfo.indexOfLargestElement, leftStatByClasses[1] / leftInfo.sumAll);
        for (int j = 0; j < leftStatByClasses.length; j++) {
            rightStatByClasses[j] = statsByClasses[j] - leftStatByClasses[j];
        }
        InternalEntropyInfo rightInfo = getEntropyInterInfo(rightStatByClasses);
        Predict rightPredict = new Predict(rightInfo.indexOfLargestElement, rightStatByClasses[1] / rightInfo.sumAll);
        double gain = info.impurity - (leftInfo.sumAll / info.sumAll) * leftInfo.impurity - (rightInfo.sumAll / info.sumAll) * rightInfo.impurity;
        Split split = null;
        if (config.isCategorical()) {
            leftCategories.add(config.getBinCategory().get(i));
            split = new Split(config.getColumnNum(), FeatureType.CATEGORICAL, 0d, leftCategories);
        } else {
            split = new Split(config.getColumnNum(), FeatureType.CONTINUOUS, config.getBinBoundary().get(i + 1), null);
        }
        internalGainList.add(new GainInfo(gain, info.impurity, predict, leftInfo.impurity, rightInfo.impurity, leftPredict, rightPredict, split));
    }
    return GainInfo.getGainInfoByMaxGain(internalGainList);
}

Output:
     InternalEntropyInfo info = getEntropyInterInfo(statsByClasses);
-    Predict predict = new Predict(info.indexOfLargestElement, statsByClasses[1] / info.sumAll);
+    Predict predict = new Predict(info.sumAll == 0d ? 0d : statsByClasses[1] / info.sumAll, info.indexOfLargestElement);
     double[] leftStatByClasses = new double[numClasses];


Input:
private QueryTerm parseTerm() {
    trim();
    if (charAt0() == '(') {
        throw new UnsupportedOperationException();
    }
    Object value = null;
    String paramName = null;
    COMP_OP op = null;
    String fName = null;
    Class<?> type = null;
    int pos0 = pos();
    char c = charAt0();
    while ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c == '_') || (c == '.')) {
        inc();
        if (c == '.') {
            String dummy = substring(pos0, pos());
            if (dummy.equals("String_Node_Str")) {
                pos0 = pos();
            } else {
                fName = substring(pos0, pos() - 1);
                pos0 = pos();
            }
        }
        c = charAt0();
    }
    if (fName == null) {
        fName = substring(pos0, pos());
    }
    if (fName.equals("String_Node_Str")) {
        throw new JDOUserException("String_Node_Str" + pos0 + "String_Node_Str");
    }
    pos0 = pos();
    trim();
    try {
        ZooFieldDef f = fields.get(fName);
        if (f == null) {
            throw new JDOFatalInternalException("String_Node_Str" + fName);
        }
        type = f.getJavaType();
    } catch (SecurityException e) {
        throw new JDOUserException("String_Node_Str" + fName, e);
    }
    c = charAt0();
    char c2 = charAt(1);
    char c3 = charAt(2);
    if (c == '=' && c2 == '=' && c3 == ' ') {
        op = COMP_OP.EQ;
    } else if (c == '<') {
        if (c2 == '=' && c3 == ' ') {
            op = COMP_OP.LE;
        } else if (c2 == ' ') {
            op = COMP_OP.L;
        }
    } else if (c == '>') {
        if (c2 == '=' && c3 == ' ') {
            op = COMP_OP.AE;
        } else if (c2 == ' ') {
            op = COMP_OP.A;
        }
    } else if (c == '!' && c2 == '=' && c3 == ' ') {
        op = COMP_OP.NE;
    }
    if (op == null) {
        throw new JDOUserException("String_Node_Str" + c + c2 + c3 + "String_Node_Str" + pos0);
    }
    inc(op._len);
    trim();
    pos0 = pos();
    c = charAt0();
    if ((len() >= 4 && substring(pos0, pos0 + 4).equals("String_Node_Str")) && (len() == 4 || (len() > 4 && (charAt(4) == ' ' || charAt(4) == ')')))) {
        if (type.isPrimitive()) {
            throw new JDOUserException("String_Node_Str" + pos0);
        }
        value = NULL;
    } else if (c == '"' || c == '\'') {
        boolean singleQuote = c == '\'';
        if (!String.class.isAssignableFrom(type)) {
            throw new JDOUserException("String_Node_Str" + type.getName());
        }
        inc();
        pos0 = pos();
        c = charAt0();
        while (true) {
            if ((!singleQuote && c == '"') || (singleQuote && c == '\'')) {
                break;
            } else if (c == '\\') {
                inc();
            }
            inc();
            c = charAt0();
        }
        value = substring(pos0, pos());
        inc();
    } else if (c == '-' || (c > '0' && c < '9')) {
        pos0 = pos();
        boolean isHex = false;
        while (!isFinished()) {
            c = charAt0();
            if (c == ')' || c == ' ') {
                break;
            } else if (c == 'x') {
                isHex = true;
            }
            inc();
        }
        if (type == Double.TYPE || type == Double.class) {
            value = Double.parseDouble(substring(pos0, pos()));
        } else if (type == Float.TYPE || type == Float.class) {
            value = Float.parseFloat(substring(pos0, pos()));
        } else if (type == Long.TYPE || type == Long.class) {
            if (isHex) {
                value = Long.parseLong(substring(pos0, pos()), 16);
            } else {
                value = Long.parseLong(substring(pos0, pos()));
            }
        } else if (type == Integer.TYPE || type == Integer.class) {
            if (isHex) {
                value = Integer.parseInt(substring(pos0, pos()), 16);
            } else {
                value = Integer.parseInt(substring(pos0, pos()));
            }
        } else if (type == Short.TYPE || type == Short.class) {
            if (isHex) {
                value = Short.parseShort(substring(pos0, pos()), 16);
            } else {
                value = Short.parseShort(substring(pos0, pos()));
            }
        } else if (type == Byte.TYPE || type == Byte.class) {
            if (isHex) {
                value = Byte.parseByte(substring(pos0, pos()), 16);
            } else {
                value = Byte.parseByte(substring(pos0, pos()));
            }
        } else if (type == BigDecimal.class) {
            value = new BigDecimal(substring(pos0, pos()));
        } else if (type == BigInteger.class) {
            value = new BigInteger(substring(pos0, pos()));
        } else {
            throw new JDOUserException("String_Node_Str" + type.getName());
        }
    } else if (type == Boolean.TYPE || type == Boolean.class) {
        if (substring(pos0, pos0 + 4).toLowerCase().equals("String_Node_Str") && (isFinished(4) || charAt(4) == ' ' || charAt(4) == ')')) {
            value = true;
            inc(4);
        } else if (substring(pos0, pos0 + 5).toLowerCase().equals("String_Node_Str") && (isFinished(5) || charAt(5) == ' ' || charAt(5) == ')')) {
            value = false;
            inc(5);
        } else {
            throw new JDOUserException("String_Node_Str" + substring(pos0, pos0 + 5));
        }
    } else {
        while ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c == '_') || (c == '"')) {
            inc();
            if (isFinished())
                break;
            c = charAt0();
        }
        paramName = substring(pos0, pos());
    }
    if (fName == null || (value == null && paramName == null) || op == null) {
        throw new JDOUserException("String_Node_Str" + pos() + "String_Node_Str" + str);
    }
    trim();
    return new QueryTerm(op, paramName, value, clsDef.getField(fName));
}

Output:
         inc();
-    } else if (c == '-' || (c > '0' && c < '9')) {
+    } else if (c == '-' || (c >= '0' && c <= '9')) {
         pos0 = pos();


Input:
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    super.onCreateContextMenu(menu, v, menuInfo);
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.musics_context, menu);
    if (isUserPlayList(mPlid))
        menu.findItem(R.id.plthumbnail).setVisible(true);
    else
        menu.findItem(R.id.plthumbnail).setVisible(false);
}

Output:
     inflater.inflate(R.menu.musics_context, menu);
-    if (isUserPlayList(mPlid))
+    if (isUserPlayList(mPlid)) {
         menu.findItem(R.id.plthumbnail).setVisible(true);


Input:
public void calculate() {
    for (Spatial s : gNode.getChildren()) s.removeFromParent();
    Node pNode = new Node();
    if (toRender != null)
        for (int i = 0; i < toRender.faces.size(); i++) try {
            HalfFace f = toRender.faces.get(i);
            SuperFace sf = (SuperFace) f;
            PlanSkeleton skel = calc(sf);
            if (skel != null)
                setSkel(skel, skel.output, sf);
        } catch (Throwable th) {
            th.printStackTrace();
        }
    if (!pNode.getChildren().isEmpty())
        tweed.frame.addGen(new JmeGen("String_Node_Str", tweed, pNode), false);
    gNode.updateModelBound();
    gNode.updateGeometricState();
    super.calculate();
}

Output:
             SuperFace sf = (SuperFace) f;
-            PlanSkeleton skel = calc(sf);
-            if (skel != null)
-                setSkel(skel, skel.output, sf);
+            Rendered previouslyRendered = geometry.get(sf);
+            if (previouslyRendered.skel != null) {
+                setSkel(previouslyRendered.skel, previouslyRendered.output, sf);
+            } else {
+                PlanSkeleton skel = calc(sf);
+                if (skel != null)
+                    setSkel(skel, skel.output, sf);
+            }
         } catch (Throwable th) {


Input:
public void startListening() {
    String hostName = TCPContext.getHostName(thisInfo);
    int port = TCPContext.getPort(thisInfo);
    looper = new Progress();
    server = new Server(config, hostName, port, looper, new ChannelServerChannelHandler());
    server.start();
}

Output:
     looper = new Progress();
-    server = new Server(config, hostName, port, looper, new ChannelServerChannelHandler());
+    server = new Server(config, hostName, port, looper, new ServerChannelHandler(), true);
     server.start();


Input:
public boolean canStartMaster() {
    List<CheckRunner.Failure> failures = checkRunner.runChecks();
    if (!failures.isEmpty()) {
        for (CheckRunner.Failure failure : failures) {
            LOG.error("String_Node_Str", failure.getName(), failure.getException().getClass().getSimpleName(), failure.getException().getMessage());
            if (failure.getException().getCause() != null) {
                LOG.error("String_Node_Str", ExceptionUtils.getRootCauseMessage(failure.getException().getCause()));
            }
        }
        LOG.error("String_Node_Str" + "String_Node_Str");
        return false;
    }
    return true;
}

Output:
         for (CheckRunner.Failure failure : failures) {
-            LOG.error("String_Node_Str", failure.getName(), failure.getException().getClass().getSimpleName(), failure.getException().getMessage());
+            LOG.error("String_Node_Str", failure.getName(), failure.getException().getClass().getSimpleName(), failure.getException().getMessage(), failure.getException());
             if (failure.getException().getCause() != null) {