Input:
private void doMarshal(SDOProperty prop, DataObject value, SDOChangeSummary cs, Element csNode, SDODataObject modifiedObject, List deletedXPaths, String xpathToCS, String sdoPrefix, String rootElementName) {
    if (value == null) {
        DOMRecord row = new DOMRecord(csNode);
        Session session = ((SDOXMLHelper) ((SDOTypeHelper) typeHelper).getHelperContext().getXMLHelper()).getXmlContext().getSession(0);
        row.setSession((AbstractSession) session);
        marshalNilAttribute(prop, row);
        return;
    }
    boolean isDeleted = false;
    Object original = cs.getReverseDeletedMap().get(value);
    if ((original != null) && cs.isDeleted((DataObject) original)) {
        isDeleted = true;
    }
    String qualifiedName = getXPathForProperty(prop);
    String uri = null;
    if (prop.isOpenContent()) {
        uri = prop.getUri();
    } else {
        uri = prop.getContainingType().getURI();
    }
    if (isDeleted) {
        String pathToNode = getPathFromAncestor(((SDODataObject) original), modifiedObject, cs);
        String containerPath = null;
        containerPath = getQualifiedName(modifiedObject);
        deletedXPaths.add(xpathToCS + containerPath + SDOConstants.SDO_XPATH_SEPARATOR_FRAGMENT + pathToNode);
        XMLRoot xmlroot = new XMLRoot();
        xmlroot.setObject(value);
        xmlroot.setNamespaceURI(uri);
        xmlroot.setLocalName(qualifiedName);
        xmlMarshaller.marshal(xmlroot, csNode);
    } else {
        Element modifiedElement = null;
        if (uri == null) {
            modifiedElement = csNode.getOwnerDocument().createElement(qualifiedName);
        } else {
            modifiedElement = csNode.getOwnerDocument().createElementNS(uri, qualifiedName);
        }
        csNode.appendChild(modifiedElement);
        String nextPath = getPathFromAncestor((SDODataObject) original, (SDODataObject) marshalledObject, cs);
        if (nextPath == SDOConstants.EMPTY_STRING) {
            modifiedElement.setAttributeNS(SDOConstants.SDO_URL, sdoPrefix + SDOConstants.SDO_XPATH_NS_SEPARATOR_FRAGMENT + SDOConstants.CHANGESUMMARY_REF, SDOConstants.SDO_CHANGESUMMARY_REF_PATH_PREFIX + SDOConstants.SDO_XPATH_SEPARATOR_FRAGMENT + rootElementName);
        } else {
            modifiedElement.setAttributeNS(SDOConstants.SDO_URL, sdoPrefix + SDOConstants.SDO_XPATH_NS_SEPARATOR_FRAGMENT + SDOConstants.CHANGESUMMARY_REF, SDOConstants.SDO_CHANGESUMMARY_REF_PATH_PREFIX + SDOConstants.SDO_XPATH_SEPARATOR_FRAGMENT + rootElementName + "String_Node_Str" + nextPath);
        }
        if ((((SDODataObject) original).getContainmentProperty() != null) && ((SDODataObject) original).getContainmentProperty().getType().isDataObjectType()) {
            String schemaContext = ((SDOType) value.getType()).getXmlDescriptor().getSchemaReference().getSchemaContext();
            QName schemaContextQName = ((SDOType) value.getType()).getXmlDescriptor().getSchemaReference().getSchemaContextAsQName(((SDOType) value.getType()).getXmlDescriptor().getNonNullNamespaceResolver());
            if (schemaContext != null) {
                String typeValue = schemaContext.substring(1, schemaContext.length());
                String schemaInstancePrefix = ((SDOType) value.getType()).getXmlDescriptor().getNonNullNamespaceResolver().resolveNamespaceURI(XMLConstants.SCHEMA_INSTANCE_URL);
                String schemaContextUri = schemaContextQName.getNamespaceURI();
                String schemaContextPrefix = ((SDOType) value.getType()).getXmlDescriptor().getNonNullNamespaceResolver().resolveNamespaceURI(schemaContextUri);
                if (schemaContextPrefix != null) {
                    modifiedElement.setAttributeNS(XMLConstants.XMLNS_URL, XMLConstants.XMLNS + "String_Node_Str" + schemaContextPrefix, schemaContextQName.getNamespaceURI());
                }
                modifiedElement.setAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, schemaInstancePrefix + "String_Node_Str" + XMLConstants.SCHEMA_TYPE_ATTRIBUTE, typeValue);
            }
        }
    }
}

Output:
     } else {
-        uri = prop.getContainingType().getURI();
+        uri = ((XMLField) ((SDOProperty) prop).getXmlMapping().getField()).getXPathFragment().getNamespaceURI();
     }


Input:
public void widgetSelected(SelectionEvent e) {
    if (ExecutionLanguage.JAVA == currentEngine) {
        try {
            DrillDownEditorInput input = new DrillDownEditorInput(analysis, currentDataEntity, itemEntity);
            if (input.computeColumnValueLength(input.filterAdaptDataList())) {
                CorePlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getActivePage().openEditor(input, "String_Node_Str");
            } else {
                MessageDialog.openWarning(null, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
            }
        } catch (PartInitException e1) {
            e1.printStackTrace();
        }
    } else {
        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                Connection tdDataProvider = SwitchHelpers.CONNECTION_SWITCH.doSwitch(analysis.getContext().getConnection());
                String query = itemEntity.getQuery();
                String editorName = currentIndicator.getName();
                SqlExplorerUtils.getDefault().runInDQViewer(tdDataProvider, query, editorName);
            }
        });
    }
}

Output:
         } catch (PartInitException e1) {
-            e1.printStackTrace();
+            log.error(e1, e1);
         }


Input:
private final HashGroupifyEntry addInternal(final int[] key, final int hash, final int representant, int count, final int pcount) {
    if (subset != null && !subset.contains(representant)) {
        count = 0;
    }
    int index = hash & (buckets.length - 1);
    HashGroupifyEntry entry = findEntry(key, index, hash);
    if (entry == null) {
        if (++elementCount > threshold) {
            rehash();
            index = hash & (buckets.length - 1);
        }
        entry = createEntry(key, index, hash, representant);
    }
    entry.count += count;
    if (subset != null) {
        entry.pcount += pcount;
        if (count > 0 && entry.count == 0) {
            entry.representant = representant;
        }
    }
    if (entry.count >= k) {
        if (!entry.isNotOutlier) {
            entry.isNotOutlier = true;
            currentOutliers -= (entry.count - count);
        }
    } else {
        currentOutliers += count;
    }
    if (subset == null || count > 0) {
        entry.representant = entry.representant < representant ? entry.representant : representant;
    }
    return entry;
}

Output:
         entry.pcount += pcount;
-        if (count > 0 && entry.count == 0) {
+        if (count > 0 && entry.count == count) {
             entry.representant = representant;


Input:
public GammaRamp getGammaRamp() {
    ByteBuffer gammaRamp = glfwGetGammaRamp(handle);
    GLFWgammaramp ramp = new GLFWgammaramp(gammaRamp);
    int byteBufferSize = ramp.getSize() * Short.BYTES / Byte.BYTES;
    ShortBuffer rBuffer = ramp.getRed(byteBufferSize).asShortBuffer();
    ShortBuffer gBuffer = ramp.getGreen(byteBufferSize).asShortBuffer();
    ShortBuffer bBuffer = ramp.getBlue(byteBufferSize).asShortBuffer();
    short[] red = new short[ramp.getSize()];
    short[] green = new short[ramp.getSize()];
    short[] blue = new short[ramp.getSize()];
    int i = 0;
    while (rBuffer.hasRemaining()) red[i++] = rBuffer.get();
    i = 0;
    while (gBuffer.hasRemaining()) green[i++] = gBuffer.get();
    i = 0;
    while (bBuffer.hasRemaining()) blue[i++] = bBuffer.get();
    return new GammaRamp(red, green, blue, ramp.getSize());
}

Output:
     GLFWgammaramp ramp = new GLFWgammaramp(gammaRamp);
-    int byteBufferSize = ramp.getSize() * Short.BYTES / Byte.BYTES;
+    int byteBufferSize = ramp.getSize() * Short.BYTES;
     ShortBuffer rBuffer = ramp.getRed(byteBufferSize).asShortBuffer();


Input:
public void setValue(Object value, boolean toMemoryConfig) {
    this.value = value;
    if (config != null && toMemoryConfig) {
        config.addNode(this);
    }
}

Output:
     this.value = value;
-    if (config != null && toMemoryConfig) {
+    if (config != null) {
         config.addNode(this);


Input:
public DisplayModeSetting getDisplayModeSetting() {
    return this.displayModeSetting;
}

Output:
 public DisplayModeSetting getDisplayModeSetting() {
-    return this.displayModeSetting;
+    return displayModeSetting;
 }


Input:
public IndicatorParameters getParameters() {
    parameters = super.getParameters();
    if (parameters == null) {
        parameters = IndicatorsFactory.eINSTANCE.createIndicatorParameters();
    }
    TextParameters textParameters = parameters.getTextParameter();
    if (textParameters == null) {
        textParameters = IndicatorsFactory.eINSTANCE.createTextParameters();
    }
    textParameters.setUseNulls(false);
    textParameters.setUseBlank(true);
    parameters.setTextParameter(textParameters);
    return parameters;
}

Output:
 public IndicatorParameters getParameters() {
-    parameters = super.getParameters();
-    if (parameters == null) {
-        parameters = IndicatorsFactory.eINSTANCE.createIndicatorParameters();
+    if (parameters != null) {
+        TextParameters textParameters = parameters.getTextParameter();
+        if (textParameters == null) {
+            textParameters = IndicatorsFactory.eINSTANCE.createTextParameters();
+        }
+        textParameters.setUseNulls(false);
+        textParameters.setUseBlank(true);
+        parameters.setTextParameter(textParameters);
     }


Input:
public void map(Chunk[] chks) {
    sums = new double[chks.length];
    for (int c = 0; c < chks.length; c++) {
        for (int r = 0; r < chks[c].len(); r++) {
            if ((long) chks[c].at0(r) != 0) {
                sums[c]++;
            }
        }
    }
}

Output:
         for (int r = 0; r < chks[c].len(); r++) {
-            if ((long) chks[c].at0(r) != 0) {
+            if ((long) chks[c].atd(r) != 0) {
                 sums[c]++;


Input:
public void setup() throws Exception {
    threadingModelFactory = new Select_NioEventLoopGroupFactory();
    super.setup();
}

Output:
 public void setup() throws Exception {
-    threadingModelFactory = new Select_NioEventLoopGroupFactory();
+    eventLoopGroupFactory = new Select_NioEventLoopGroupFactory();
     super.setup();


Input:
public static JacocoCoverageResultSummary getResultSummary(final Collection<Job<?, ?>> jobs) {
    JacocoCoverageResultSummary summary = new JacocoCoverageResultSummary();
    for (Job<?, ?> job : jobs) {
        float classCoverage = 0.0f;
        float lineCoverage = 0.0f;
        float methodCoverage = 0.0f;
        float branchCoverage = 0.0f;
        float instructionCoverage = 0.0f;
        float complexityScore = 0.0f;
        Run<?, ?> run = job.getLastSuccessfulBuild();
        if (run != null) {
            JacocoBuildAction jacocoAction = job.getLastSuccessfulBuild().getAction(JacocoBuildAction.class);
            if (null != jacocoAction) {
                if (null != jacocoAction.getClassCoverage()) {
                    classCoverage = jacocoAction.getClassCoverage().getPercentageFloat();
                    BigDecimal bigClassCoverage = new BigDecimal(classCoverage);
                    bigClassCoverage = bigClassCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    classCoverage = bigClassCoverage.floatValue();
                }
                if (null != jacocoAction.getLineCoverage()) {
                    lineCoverage = jacocoAction.getLineCoverage().getPercentageFloat();
                    BigDecimal bigLineCoverage = new BigDecimal(lineCoverage);
                    bigLineCoverage = bigLineCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    lineCoverage = bigLineCoverage.floatValue();
                }
                if (null != jacocoAction.getMethodCoverage()) {
                    methodCoverage = jacocoAction.getMethodCoverage().getPercentageFloat();
                    BigDecimal bigMethodCoverage = new BigDecimal(methodCoverage);
                    bigMethodCoverage = bigMethodCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    methodCoverage = bigMethodCoverage.floatValue();
                }
                if (null != jacocoAction.getBranchCoverage()) {
                    branchCoverage = jacocoAction.getBranchCoverage().getPercentageFloat();
                    BigDecimal bigBranchCoverage = new BigDecimal(branchCoverage);
                    bigBranchCoverage = bigBranchCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    branchCoverage = bigBranchCoverage.floatValue();
                }
                if (null != jacocoAction.getInstructionCoverage()) {
                    instructionCoverage = jacocoAction.getInstructionCoverage().getPercentageFloat();
                    BigDecimal bigInstructionCoverage = new BigDecimal(instructionCoverage);
                    bigInstructionCoverage = bigInstructionCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    instructionCoverage = bigInstructionCoverage.floatValue();
                }
                if (null != jacocoAction.getComplexityScore()) {
                    complexityScore = jacocoAction.getComplexityScore().getPercentageFloat();
                    BigDecimal bigComplexityCoverage = new BigDecimal(complexityScore);
                    bigComplexityCoverage = bigComplexityCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
                    complexityScore = bigComplexityCoverage.floatValue();
                }
            }
        }
        summary.addCoverageResult(new JacocoCoverageResultSummary(job, lineCoverage, methodCoverage, classCoverage, branchCoverage, instructionCoverage, complexityScore));
    }
    return summary;
}

Output:
                     BigDecimal bigClassCoverage = new BigDecimal(classCoverage);
-                    bigClassCoverage = bigClassCoverage.setScale(1, BigDecimal.ROUND_HALF_EVEN);
+                    bigClassCoverage = bigClassCoverage.setScale(1, RoundingMode.HALF_EVEN);
                     classCoverage = bigClassCoverage.floatValue();


Input:
private void runShadowProcess(final Property property, final Node inputNode, final IContext selectContext, final IElementParameter switchParam) {
    DatabaseConnection connt = TracesConnectionUtils.createConnection(connParameters);
    String dbmsId = connt.getDbmsId();
    if (dbmsId == null) {
        Shell shell = Display.getCurrent().getActiveShell();
        MessageDialog.openError(shell, "String_Node_Str", "String_Node_Str");
        MappingFileSelectDialog dialog = new MappingFileSelectDialog(shell);
        dialog.open();
        dbmsId = dialog.getSelectId();
    }
    GuessSchemaProcess gsp = new GuessSchemaProcess(property, inputNode, selectContext, memoSQL, info);
    try {
        List<Integer> indexsForSameNamedColumn = new ArrayList<Integer>();
        CsvArray array = gsp.run();
        List<String[]> schemaContent = array.getRows();
        if (columns != null) {
            columns.clear();
        }
        if (!schemaContent.isEmpty()) {
            int numbOfColumn = schemaContent.get(0).length;
            for (int i = 1; i <= numbOfColumn; i++) {
                indexsForSameNamedColumn.clear();
                Boolean b = false;
                IMetadataColumn oneColum = new MetadataColumn();
                String labelName = (schemaContent.get(0))[i - 1];
                String sub = "String_Node_Str";
                String sub2 = "String_Node_Str";
                if (labelName != null && labelName.length() > 0 && labelName.startsWith("String_Node_Str")) {
                    sub = labelName.substring(1);
                    if (sub != null && sub.length() > 0) {
                        sub2 = sub.substring(1);
                    }
                }
                if (KeywordsValidator.isKeyword(labelName) || KeywordsValidator.isKeyword(sub) || KeywordsValidator.isKeyword(sub2)) {
                    labelName = "String_Node_Str" + labelName;
                    b = true;
                }
                findSameNamedColumnAndReplaceTheIndex(indexsForSameNamedColumn, i, oneColum, labelName);
                String label = labelName;
                if (b && label != null && label.length() > 0 && label.startsWith("String_Node_Str")) {
                    String substring = label.substring(1);
                    if (label.startsWith("String_Node_Str") && (KeywordsValidator.isKeyword(substring) || KeywordsValidator.isKeyword(sub) || KeywordsValidator.isKeyword(sub2))) {
                        label = substring;
                    }
                }
                oneColum.setOriginalDbColumnName(label);
                if (schemaContent.size() > 5) {
                    oneColum.setPrecision(Integer.parseInt(schemaContent.get(2)[i - 1]));
                    oneColum.setLength(Integer.parseInt(schemaContent.get(3)[i - 1]));
                }
                try {
                    String talendType = null;
                    if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA) {
                        if (schemaContent.size() >= 5) {
                            talendType = MetadataTalendType.getMappingTypeRetriever(dbmsId).getDefaultSelectedTalendType(schemaContent.get(4)[i - 1]);
                        } else {
                            talendType = JavaTypesManager.STRING.getId();
                        }
                    } else {
                        if (schemaContent.size() >= 5) {
                            talendType = PerlDataTypeHelper.getNewTalendTypeOfValue(schemaContent.get(4)[i - 1]);
                        } else {
                            talendType = PerlTypesManager.STRING;
                        }
                    }
                    oneColum.setTalendType(talendType);
                } catch (Exception e) {
                    ExceptionHandler.process(e);
                }
                oneColum.setNullable((schemaContent.get(1))[i - 1].equals(Boolean.TRUE.toString()) ? true : false);
                columns.add(oneColum);
            }
            if (columns.size() > 0) {
                IElementParameter dqRule = elem.getElementParameter("String_Node_Str");
                if (dqRule != null) {
                    ITDQRuleService ruleService = null;
                    try {
                        ruleService = (ITDQRuleService) GlobalServiceRegister.getDefault().getService(ITDQRuleService.class);
                    } catch (RuntimeException e) {
                    }
                    IElementParameter queryParam = elem.getElementParameter("String_Node_Str");
                    if (ruleService != null && queryParam != null) {
                        ruleService.updateOriginalColumnNames(columns, queryParam);
                    }
                }
            }
            IMetadataTable tempMetatable = new MetadataTable();
            if (tempMetatable.getTableName() == null) {
                tempMetatable.setTableName(inputNode.getUniqueName());
            }
            IMetadataTable outputMetaCopy, originaleOutputTable;
            String propertyName = (String) btn.getData(PARAMETER_NAME);
            IElementParameter param = inputNode.getElementParameter(propertyName);
            for (IElementParameter eParam : elem.getElementParameters()) {
                if (eParam.getContext() != null) {
                    param = eParam;
                }
            }
            originaleOutputTable = inputNode.getMetadataFromConnector(param.getContext());
            if (originaleOutputTable != null) {
                outputMetaCopy = originaleOutputTable.clone();
            }
            tempMetatable.setListColumns(columns);
            MetadataDialog metaDialog = new MetadataDialog(composite.getShell(), tempMetatable, inputNode, getCommandStack());
            if (metaDialog != null) {
                metaDialog.setText(Messages.getString("String_Node_Str") + inputNode.getLabel());
            }
            if (metaDialog.open() == MetadataDialog.OK) {
                outputMetaCopy = metaDialog.getOutputMetaData();
                boolean modified = false;
                if (!outputMetaCopy.sameMetadataAs(originaleOutputTable, IMetadataColumn.OPTIONS_NONE)) {
                    modified = true;
                }
                if (modified) {
                    if (switchParam != null) {
                        switchParam.setValue(Boolean.FALSE);
                    }
                    changeMetadataCommand = new ChangeMetadataCommand(inputNode, param, originaleOutputTable, outputMetaCopy);
                }
            }
        }
    } catch (ProcessorException e) {
        ExtractMetaDataUtils.closeConnection();
        final String strExcepton = e.getMessage();
        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                MessageDialog.openWarning(composite.getShell(), Messages.getString("String_Node_Str"), strExcepton);
            }
        });
        ExceptionHandler.process(e);
    }
}

Output:
                 }
-                findSameNamedColumnAndReplaceTheIndex(indexsForSameNamedColumn, i, oneColum, labelName);
-                String label = labelName;
-                if (b && label != null && label.length() > 0 && label.startsWith("String_Node_Str")) {
-                    String substring = label.substring(1);
-                    if (label.startsWith("String_Node_Str") && (KeywordsValidator.isKeyword(substring) || KeywordsValidator.isKeyword(sub) || KeywordsValidator.isKeyword(sub2))) {
-                        label = substring;
-                    }
-                }
-                oneColum.setOriginalDbColumnName(label);
+                oneColum.setLabel(MetadataToolHelper.validateColumnName(labelName, i, columnLabels));
+                oneColum.setOriginalDbColumnName(name);
                 if (schemaContent.size() > 5) {


Input:
protected void __handleIFrame() throws Exception {
    JspWriter writer = pageContext.getOut();
    String iframe = "String_Node_Str";
    if (viewer.getId() != null)
        iframe += "String_Node_Str" + viewer.getId() + "String_Node_Str";
    if (viewer.getName() != null)
        iframe += "String_Node_Str" + viewer.getName() + "String_Node_Str";
    String src = viewer.createURI(IBirtConstants.VIEWER_PARAMETER) + "String_Node_Str" + ParameterAccessor.PARAM_NOCACHE_PARAMETER;
    iframe += "String_Node_Str" + src + "String_Node_Str";
    iframe += "String_Node_Str" + viewer.getBorder() + "String_Node_Str";
    if (viewer.getScrolling() != null)
        iframe += "String_Node_Str" + viewer.getScrolling() + "String_Node_Str";
    iframe += __handleAppearance() + "String_Node_Str";
    writer.write(iframe);
}

Output:
     iframe += "String_Node_Str" + src + "String_Node_Str";
-    iframe += "String_Node_Str" + viewer.getBorder() + "String_Node_Str";
+    iframe += "String_Node_Str" + viewer.getFrameborder() + "String_Node_Str";
     if (viewer.getScrolling() != null)


Input:
private void sampleLabels(int sampleNumber) {
    for (int p = 0; p < numberOfDomains; p++) {
        for (int i = 0; i < numberOfDataSamples[p]; i++) {
            double p0 = 1 - priorSamples[sampleNumber][p];
            double p1 = priorSamples[sampleNumber][p];
            for (int j = 0; j < numberOfFunctions; j++) {
                p0 *= confusionMatrixSamples[sampleNumber][p][clusterAssignmentSamples[sampleNumber][p][j]][0][functionOutputsArray[j][p][i]];
                p1 *= confusionMatrixSamples[sampleNumber][p][clusterAssignmentSamples[sampleNumber][p][j]][1][functionOutputsArray[j][p][i]];
            }
            int newLabel = randomDataGenerator.nextBinomial(1, p1 / (p0 + p1));
            if (labelsSamples[sampleNumber][p][i] != newLabel) {
                updateCountsBeforeSamplingLabel(sampleNumber, p, i);
                labelsSamples[sampleNumber][p][i] = newLabel;
                updateCountsAfterSamplingLabel(sampleNumber, p, i);
            }
        }
    }
}

Output:
         for (int i = 0; i < numberOfDataSamples[p]; i++) {
-            double p0 = 1 - priorSamples[sampleNumber][p];
-            double p1 = priorSamples[sampleNumber][p];
+            double p0 = 1 - labelPriorsSamples[sampleNumber][p];
+            double p1 = labelPriorsSamples[sampleNumber][p];
             for (int j = 0; j < numberOfFunctions; j++) {


Input:
public final void savePropagationTask() {
    ExternalResource resource = resourceDAO.find("String_Node_Str");
    assertNotNull(resource);
    SyncopeUser user = userDAO.find(2L);
    assertNotNull(user);
    PropagationTask task = new PropagationTask();
    task.setResource(resource);
    task.setSyncopeUser(user);
    task.setPropagationMode(PropagationMode.ASYNC);
    task.setPropagationOperation(PropagationOperation.CREATE);
    task.setAccountId("String_Node_Str");
    Set<Attribute> attributes = new HashSet<Attribute>();
    attributes.add(AttributeBuilder.build("String_Node_Str", "String_Node_Str", "String_Node_Str"));
    attributes.add(AttributeBuilder.buildPassword("String_Node_Str".toCharArray()));
    task.setAttributes(attributes);
    task = taskDAO.save(task);
    assertNotNull(task);
    PropagationTask actual = taskDAO.find(task.getId());
    assertEquals(task, actual);
}

Output:
     task.setSyncopeUser(user);
-    task.setPropagationMode(PropagationMode.ASYNC);
+    task.setPropagationMode(PropagationMode.TWO_PHASES);
     task.setPropagationOperation(PropagationOperation.CREATE);


Input:
public static <T extends Comparable<T>> Matcher<? super T> greaterThanOrEqualTo(T value) {
    return new OrderingComparison<T>(value, -1, 0);
}

Output:
 public static <T extends Comparable<T>> Matcher<? super T> greaterThanOrEqualTo(T value) {
-    return new OrderingComparison<T>(value, -1, 0);
+    return new OrderingComparison<T>(value, EQUAL, GREATER_THAN);
 }


Input:
public long getStartTime() {
    return -1;
}

Output:
 public long getStartTime() {
-    return -1;
+    return fTraceStartTime;
 }


Input:
public static void serialize(SerializationStreamWriter writer, RegularImmutableAsList<?> instance) throws SerializationException {
    writer.writeObject(instance.delegateCollection());
    writer.writeObject(instance.delegateList());
}

Output:
 public static void serialize(SerializationStreamWriter writer, RegularImmutableAsList<?> instance) throws SerializationException {
-    writer.writeObject(instance.delegateCollection());
-    writer.writeObject(instance.delegateList());
+    Collection_CustomFieldSerializerBase.serialize(writer, instance);
 }


Input:
public List<HttpRequest> getCapturedRequests() {
    List<HttpRequest> snapshot = new ArrayList<HttpRequest>();
    snapshot.addAll(capturedRequests);
    return snapshot;
}

Output:
 public List<HttpRequest> getCapturedRequests() {
-    List<HttpRequest> snapshot = new ArrayList<HttpRequest>();
-    snapshot.addAll(capturedRequests);
-    return snapshot;
+    return capturedRequests;
 }


Input:
public Neighborhood query(float[] vector, int k, int maxTraversal, TIntSet validIds) {
    if (validIds != null) {
        TIntSet tmp = validIds;
        validIds = new TIntHashSet(tmp.size() * 4);
        tmp.addAll(validIds);
    }
    long[] vbits = new long[2];
    project(vector, vbits);
    long p0 = vbits[0];
    long p1 = vbits[1];
    int[] numHits = new int[NUM_BITS + 1];
    for (int i = 0; i < ids.length; i++) {
        if (validIds != null && !validIds.contains(ids[i]))
            continue;
        int nSet = NUM_BITS - Long.bitCount(bits[2 * i] ^ p0) - Long.bitCount(bits[2 * i + 1] ^ p1);
        numHits[nSet]++;
    }
    int threshold;
    int count = 0;
    for (threshold = NUM_BITS; threshold > 0; threshold--) {
        count += numHits[threshold];
        if (count >= maxTraversal) {
            break;
        }
    }
    NeighborhoodAccumulator accum = new NeighborhoodAccumulator(k);
    for (int i = 0; i < ids.length; i++) {
        if (validIds != null && !validIds.contains(ids[i]))
            continue;
        int nSet = NUM_BITS - Long.bitCount(bits[2 * i] ^ p0) - Long.bitCount(bits[2 * i + 1] ^ p1);
        if (nSet >= threshold) {
            try {
                DenseMatrixRow row = matrix.getRow(ids[i]);
                double sim = KmeansKNNFinder.cosine(vector, row);
                accum.visit(ids[i], sim);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }
    return accum.get();
}

Output:
         validIds = new TIntHashSet(tmp.size() * 4);
-        tmp.addAll(validIds);
+        validIds.addAll(tmp);
     }


Input:
private List<View> wrap(ListView listView) {
    List<View> result = newArrayList();
    for (int i = 0; i < listView.getChildCount(); i++) {
        result.add(listView.getChildAt(i));
    }
    return result;
}

Output:
     List<View> result = newArrayList();
-    for (int i = 0; i < listView.getChildCount(); i++) {
-        result.add(listView.getChildAt(i));
+    for (int i = 0; i < listView.getAdapter().getCount(); i++) {
+        result.add(listView.getAdapter().getView(i, null, listView));
     }


Input:
public void add(Key obj) {
    optimizeWrites();
    Verse firstVerse = null;
    Verse lastVerse = null;
    for (Key aKey : obj) {
        lastVerse = (Verse) aKey;
        if (firstVerse == null) {
            firstVerse = lastVerse;
        }
        store.set(lastVerse.getOrdinal());
    }
    if (suppressEvents == 0) {
        fireIntervalAdded(this, firstVerse, lastVerse);
    }
}

Output:
         }
-        store.set(lastVerse.getOrdinal());
+        store.set(v11n.getOrdinal(lastVerse));
     }


Input:
public void execute() {
    checkAndAddContextVariables(contextItem, addedVars, contextManager, true);
}

Output:
 public void execute() {
-    checkAndAddContextVariables(contextItem, addedVars, contextManager, true);
+    checkAndAddContextVariables(contextItem, contextManager, addedVars, contextGoupNameSet);
 }


Input:
public void testCompressedFieldDataDirectoryBasic() throws CorruptIndexException, IOException {
    RAMDirectory dir = new RAMDirectory();
    CompressedFieldDataDirectory directory = new CompressedFieldDataDirectory(dir, COMPRESSION_CODEC);
    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_33, new KeywordAnalyzer());
    TieredMergePolicy mergePolicy = (TieredMergePolicy) config.getMergePolicy();
    mergePolicy.setUseCompoundFile(false);
    IndexWriter writer = new IndexWriter(directory, config);
    addDocs(writer, 0, 10);
    writer.close();
    testFetches(directory);
}

Output:
     RAMDirectory dir = new RAMDirectory();
-    CompressedFieldDataDirectory directory = new CompressedFieldDataDirectory(dir, COMPRESSION_CODEC);
+    CompressedFieldDataDirectory directory = new CompressedFieldDataDirectory(DirectIODirectory.wrap(dir), COMPRESSION_CODEC);
     IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_33, new KeywordAnalyzer());


Input:
public VisitStatus acceptASTNode(ASTNode node, TypeLookupResult result, IJavaElement enclosingElement) {
    if (node instanceof ClassExpression || node instanceof ClassNode || node instanceof ImportNode || node instanceof AnnotationNode) {
        ASTNode noArray;
        if (node instanceof ClassNode) {
            noArray = removeArray((ClassNode) node);
        } else {
            noArray = node;
        }
        ClassNode type = result.type;
        if (node instanceof ClassExpression && type == VariableScope.CLASS_CLASS_NODE) {
            type = ((ClassExpression) node).getType();
        }
        if (type != null) {
            String qualifiedName = removeArray(type).getName();
            if (qualifiedNameMatches(qualifiedName) && noArray.getEnd() > 0) {
                int start;
                int end;
                if (node instanceof ImportNode) {
                    node = ((ImportNode) node).getType();
                    start = node.getStart();
                    end = node.getEnd();
                } else if (node instanceof ClassExpression) {
                    start = node.getStart();
                    end = start + ((ClassExpression) node).getType().getNameWithoutPackage().length();
                } else if (node instanceof ClassNode) {
                    node = maybeGetComponentType((ClassNode) node);
                    start = node.getStart();
                    end = start + ((ClassNode) node).getNameWithoutPackage().length();
                } else {
                    start = node.getStart();
                    end = node.getEnd();
                }
                SearchMatch match = new SearchMatch(enclosingElement, getAccuracy(result.confidence), start, end - start, participant, enclosingElement.getResource());
                try {
                    requestor.acceptSearchMatch(match);
                } catch (CoreException e) {
                    Util.log(e, "String_Node_Str" + enclosingElement);
                }
            }
        }
    }
    return VisitStatus.CONTINUE;
}

Output:
 public VisitStatus acceptASTNode(ASTNode node, TypeLookupResult result, IJavaElement enclosingElement) {
-    if (node instanceof ClassExpression || node instanceof ClassNode || node instanceof ImportNode || node instanceof AnnotationNode) {
+    if (node instanceof ClassExpression || node instanceof ClassNode || node instanceof ImportNode || node instanceof AnnotationNode || node instanceof ConstructorNode) {
         ASTNode noArray;


Input:
public <T> int countByWhere(Class<T> clazz, String strWhere) {
    TableInfo table = TableInfo.get(clazz);
    DbModel model = db.findDbModelBySQL(clazz, "String_Node_Str" + table.getTableName() + "String_Node_Str" + strWhere);
    if (model != null) {
        return model.getInt("String_Node_Str");
    }
    return 0;
}

Output:
     TableInfo table = TableInfo.get(clazz);
-    DbModel model = db.findDbModelBySQL(clazz, "String_Node_Str" + table.getTableName() + "String_Node_Str" + strWhere);
+    DbModel model = db.findDbModelBySQL("String_Node_Str" + table.getTableName() + "String_Node_Str" + strWhere);
     if (model != null) {


Input:
protected Bitmap doInBackground(Void... voids) {
    Bitmap bitmap = null;
    InputStream in = null;
    try {
        in = new java.net.URL(url).openStream();
        bitmap = BitmapFactory.decodeStream(in);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        in.close();
    }
    return bitmap;
}

Output:
     } finally {
-        in.close();
+        try {
+            in.close();
+        } catch (Exception ignored) {
+        }
     }


Input:
public double getLogUnormalizedScore(VarConfig vc) {
    LogSemiring s = Algebras.LOG_SEMIRING;
    if (!hasOneParentPerToken(n, vc)) {
        log.trace("String_Node_Str");
        return s.zero();
    }
    int[] parents = getParents(n, vc);
    if (!DepTree.isDepTree(parents, true, InsideOutsideDepParse.singleRoot)) {
        log.trace("String_Node_Str");
        return s.zero();
    }
    return s.one();
}

Output:
     int[] parents = getParents(n, vc);
-    if (!DepTree.isDepTree(parents, true, InsideOutsideDepParse.singleRoot)) {
+    if (!ParentsArray.isDepTree(parents, true, InsideOutsideDepParse.singleRoot)) {
         log.trace("String_Node_Str");


Input:
private String getMetricContext(WeaveRunner.LiveInfo info) {
    Matcher matcher = APP_NAME_PATTERN.matcher(info.getApplicationName());
    if (!matcher.matches()) {
        return null;
    }
    Type type = getType(matcher.group(1));
    if (type == null) {
        return null;
    }
    Id.Program programId = Id.Program.from(matcher.group(2), matcher.group(3), matcher.group(4));
    return Joiner.on("String_Node_Str").join(programId.getApplicationId(), TypeId.getMetricContextId(type), programId.getApplication().getId());
}

Output:
     Id.Program programId = Id.Program.from(matcher.group(2), matcher.group(3), matcher.group(4));
-    return Joiner.on("String_Node_Str").join(programId.getApplicationId(), TypeId.getMetricContextId(type), programId.getApplication().getId());
+    return Joiner.on("String_Node_Str").join(programId.getApplicationId(), TypeId.getMetricContextId(type), programId.getId());
 }


Input:
public <T> JournalBulkReader<T> bulkReader(JournalKey<T> key) throws JournalException {
    String name = key.path();
    checkBlocked(name);
    JournalBulkReader<T> result = bulkReaders.get(name);
    if (result == null) {
        result = new JournalBulkReader<>(getOrCreateMetadata(key), key);
        result.setCloseListener(this);
        bulkReaders.put(name, result);
        journalList.add(result);
    }
    return result;
}

Output:
     if (result == null) {
-        result = new JournalBulkReader<>(getOrCreateMetadata(key), key);
+        result = super.bulkReader(key);
         result.setCloseListener(this);


Input:
public void build(final Progress p) throws IOException, JobFailedException, JobCancelledException {
    if (p != null) {
        p.starting();
    }
    final InputFormatDescriptor ifd = ((VectorMapOp) _inputs.get(0)).getVectorOutput();
    if (bounds == null) {
        bounds = calculateBounds();
    }
    {
        final RasterizeVectorDriver rvd = new RasterizeVectorDriver();
        final Job job = new Job(getConf());
        ifd.populateJobParameters(job);
        rvd.setValueColumn(column);
        rvd.run(job, _outputName, _aggregationType, zoomlevel, bounds, p, jobListener, getProtectionLevel(), getProviderProperties());
    }
    MrsImageDataProvider dp = DataProviderFactory.getMrsImageDataProvider(_outputName, AccessMode.READ, getProviderProperties());
    _output = MrsPyramidDescriptor.create(dp);
    if (p != null) {
        p.complete();
    }
}

Output:
         final RasterizeVectorDriver rvd = new RasterizeVectorDriver();
-        final Job job = new Job(getConf());
+        final Job job = new Job(createConfiguration());
         ifd.populateJobParameters(job);


Input:
public static void showMultipleAligmentPanel(MultipleAlignment multAln, AbstractAlignmentJmol jmol, Color[] colors) throws StructureException {
    MultipleAligPanel me = new MultipleAligPanel(multAln, colors, jmol);
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    frame.setTitle("String_Node_Str");
    me.setPreferredSize(new Dimension(me.getCoordManager().getPreferredWidth(), me.getCoordManager().getPreferredHeight()));
    JMenuBar menu = MenuCreator.getAlignmentTextMenu(frame, me, multAln);
    frame.setJMenuBar(menu);
    JScrollPane scroll = new JScrollPane(me);
    scroll.setAutoscrolls(true);
    MultipleStatusDisplay status = new MultipleStatusDisplay(me);
    me.addAlignmentPositionListener(status);
    Box vBox = Box.createVerticalBox();
    vBox.add(scroll);
    vBox.add(status);
    frame.getContentPane().add(vBox);
    frame.pack();
    frame.setVisible(true);
    frame.addWindowListener(me);
    frame.addWindowListener(status);
}

Output:
     frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-    frame.setTitle("String_Node_Str");
+    frame.setTitle(jmol.getTitle());
     me.setPreferredSize(new Dimension(me.getCoordManager().getPreferredWidth(), me.getCoordManager().getPreferredHeight()));


Input:
private static void copyFileL(String srcFileName, FileInputStream srcInputStream, String desFileName, boolean delSrc) throws Exception {
    File source = new File(srcFileName);
    File dest = new File(desFileName);
    FileChannel in = null, out = null;
    try {
        in = srcInputStream.getChannel();
        out = new FileOutputStream(dest).getChannel();
        long size = in.size();
        long position = 0;
        final long MAP_SIZE = 102400000;
        MappedByteBuffer buf = null;
        while (true) {
            if (position + MAP_SIZE >= size) {
                buf = in.map(FileChannel.MapMode.READ_ONLY, position, size - position);
                out.write(buf);
                if (delSrc) {
                    clean(buf);
                }
                break;
            } else {
                buf = in.map(FileChannel.MapMode.READ_ONLY, position, MAP_SIZE);
                out.write(buf);
                if (delSrc) {
                    clean(buf);
                }
                position += MAP_SIZE;
            }
        }
        in.close();
        out.close();
        if (delSrc) {
            source.delete();
        }
    } finally {
        if (in != null) {
            in.close();
        }
        if (out != null) {
            out.close();
        }
    }
}

Output:
         long position = 0;
-        final long MAP_SIZE = 102400000;
+        final long MAP_SIZE = 33525760;
         MappedByteBuffer buf = null;


Input:
private HeaderGroupConfig processColumn(Element aTag, int deepness) throws Exception {
    String name = aTag.getAttribute("String_Node_Str");
    String title = aTag.getAttribute("String_Node_Str");
    boolean visible = Utils.getBooleanAttribute(aTag, "String_Node_Str", true);
    boolean enabled = Utils.getBooleanAttribute(aTag, "String_Node_Str", true);
    boolean substitute = Utils.getBooleanAttribute(aTag, "String_Node_Str", false);
    boolean plain = Utils.getBooleanAttribute(aTag, "String_Node_Str", true);
    int width = Utils.getIntegerAttribute(aTag, "String_Node_Str", 50);
    Element cellTag = null;
    ModelElementRef modelElement = null;
    Element controlTag = null;
    ModelElementRef columnsDatasource = null;
    ModelElementRef columnsDisplayField = null;
    ModelElementRef cellsDatasource = null;
    Element headerEasFontTag = null;
    Element styleTag = null;
    int childrenCount = 0;
    int subgroupsCount = 0;
    List<HeaderGroupConfig> subGroups = new ArrayList();
    NodeList columnNodes = aTag.getChildNodes();
    for (int c = 0; c < columnNodes.getLength(); c++) {
        if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            cellTag = (Element) columnNodes.item(c);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            modelElement = new ModelElementRef((Element) columnNodes.item(c), model);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            controlTag = (Element) columnNodes.item(c);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            columnsDatasource = new ModelElementRef((Element) columnNodes.item(c), model);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            columnsDisplayField = new ModelElementRef((Element) columnNodes.item(c), model);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            cellsDatasource = new ModelElementRef((Element) columnNodes.item(c), model);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            headerEasFontTag = (Element) columnNodes.item(c);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName()))
            styleTag = (Element) columnNodes.item(c);
        else if ("String_Node_Str".equalsIgnoreCase(columnNodes.item(c).getNodeName())) {
            childrenCount++;
            HeaderGroupConfig subGroup = processColumn((Element) columnNodes.item(c), deepness + 1);
            subGroups.add(subGroup);
            if (subGroup == null) {
                if (childrenCount == 1) {
                    currentLeavesCount = leaves.size();
                }
            } else
                subgroupsCount++;
        }
    }
    if (childrenCount > 0) {
        HeaderGroupConfig group = new HeaderGroupConfig((title != null && !title.isEmpty()) ? title : name);
        groups.add(group);
        group.setRow(deepness);
        if (subgroupsCount > 0)
            group.setColumn(subGroups.get(0).getColumn());
        else
            group.setColumn(currentLeavesCount - 1);
        group.setRowspan(1);
        int colSpan = 0;
        for (HeaderGroupConfig subGroup : subGroups) {
            if (subGroup == null)
                colSpan++;
            else
                colSpan += subGroup.getColspan();
        }
        group.setColspan(colSpan);
        return group;
    } else {
        ColumnConfig<Row, ?> cc = configureColumn(name, title, width, modelElement, aTag, controlTag);
        if (cc != null) {
            cc.setHidden(!visible);
        }
        return null;
    }
}

Output:
             subGroups.add(subGroup);
-            if (subGroup == null) {
-                if (childrenCount == 1) {
-                    currentLeavesCount = leaves.size();
-                }
-            } else
+            if (subGroup != null)
                 subgroupsCount++;


Input:
public void onClick(View v) {
    if (!Common.getBooleanPref(activity, Const.PREF_NAME, Const.PREF_KEY_ADS))
        Toast.makeText(activity, R.string.please_ads, Toast.LENGTH_SHORT).show();
    Toast.makeText(activity, R.string.donate_to_support, Toast.LENGTH_SHORT).show();
    try {
        ArrayList<File> files = new ArrayList<>();
        File TestResults = new File(activity.getFilesDir(), "String_Node_Str");
        try {
            if (TestResults.exists()) {
                if (TestResults.delete()) {
                    FileOutputStream fos = activity.openFileOutput(TestResults.getName(), Context.MODE_PRIVATE);
                    fos.write(("String_Node_Str" + shell.execCommand("String_Node_Str" + Const.PathToRashr.getAbsolutePath()) + "String_Node_Str" + shell.execCommand("String_Node_Str") + "String_Node_Str" + "String_Node_Str" + shell.execCommand("String_Node_Str") + "String_Node_Str" + "String_Node_Str" + shell.execCommand("String_Node_Str")).getBytes());
                }
                files.add(TestResults);
            }
        } catch (Exception e) {
            activity.addError(Const.RASHR_TAG, e, false);
        }
        if (activity.getPackageManager() != null) {
            PackageInfo pInfo = activity.getPackageManager().getPackageInfo(activity.getPackageName(), 0);
            String comment = "String_Node_Str";
            if (text.getText() != null)
                comment = text.getText().toString();
            Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
            intent.setType("String_Node_Str");
            intent.putExtra(Intent.EXTRA_EMAIL, new String[] { "String_Node_Str" });
            intent.putExtra(Intent.EXTRA_SUBJECT, "String_Node_Str" + pInfo.versionCode + "String_Node_Str");
            String message = "String_Node_Str" + "String_Node_Str" + pInfo.packageName + "String_Node_Str" + pInfo.versionName;
            message += "String_Node_Str" + "String_Node_Str" + Build.MANUFACTURER + "String_Node_Str" + device.getManufacture() + "String_Node_Str" + "String_Node_Str" + Build.DEVICE + "String_Node_Str" + device.getName() + "String_Node_Str" + "String_Node_Str" + Build.BOARD + "String_Node_Str" + Build.BRAND + "String_Node_Str" + Build.MODEL + "String_Node_Str" + Build.FINGERPRINT + "String_Node_Str" + Build.VERSION.CODENAME + "String_Node_Str" + Build.VERSION.SDK_INT + "String_Node_Str";
            if (device.isRecoverySupported()) {
                message += "String_Node_Str" + device.getRecoveryPath() + "String_Node_Str" + device.getRecoveryVersion() + "String_Node_Str" + device.isRecoveryMTD() + "String_Node_Str" + device.isRecoveryDD() + "String_Node_Str" + device.isStockRecoverySupported() + "String_Node_Str" + device.isCwmRecoverySupported() + "String_Node_Str" + device.isTwrpRecoverySupported() + "String_Node_Str" + device.isPhilzRecoverySupported();
            }
            if (device.isKernelSupported()) {
                message += "String_Node_Str" + device.getKernelPath() + "String_Node_Str" + device.getKernelVersion() + "String_Node_Str" + device.isKernelMTD() + "String_Node_Str" + device.isKernelDD();
            }
            if (!comment.equals("String_Node_Str")) {
                message += "String_Node_Str" + comment + "String_Node_Str";
            }
            message += "String_Node_Str" + activity.getAllPrefs() + "String_Node_Str";
            files.add(new File(activity.getFilesDir(), Shell.Logs));
            files.add(new File(activity.getFilesDir(), Const.LastLog.getName()));
            ArrayList<Uri> uris = new ArrayList<>();
            for (File i : files) {
                try {
                    shell.execCommand(Const.Busybox + "String_Node_Str" + i);
                } catch (Exception e) {
                    activity.addError(Const.RASHR_TAG, e, false);
                }
            }
            if (errors.size() > 0) {
                message += "String_Node_Str";
                for (String error : errors) {
                    message += error + "String_Node_Str";
                }
            }
            intent.putExtra(Intent.EXTRA_TEXT, message);
            intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
            activity.startActivity(Intent.createChooser(intent, "String_Node_Str"));
            dismiss();
        }
    } catch (Exception e) {
        dismiss();
        activity.addError(Const.RASHR_TAG, e, false);
    }
}

Output:
 public void onClick(View v) {
-    if (!Common.getBooleanPref(activity, Const.PREF_NAME, Const.PREF_KEY_ADS))
+    if (!Common.getBooleanPref(activity, Const.PREF_NAME, Const.PREF_KEY_ADS)) {
         Toast.makeText(activity, R.string.please_ads, Toast.LENGTH_SHORT).show();


Input:
public void execute(CommandSender sender, List<String> args) {
    if (!correctLength(sender, args.size(), 0, 2)) {
        return;
    } else if (args.size() == 0) {
        if (!hasPermission(sender) || !isPlayer(sender)) {
            return;
        }
        if (Commands.isToggledForAll) {
            sender.sendMessage(ChatColor.RED + "String_Node_Str");
            return;
        }
        BendingPlayer bPlayer = GeneralMethods.getBendingPlayer(sender.getName());
        if (bPlayer == null) {
            GeneralMethods.createBendingPlayer(((Player) sender).getUniqueId(), sender.getName());
            bPlayer = GeneralMethods.getBendingPlayer(sender.getName());
        }
        if (bPlayer.isToggled()) {
            sender.sendMessage(ChatColor.RED + "String_Node_Str");
            bPlayer.toggleBending();
        } else {
            sender.sendMessage(ChatColor.GREEN + "String_Node_Str");
            bPlayer.toggleBending();
        }
    } else if (args.size() == 1 && args.get(0).equalsIgnoreCase("String_Node_Str") && hasPermission(sender, "String_Node_Str")) {
        if (Commands.isToggledForAll) {
            Commands.isToggledForAll = false;
            for (Player player : Bukkit.getOnlinePlayers()) {
                player.sendMessage(ChatColor.GREEN + "String_Node_Str");
            }
            if (!(sender instanceof Player))
                sender.sendMessage(ChatColor.GREEN + "String_Node_Str");
        } else {
            Commands.isToggledForAll = true;
            for (Player player : Bukkit.getOnlinePlayers()) {
                player.sendMessage(ChatColor.RED + "String_Node_Str");
            }
            if (!(sender instanceof Player))
                sender.sendMessage(ChatColor.RED + "String_Node_Str");
        }
    } else if (sender instanceof Player && args.size() == 1 && Element.getType(args.get(0)) != null && sender.hasPermission("String_Node_Str" + getElement(args.get(0)))) {
        Element e = Element.getType(getElement(args.get(0)));
        BendingPlayer bPlayer = GeneralMethods.getBendingPlayer(sender.getName());
        bPlayer.toggleElement(e);
        if (bPlayer.isElementToggled(e) == false) {
            if (e == Element.Chi) {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
            } else {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
            }
        } else {
            if (e == Element.Chi) {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
            } else {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
            }
        }
    } else if (sender instanceof Player && args.size() == 2 && Element.getType(args.get(0)) != null && sender.hasPermission("String_Node_Str" + getElement(args.get(0)))) {
        Player target = Bukkit.getPlayer(args.get(1));
        if (!hasAdminPermission(sender))
            return;
        if (target == null) {
            sender.sendMessage(ChatColor.RED + "String_Node_Str");
        }
        Element e = Element.getType(getElement(args.get(0)));
        BendingPlayer bPlayer = GeneralMethods.getBendingPlayer(target.getName());
        if (bPlayer.isElementToggled(e) == true) {
            if (e == Element.Chi) {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + ChatColor.DARK_AQUA + target.getName() + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
                target.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str" + ChatColor.DARK_AQUA + sender.getName());
            } else {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + ChatColor.DARK_AQUA + target.getName() + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
                target.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str" + ChatColor.DARK_AQUA + sender.getName());
            }
        } else {
            if (e == Element.Chi) {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + ChatColor.DARK_AQUA + target.getName() + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
                target.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str" + ChatColor.DARK_AQUA + sender.getName());
            } else {
                sender.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + ChatColor.DARK_AQUA + target.getName() + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str");
                target.sendMessage(GeneralMethods.getElementColor(e) + "String_Node_Str" + args.get(0).toLowerCase() + "String_Node_Str" + ChatColor.DARK_AQUA + sender.getName());
            }
        }
        bPlayer.toggleElement(e);
    } else {
        help(sender, false);
    }
}

Output:
         }
-    } else if (sender instanceof Player && args.size() == 1 && Element.getType(args.get(0)) != null && sender.hasPermission("String_Node_Str" + getElement(args.get(0)))) {
+    } else if (sender instanceof Player && args.size() == 1 && Element.getType(getElement(args.get(0))) != null && GeneralMethods.getBendingPlayer(sender.getName()).hasElement(Element.getType(getElement(args.get(0))))) {
         Element e = Element.getType(getElement(args.get(0)));


Input:
private void createNonConflictingReferencesUpdate(DiffGroup root, EReference reference, EObject leftElement, EObject rightElement) throws FactoryException {
    final List<Object> leftElementObjReferences = convertFeatureMapList(EFactory.eGetAsList(leftElement, reference.getName()));
    final List<Object> rightElementObjReferences = convertFeatureMapList(EFactory.eGetAsList(rightElement, reference.getName()));
    final List<EObject> leftElementReferences = new ArrayList<EObject>();
    final List<EObject> rightElementReferences = new ArrayList<EObject>();
    for (Object left : leftElementObjReferences) {
        leftElementReferences.add((EObject) left);
    }
    for (Object right : rightElementObjReferences) {
        rightElementReferences.add((EObject) right);
    }
    final List<EObject> deletedReferences = computeDeletedReferences(leftElementReferences, rightElementReferences);
    final List<EObject> addedReferences = computeAddedReferences(leftElementReferences, rightElementReferences);
    if (!reference.isMany()) {
        EObject addedValue = null;
        EObject deletedValue = null;
        if (addedReferences.size() > 0) {
            addedValue = addedReferences.get(0);
        }
        if (deletedReferences.size() > 0) {
            deletedValue = deletedReferences.get(0);
        }
        if (areDistinct(addedValue, deletedValue)) {
            root.getSubDiffElements().add(createUpdatedReferenceOperation(leftElement, rightElement, reference, addedValue, deletedValue));
        }
    } else {
        deletedReferences.removeAll(addedReferences);
        addedReferences.removeAll(deletedReferences);
        final List<ReferenceChangeLeftTarget> addedReferencesDiffs = new ArrayList<ReferenceChangeLeftTarget>(addedReferences.size());
        final List<ReferenceChangeRightTarget> removedReferencesDiffs = new ArrayList<ReferenceChangeRightTarget>(deletedReferences.size());
        if (addedReferences.size() > 0) {
            addedReferencesDiffs.addAll(createNewReferencesOperation(root, leftElement, rightElement, reference, addedReferences));
        }
        if (deletedReferences.size() > 0) {
            removedReferencesDiffs.addAll(createRemovedReferencesOperation(root, leftElement, rightElement, reference, deletedReferences));
        }
        if (reference.isOrdered()) {
            checkReferenceOrderChange(root, reference, leftElement, rightElement, addedReferencesDiffs, removedReferencesDiffs);
        }
    }
}

Output:
         }
-        if (areDistinct(addedValue, deletedValue)) {
+        if (getMatchManager().isUnmatched(addedValue) || getMatchManager().isUnmatched(deletedValue) || areDistinct(addedValue, deletedValue)) {
             root.getSubDiffElements().add(createUpdatedReferenceOperation(leftElement, rightElement, reference, addedValue, deletedValue));


Input:
private void colorNodeLabels() {
    for (NodeImpl n : supervisedNodes) {
        colorNodeLabel(n.getLabel());
    }
}

Output:
     for (NodeImpl n : supervisedNodes) {
-        colorNodeLabel(n.getLabel());
+        if (n.hasLabel()) {
+            colorNodeLabel(n.getLabel());
+        }
     }


Input:
public static ProfilerConfig load(String pinpiontConfigFileName) throws IOException {
    try {
        Properties properties = PropertyUtils.loadProperty(pinpiontConfigFileName);
        return new ProfilerConfig(properties);
    } catch (FileNotFoundException fe) {
        if (logger.isLoggable(Level.WARNING)) {
            logger.log(Level.WARNING, pinpiontConfigFileName + "String_Node_Str");
        }
        throw fe;
    } catch (IOException e) {
        if (logger.isLoggable(Level.WARNING)) {
            logger.log(Level.WARNING, pinpiontConfigFileName + "String_Node_Str" + e.getMessage(), e);
        }
        throw e;
    }
}

Output:
     try {
-        Properties properties = PropertyUtils.loadProperty(pinpiontConfigFileName);
+        Properties properties = PropertyUtils.loadProperty(pinpointConfigFileName);
         return new ProfilerConfig(properties);


Input:
private void dispatchUpdatePluginAction() {
    if (!NetworkUtils.checkConnection(this)) {
        return;
    }
    if (!PluginUtils.isUpdateAvailable(mPlugin, mPluginInfo) || mIsUpdatingPlugin) {
        return;
    }
    mIsUpdatingPlugin = true;
    refreshUpdateVersionViews();
    UpdateSitePluginPayload payload = new UpdateSitePluginPayload(mSite, mPlugin);
    mDispatcher.dispatch(PluginActionBuilder.newUpdateSitePluginAction(payload));
}

Output:
     }
-    if (!PluginUtils.isUpdateAvailable(mPlugin, mPluginInfo) || mIsUpdatingPlugin) {
+    if (!PluginUtils.isUpdateAvailable(mPlugin, mWPOrgPlugin) || mIsUpdatingPlugin) {
         return;


Input:
public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
    Field field = null;
    Object value = this.getCharacters();
    Class attributeClassification = null;
    AbstractNullPolicy nullPolicy;
    boolean isSwaRef = false;
    CoreContainerPolicy cp = null;
    if (isCollection) {
        isSwaRef = ((BinaryDataCollectionMapping) mapping).isSwaRef();
        field = (Field) ((BinaryDataCollectionMapping) mapping).getField();
        attributeClassification = ((BinaryDataCollectionMapping) mapping).getAttributeElementClass();
        nullPolicy = ((BinaryDataCollectionMapping) mapping).getNullPolicy();
        cp = ((BinaryDataCollectionMapping) mapping).getContainerPolicy();
    } else {
        isSwaRef = ((BinaryDataMapping) mapping).isSwaRef();
        field = (Field) ((BinaryDataMapping) mapping).getField();
        attributeClassification = ((BinaryDataMapping) mapping).getAttributeClassification();
        nullPolicy = ((BinaryDataMapping) mapping).getNullPolicy();
    }
    if (isSwaRef && (parent.getUnmarshaller().getAttachmentUnmarshaller() != null)) {
        if (attributeClassification != null && attributeClassification == XMLBinaryDataHelper.getXMLBinaryDataHelper().DATA_HANDLER) {
            value = parent.getUnmarshaller().getAttachmentUnmarshaller().getAttachmentAsDataHandler(value.toString());
        } else {
            value = parent.getUnmarshaller().getAttachmentUnmarshaller().getAttachmentAsByteArray(value.toString());
        }
    } else {
        Object valueFromReader = this.parent.getXMLReader().getValue(getCharacters(), attributeClassification);
        if (parent.isNil() && parent.getXMLReader().isNullRepresentedByXsiNil(nullPolicy)) {
            value = null;
            isCollection = isCollection && parent.getXMLReader().isInCollection();
        } else {
            if (null != valueFromReader) {
                value = valueFromReader;
            } else {
                String valueString = value.toString();
                if (valueString.length() == 0 && nullPolicy.isNullRepresentedByEmptyNode()) {
                    value = null;
                } else {
                    if (field.usesSingleNode()) {
                        value = parent.getConversionManager().convertSchemaBase64ListToByteArrayList(valueString, cp, parent.getSession());
                    } else {
                        value = parent.getConversionManager().convertSchemaBase64ToByteArray(valueString);
                    }
                }
            }
            value = XMLBinaryDataHelper.getXMLBinaryDataHelper().convertObject(value, attributeClassification, parent.getSession(), cp);
        }
    }
    value = converter.convertDataValueToObjectValue(value, parent.getSession(), parent.getUnmarshaller());
    if (isCollection) {
        parent.addAttributeValue((ContainerValue) nodeValue, value);
    } else {
        parent.setAttributeValue(value, mapping);
    }
    if (!field.isSelfField()) {
        parent.getXMLReader().setContentHandler(parent);
        parent.endElement(namespaceURI, localName, qName);
    }
    resetStringBuffer();
}

Output:
                     if (field.usesSingleNode()) {
-                        value = parent.getConversionManager().convertSchemaBase64ListToByteArrayList(valueString, cp, parent.getSession());
+                        if (isHex) {
+                            value = parent.getConversionManager().convertHexBinaryListToByteArrayList(valueString, cp, parent.getSession());
+                        } else {
+                            value = parent.getConversionManager().convertSchemaBase64ListToByteArrayList(valueString, cp, parent.getSession());
+                        }
                     } else {


Input:
private void createGUI() {
    Composite composite = new Composite(parentComposite, 0);
    composite.setLayout(new GridLayout(1, false));
    if (dataDomain == null) {
        Group dataChooserGroup = new Group(composite, SWT.SHADOW_ETCHED_IN);
        dataChooserGroup.setText("String_Node_Str");
        dataChooserGroup.setLayout(new GridLayout(1, false));
        dataChooser = new DataChooserComposite(this, dataChooserGroup, SWT.NONE);
        dataChooser.setLayout(new GridLayout(1, false));
        GridData gridData = new GridData(SWT.BEGINNING, SWT.TOP, true, false);
        gridData.minimumWidth = 300;
        dataChooser.setLayoutData(gridData);
    }
    Group clusterDimensionGroup = new Group(composite, SWT.SHADOW_ETCHED_IN);
    clusterDimensionGroup.setText("String_Node_Str");
    clusterDimensionGroup.setLayout(new GridLayout(1, false));
    clusterTypeCombo = new Combo(clusterDimensionGroup, SWT.DROP_DOWN);
    clusterTypeCombo.setItems(typeOptions);
    clusterTypeCombo.select(0);
    clusterTargetName = typeOptions[0];
    if (dataDomain == null) {
        clusterTypeCombo.setEnabled(false);
    }
    Group distanceMeasureGroup = new Group(composite, SWT.SHADOW_ETCHED_IN);
    distanceMeasureGroup.setText("String_Node_Str");
    distanceMeasureGroup.setLayout(new GridLayout(1, false));
    final Combo distMeasureCombo = new Combo(distanceMeasureGroup, SWT.DROP_DOWN);
    distMeasureCombo.setItems(distanceMeasureOptions);
    distMeasureCombo.setEnabled(true);
    distMeasureCombo.select(0);
    distanceMeasureName = distanceMeasureOptions[0];
    distMeasureCombo.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            distanceMeasureName = distMeasureCombo.getText();
        }
    });
    tabFolder = new TabFolder(composite, SWT.BORDER);
    tabFolder.addSelectionListener(new SelectionListener() {
        public void widgetSelected(SelectionEvent e) {
            int selectionIndex = tabFolder.getSelectionIndex();
            AClusterTab tab = (AClusterTab) tabFolder.getItem(selectionIndex).getData();
            if (tab == null)
                return;
            int selectedMeasure = distMeasureCombo.getSelectionIndex();
            String[] supportedMeasures = tab.getSupportedDistanceMeasures();
            distMeasureCombo.setItems(supportedMeasures);
            if (supportedMeasures.length - 1 < selectedMeasure)
                distMeasureCombo.select(0);
            else
                distMeasureCombo.select(selectedMeasure);
            distanceMeasureName = distMeasureCombo.getText();
        }
        public void widgetDefaultSelected(SelectionEvent e) {
        }
    });
    new KMeansTab(tabFolder);
    new AffinityTab(tabFolder);
    new TreeTab(tabFolder);
    Button helpButton = new Button(composite, SWT.PUSH);
    helpButton.setText("String_Node_Str");
    helpButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            LinkHandler.openLink("String_Node_Str");
        }
    });
    tabFolder.pack();
}

Output:
     distanceMeasureGroup.setLayout(new GridLayout(1, false));
-    final Combo distMeasureCombo = new Combo(distanceMeasureGroup, SWT.DROP_DOWN);
-    distMeasureCombo.setItems(distanceMeasureOptions);
-    distMeasureCombo.setEnabled(true);
-    distMeasureCombo.select(0);
-    distanceMeasureName = distanceMeasureOptions[0];
-    distMeasureCombo.addSelectionListener(new SelectionAdapter() {
-        public void widgetSelected(SelectionEvent e) {
-            distanceMeasureName = distMeasureCombo.getText();
-        }
-    });
+    distanceMeasureCombo = new Combo(distanceMeasureGroup, SWT.DROP_DOWN);
+    distanceMeasureCombo.setItems(distanceMeasureOptions);
+    distanceMeasureCombo.setEnabled(true);
+    distanceMeasureCombo.select(0);
     tabFolder = new TabFolder(composite, SWT.BORDER);


Input:
public Move getMove(Board board) {
    assert (this.equals(board.currentPlayer()));
    Board newBoard;
    List<Move> potentialMoves = allMoves(board);
    List<Move> bestMoves = new LinkedList<Move>();
    Collections.sort(potentialMoves, new MinimaxComparator(board.getSpace(board.players.other(this))));
    int bestCase = Integer.MIN_VALUE;
    int evaluation;
    for (Move move : potentialMoves) {
        try {
            newBoard = board.clone();
            newBoard.makeMove(move);
            evaluation = -negamax(newBoard, Integer.MIN_VALUE, Integer.MAX_VALUE, depth);
            if (evaluation > bestCase) {
                bestMoves.clear();
                bestMoves.add(move);
                bestCase = evaluation;
            } else if (evaluation == bestCase) {
                bestMoves.add(move);
            }
        } catch (Exception e) {
        }
    }
    int pick = (int) Math.floor(bestMoves.size() * Math.random());
    System.out.println(i);
    i = 0;
    return bestMoves.get(pick);
}

Output:
             newBoard.makeMove(move);
-            evaluation = -negamax(newBoard, Integer.MIN_VALUE, Integer.MAX_VALUE, depth);
+            evaluation = -negamax(newBoard, Integer.MIN_VALUE + 1, Integer.MAX_VALUE, depth);
             if (evaluation > bestCase) {


Input:
public <T> T executeTransaction(TransactionOptions options, TransactionalTask<T> task) throws TransactionException {
    final TransactionContext context = newTransactionContext(options);
    context.beginTransaction();
    try {
        final T value = task.execute(context);
        context.commitTransaction();
        return value;
    } catch (Throwable e) {
        context.rollbackTransaction();
        if (e instanceof TransactionException) {
            throw (TransactionException) e;
        }
        if (e.getCause() instanceof TransactionException) {
            throw (TransactionException) e.getCause();
        }
        if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        }
        throw new TransactionException(e);
    }
}

Output:
 public <T> T executeTransaction(TransactionOptions options, TransactionalTask<T> task) throws TransactionException {
-    final TransactionContext context = newTransactionContext(options);
-    context.beginTransaction();
-    try {
-        final T value = task.execute(context);
-        context.commitTransaction();
-        return value;
-    } catch (Throwable e) {
-        context.rollbackTransaction();
-        if (e instanceof TransactionException) {
-            throw (TransactionException) e;
-        }
-        if (e.getCause() instanceof TransactionException) {
-            throw (TransactionException) e.getCause();
-        }
-        if (e instanceof RuntimeException) {
-            throw (RuntimeException) e;
-        }
-        throw new TransactionException(e);
-    }
+    return transactionManager.executeTransaction(options, task);
 }


Input:
public static String promptAndReadValue(String promptMessage) {
    LOGGER.trace("String_Node_Str");
    PropertiesUtils propsUtils = new PropertiesUtils(getProperties());
    boolean defaultEchoEnabled = propsUtils.getBoolean(Constants.CONSOLE_DEFAULT_ECHO_ENABLED_KEY, false);
    LOGGER.debug("String_Node_Str", new Object[] { defaultEchoEnabled ? "String_Node_Str" : "String_Node_Str" });
    getConsole().print(promptMessage);
    char[] passwordChars = getConsole().readPassword(defaultEchoEnabled);
    return new String(passwordChars);
}

Output:
     getConsole().print(promptMessage);
-    char[] passwordChars = getConsole().readPassword(defaultEchoEnabled);
-    return new String(passwordChars);
+    char[] responseChars = getConsole().readPassword(defaultEchoEnabled);
+    String response = new String(responseChars);
+    responseChars = null;
+    return response;
 }


Input:
private void stringColumSlice(Set<String> fieldSet, DBObject row) {
    subList = new ArrayList<DBObject>();
    Map<String, Object> map = new TreeMap<String, Object>();
    String fromField = StandardConverters.convertFromBytes(String.class, from);
    String toField = StandardConverters.convertFromBytes(String.class, to);
    for (String field : fieldSet) {
        if (!field.equalsIgnoreCase("String_Node_Str")) {
            if (field.compareTo(fromField) > 0 && field.compareTo(toField) < 0) {
                Object value = row.get(field);
                map.put(field, value);
            }
        }
    }
    for (String field : map.keySet()) {
        BasicDBObject dbObject = new BasicDBObject(field, map.get(field));
        subList.add(dbObject);
    }
}

Output:
         if (!field.equalsIgnoreCase("String_Node_Str")) {
-            if (field.compareTo(fromField) > 0 && field.compareTo(toField) < 0) {
+            if (field.compareTo(fromField) >= 0 && field.compareTo(toField) <= 0) {
                 Object value = row.get(field);


Input:
private String refresh(String application, String label) {
    initialize();
    Git git = null;
    try {
        git = createGitClient();
        if (shouldPull(git)) {
            FetchResult fetchResult = fetch(git, label);
            checkout(git, label);
            if (isBranch(git, label)) {
                MergeResult mergeResult = merge(git, label);
                if (!isClean(git)) {
                    logger.warn("String_Node_Str" + label + "String_Node_Str");
                    resetHard(git, label, "String_Node_Str" + label);
                }
            }
        } else {
            checkout(git, label);
        }
        return git.getRepository().getRef("String_Node_Str").getObjectId().getName();
    } catch (RefNotFoundException e) {
        throw new NoSuchLabelException("String_Node_Str" + label);
    } catch (GitAPIException e) {
        throw new IllegalStateException("String_Node_Str", e);
    } catch (Exception e) {
        throw new IllegalStateException("String_Node_Str", e);
    } finally {
        try {
            if (git != null) {
                git.close();
            }
        } catch (Exception e) {
            this.logger.warn("String_Node_Str", e);
        }
    }
}

Output:
         if (shouldPull(git)) {
-            FetchResult fetchResult = fetch(git, label);
+            fetch(git, label);
             checkout(git, label);


Input:
public void onListItemClicked(boolean isBackButton, int position, LayoutElementParcelable e, ImageView imageView) {
    if (results) {
        FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
        SearchWorkerFragment fragment = (SearchWorkerFragment) fragmentManager.findFragmentByTag(MainActivity.TAG_ASYNC_HELPER);
        if (fragment != null) {
            if (fragment.mSearchAsyncTask.getStatus() == AsyncTask.Status.RUNNING) {
                fragment.mSearchAsyncTask.cancel(true);
            }
            getActivity().getSupportFragmentManager().beginTransaction().remove(fragment).commit();
        }
        mRetainSearchTask = true;
        results = false;
    } else {
        mRetainSearchTask = false;
        MainActivityHelper.SEARCH_TEXT = null;
    }
    if (selection) {
        if (isBackButton) {
            selection = false;
            if (mActionMode != null)
                mActionMode.finish();
            mActionMode = null;
        } else {
            adapter.toggleChecked(position, imageView);
        }
    } else {
        if (isBackButton) {
            goBackItemClick();
        } else {
            if (getMainActivity().getAppbar().getSearchView().isEnabled()) {
                getMainActivity().getAppbar().getSearchView().hideSearchView();
            }
            String path = !e.hasSymlink() ? e.desc : e.symlink;
            if (e.isDirectory) {
                computeScroll();
                loadlist(path, false, openMode);
            } else if (e.desc.endsWith(CryptUtil.CRYPT_EXTENSION)) {
                isEncryptOpen = true;
                encryptBaseFile = new HybridFileParcelable(getActivity().getExternalCacheDir().getPath() + "String_Node_Str" + e.generateBaseFile().getName().replace(CryptUtil.CRYPT_EXTENSION, "String_Node_Str"));
                encryptBaseFiles.add(encryptBaseFile);
                EncryptDecryptUtils.decryptFile(getContext(), getMainActivity(), ma, openMode, e.generateBaseFile(), getActivity().getExternalCacheDir().getPath(), utilsProvider, true);
            } else {
                if (getMainActivity().mReturnIntent) {
                    returnIntentResults(e.generateBaseFile());
                } else {
                    switch(e.getMode()) {
                        case SMB:
                            try {
                                SmbFile smbFile = new SmbFile(e.desc);
                                launchSMB(smbFile, e.longSize, getMainActivity());
                            } catch (MalformedURLException ex) {
                                ex.printStackTrace();
                            }
                            break;
                        case SFTP:
                            Toast.makeText(getContext(), getResources().getString(R.string.please_wait), Toast.LENGTH_LONG).show();
                            SshClientUtils.launchSftp(e.generateBaseFile(), getMainActivity());
                            break;
                        case OTG:
                            FileUtils.openFile(OTGUtil.getDocumentFile(e.desc, getContext(), false), (MainActivity) getActivity(), sharedPref);
                            break;
                        case DROPBOX:
                        case BOX:
                        case GDRIVE:
                        case ONEDRIVE:
                            Toast.makeText(getContext(), getResources().getString(R.string.please_wait), Toast.LENGTH_LONG).show();
                            CloudUtil.launchCloud(e.generateBaseFile(), openMode, getMainActivity());
                            break;
                        default:
                            FileUtils.openFile(new File(e.desc), (MainActivity) getActivity(), sharedPref);
                            break;
                    }
                    dataUtils.addHistoryFile(e.desc);
                }
            }
        }
    }
}

Output:
                         case SMB:
-                            try {
-                                SmbFile smbFile = new SmbFile(e.desc);
-                                launchSMB(smbFile, e.longSize, getMainActivity());
-                            } catch (MalformedURLException ex) {
-                                ex.printStackTrace();
-                            }
+                            launchSMB(e.generateBaseFile(), getMainActivity());
                             break;


Input:
public String deleteRole() {
    try {
        String frontEndCaseDataIn = extractWidgetConfig("String_Node_Str");
        this.setFrontEndCaseData(frontEndCaseDataIn);
        if (this.getChannelPath().equalsIgnoreCase(this.getFrontEndCaseData())) {
            this.getCaseManager().setKieServerConfiguration(this.getKnowledgeSourceId());
            System.out.println("String_Node_Str" + this.getChannelPath() + "String_Node_Str" + this.getContainerid() + "String_Node_Str" + this.getCasePath() + "String_Node_Str" + this.getCaseRoleName() + "String_Node_Str" + this.getUser() + "String_Node_Str" + this.getGroup());
            this.getCaseManager().deleteCaseRoles(this.getContainerid(), this.getCasePath(), this.getCaseRoleName(), this.getUser(), this.getGroup());
            this.setRoles(this.getCaseManager().getCaseRoles(this.getContainerid(), this.getCasePath()).toString());
        }
    } catch (ApsSystemException t) {
        logger.error("String_Node_Str", t);
        return FAILURE;
    }
    return SUCCESS;
}

Output:
         this.setFrontEndCaseData(frontEndCaseDataIn);
-        if (this.getChannelPath().equalsIgnoreCase(this.getFrontEndCaseData())) {
+        String channelIn = extractWidgetConfig("String_Node_Str");
+        this.setChannel(channelIn);
+        if (this.getChannelPath().equalsIgnoreCase(this.getChannel())) {
             this.getCaseManager().setKieServerConfiguration(this.getKnowledgeSourceId());


Input:
public void testPatchedNameKeysGazaHistoric() throws Exception {
    DateTimeZone zone = DateTimeZone.forID("String_Node_Str");
    DateTime now = new DateTime(1944, 1, 1, 0, 0, 0, 0);
    String str1 = zone.getName(now.getMillis());
    String str2 = zone.getName(now.plusMonths(6).getMillis());
    assertEquals(false, str1.equals(str2));
}

Output:
     DateTimeZone zone = DateTimeZone.forID("String_Node_Str");
-    DateTime now = new DateTime(1944, 1, 1, 0, 0, 0, 0);
+    DateTime now = new DateTime(1943, 1, 1, 0, 0, 0, 0);
     String str1 = zone.getName(now.getMillis());


Input:
public MapperSettingModel getCurrnentModel() {
    return this.currnentModel;
}

Output:
 public MapperSettingModel getCurrnentModel() {
-    return this.currnentModel;
+    return this.currentModel;
 }


Input:
public void paint(Graphics g) {
    if (wantsPaint) {
        synchronized (getHandleLock()) {
            long handle;
            if ((handle = getHandle()) != 0) {
                Container parent = getParent();
                int zOrder = (parent == null) ? -1 : parent.getComponentZOrder(this);
                wantsPaint = JAWTRenderer.paint(handle, this, g, zOrder);
            }
        }
    }
}

Output:
 public void paint(Graphics g) {
-    if (wantsPaint) {
+    if (wantsPaint && (getWidth() >= SwScale.MIN_SWS_SCALE_HEIGHT_OR_WIDTH) && (getHeight() >= SwScale.MIN_SWS_SCALE_HEIGHT_OR_WIDTH)) {
         synchronized (getHandleLock()) {


Input:
public SqlConvertible createQuery(List<ExecutionInfoToken> tokens) throws VerdictDBException {
    savedToken = tokens.get(0);
    List<HyperTableCube> cubes = ((AggMeta) savedToken.getValue("String_Node_Str")).getCubes();
    HashMap<List<Integer>, Double> scaleFactor = calculateScaleFactor(cubes);
    Pair<List<ColumnOp>, SqlConvertible> aggColumnsAndQuery = createBaseQueryForReplacement(cubes);
    if (scaleFactor.size() == 1) {
        Double s = (Double) (scaleFactor.values().toArray())[0];
        for (ColumnOp col : aggColumnsAndQuery.getLeft()) {
            col.setOperand(0, ConstantColumn.valueOf(String.format("String_Node_Str", s)));
        }
    } else {
        for (ColumnOp col : aggColumnsAndQuery.getLeft()) {
            String alias = ((BaseColumn) col.getOperand(1)).getColumnName();
            col.setOpType("String_Node_Str");
            List<UnnamedColumn> operands = new ArrayList<>();
            for (Map.Entry<List<Integer>, Double> entry : scaleFactor.entrySet()) {
                UnnamedColumn condition = generateCaseCondition(entry.getKey());
                operands.add(condition);
                ColumnOp multiply = new ColumnOp("String_Node_Str", Arrays.asList(ConstantColumn.valueOf(String.format("String_Node_Str", entry.getValue())), col.getOperand(1)));
                operands.add(multiply);
            }
            operands.add(ConstantColumn.valueOf(0));
            col.setOperand(operands);
        }
    }
    SelectQuery query;
    if (multipleTierTableTierInfo.size() > 0) {
        query = sumUpTierGroup((SelectQuery) aggColumnsAndQuery.getRight(), ((AggMeta) savedToken.getValue("String_Node_Str")));
    } else
        query = (SelectQuery) aggColumnsAndQuery.getRight();
    Pair<String, String> tempTableFullName = getNamer().generateTempTableName();
    newTableSchemaName = tempTableFullName.getLeft();
    newTableName = tempTableFullName.getRight();
    SelectQuery createTableQuery = replaceWithOriginalSelectList(query, ((AggMeta) savedToken.getValue("String_Node_Str")));
    if (selectQuery != null) {
        if (!selectQuery.getGroupby().isEmpty()) {
            createTableQuery.addGroupby(selectQuery.getGroupby());
        }
        if (!selectQuery.getOrderby().isEmpty()) {
            createTableQuery.addOrderby(selectQuery.getOrderby());
        }
        if (selectQuery.getHaving().isPresent()) {
            createTableQuery.addHavingByAnd(selectQuery.getHaving().get());
        }
        if (selectQuery.getLimit().isPresent()) {
            createTableQuery.addLimit(selectQuery.getLimit().get());
        }
    }
    CreateTableAsSelectQuery createQuery = new CreateTableAsSelectQuery(newTableSchemaName, newTableName, createTableQuery);
    return createQuery;
}

Output:
     if (selectQuery != null) {
-        if (!selectQuery.getGroupby().isEmpty()) {
+        if (!selectQuery.getGroupby().isEmpty() && selectQuery.getHaving().isPresent()) {
             createTableQuery.addGroupby(selectQuery.getGroupby());


Input:
public Object invoke(Object[] arguments) {
    arguments = ParameterUtils.getActualArguments(arguments, length, isVarArgs, 0);
    return method.invoke(null, arguments);
}

Output:
 public Object invoke(Object[] arguments) {
-    arguments = ParameterUtils.getActualArguments(arguments, length, isVarArgs, 0);
+    arguments = ParameterUtils.getActualArguments(arguments, length, varArgsClass, 0);
     return method.invoke(null, arguments);


Input:
public void translate(Stack<GraphTargetItem> stack, List<GraphTargetItem> output, java.util.HashMap<Integer, String> regNames, HashMap<String, GraphTargetItem> variables, HashMap<String, GraphTargetItem> functions) {
    GraphTargetItem value = stack.pop();
    GraphTargetItem name = stack.pop();
    variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)), value);
    output.add(new DefineLocalTreeItem(this, name, value));
}

Output:
     GraphTargetItem name = stack.pop();
-    variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)), value);
+    variables.put(Highlighting.stripHilights(name.toStringNoQuotes((ConstantPool) null)), value);
     output.add(new DefineLocalTreeItem(this, name, value));


Input:
protected String generateNonce() {
    byte[] random = new byte[16];
    StringBuilder buffer = new StringBuilder();
    randomSource.nextBytes(random);
    for (int j = 0; j < random.length; j++) {
        byte b1 = (byte) ((random[j] & 0xf0) >> 4);
        byte b2 = (byte) (random[j] & 0x0f);
        if (b1 < 10)
            buffer.append((char) ('0' + b1));
        else
            buffer.append((char) ('A' + (b1 - 10)));
        if (b2 < 10)
            buffer.append((char) ('0' + b2));
        else
            buffer.append((char) ('A' + (b2 - 10)));
    }
    return buffer.toString();
}

Output:
         byte b2 = (byte) (random[j] & 0x0f);
-        if (b1 < 10)
+        if (b1 < 10) {
             buffer.append((char) ('0' + b1));


Input:
public void onZoom(boolean zoomIn) {
    if (mZooming)
        return;
    if (zoomIn) {
        if (mZoomValue < mZoomMax) {
            mZoomValue += mZoomStep;
            zoomToLevel(ZOOM_CONTINUOUS);
        }
    } else {
        if (mZoomValue > ZOOM_MIN) {
            mZoomValue -= mZoomStep;
            zoomToLevel(ZOOM_CONTINUOUS);
        }
    }
    updateZoomButtonsEnabled();
}

Output:
 public void onZoom(boolean zoomIn) {
-    if (mZooming)
+    if (isZooming())
         return;


Input:
void obliterateMenu() {
    if (_native != null) {
        synchronized (menuEntries) {
            for (int i = 0; i < menuEntries.size(); i++) {
                MenuEntry menuEntry__ = menuEntries.get(i);
                if (menuEntry__ instanceof GtkEntry) {
                    ((GtkEntry) menuEntry__).removePrivate();
                } else if (menuEntry__ instanceof GtkMenu) {
                    ((GtkMenu) menuEntry__).removePrivate();
                }
            }
            menuEntries.clear();
            Gtk.gtk_widget_destroy(_native);
        }
    }
}

Output:
 void obliterateMenu() {
-    if (_native != null) {
+    if (_native != null && !obliterateInProgress) {
+        obliterateInProgress = true;
         synchronized (menuEntries) {


Input:
public final char nextChar() {
    if (length == -1) {
        throw new EOFException();
    }
    char ch = buffer[i - 1];
    if (i >= length) {
        updateBuffer();
    }
    i++;
    if (lineSeparator1 == ch && (lineSeparator2 == '\0' || lineSeparator2 == buffer[i - 1])) {
        lineCount++;
        if (lineSeparator2 != '\0') {
            ch = normalizedLineSeparator;
            if (i >= length) {
                if (length != -1) {
                    updateBuffer();
                } else {
                    throw new EOFException();
                }
            }
            if (i < length) {
                i++;
            }
        } else {
            return normalizedLineSeparator;
        }
    }
    return ch;
}

Output:
     if (length == -1) {
-        throw new EOFException();
+        throwEOFException();
     }


Input:
public double adagradL1(String feature, double param, long iter) {
    double eta = (initialLearningRate * iter) / Math.sqrt(gradients.getCoordinate(feature));
    double u = unnormalizedGradients.getCoordinate(feature);
    double normalizedGradient = u / iter;
    if (Math.abs(normalizedGradient) <= laplace) {
        param = 0.0;
    } else {
        param = -(Math.signum(u) * eta * (normalizedGradient - laplace));
    }
    return param;
}

Output:
 public double adagradL1(String feature, double param, long iter) {
-    double eta = (initialLearningRate * iter) / Math.sqrt(gradients.getCoordinate(feature));
+    double eta = (initialLearningRate * iter) / Math.sqrt(summedGradients.getCoordinate(feature));
     double u = unnormalizedGradients.getCoordinate(feature);


Input:
private Sound transformSubsound(Sound[] subSound, int channelNum, int frequency, int length) {
    int percent = (int) (frequency * 100.0 / this.frequency);
    Sound result = subSound[channelNum];
    PitchSoundTransformation pitcher = new PitchSoundTransformation(percent);
    if (percent < 98 || percent > 102) {
        result = pitcher.transform(result);
    }
    double factor = length / subSound.length;
    if (factor < 0.98 || factor > 1.02) {
        if (factor < 0.98) {
            SpeedUpSoundTransformation speedup = new SpeedUpSoundTransformation(100, percent);
            result = speedup.transform(result);
        } else if (factor > 1.02) {
            SlowdownSoundTransformation slowdown = new SlowdownSoundTransformation(100, percent);
            result = slowdown.transform(result);
        }
    }
    return result;
}

Output:
     }
-    double factor = length / subSound.length;
+    double factor = length / subSound[0].getSamples().length;
     if (factor < 0.98 || factor > 1.02) {


Input:
public void execute(AdminCommandContext context) {
    report = context.getActionReport();
    logger = context.getLogger();
    if (!checkEnvAndParams()) {
        return;
    }
    if (logger.isLoggable(Level.FINE)) {
        logger.log(Level.FINE, Strings.get("String_Node_Str", containerType));
    }
    Set<String> allPersistenceTypes = BackingStoreFactoryRegistry.getRegisteredTypes();
    allPersistenceTypes.remove("String_Node_Str");
    if (containerType.equals("String_Node_Str")) {
        allPersistenceTypes.remove("String_Node_Str");
    }
    StringBuilder sb = new StringBuilder("String_Node_Str");
    boolean removeTrailingSeparator = false;
    for (String type : allPersistenceTypes) {
        sb.append(type).append(SEPARATOR);
        removeTrailingSeparator = true;
    }
    String output = sb.toString();
    if (removeTrailingSeparator) {
        output = output.substring(0, output.length() - 1);
    }
    Properties extraProperties = new Properties();
    extraProperties.put("String_Node_Str", new ArrayList<String>(allPersistenceTypes));
    report.setExtraProperties(extraProperties);
    report.setMessage(output);
    report.setActionExitCode(ActionReport.ExitCode.SUCCESS);
}

Output:
 public void execute(AdminCommandContext context) {
-    report = context.getActionReport();
+    ActionReport report = context.getActionReport();
     logger = context.getLogger();


Input:
public Map<Service, Map<Capability, String>> getNetworkCapabilities(long networkId) {
    Network network = getNetwork(networkId);
    if (network == null) {
        throw new InvalidParameterValueException("String_Node_Str" + networkId);
    }
    Map<Service, Map<Capability, String>> zoneCapabilities = getZoneCapabilities(network.getDataCenterId());
    Map<Service, Map<Capability, String>> networkCapabilities = new HashMap<Service, Map<Capability, String>>();
    for (Service service : zoneCapabilities.keySet()) {
        if (isServiceSupported(networkId, service)) {
            networkCapabilities.put(service, zoneCapabilities.get(service));
        }
    }
    return networkCapabilities;
}

Output:
     for (Service service : zoneCapabilities.keySet()) {
-        if (isServiceSupported(networkId, service)) {
+        if (isServiceSupported(networkOfferingId, service)) {
             networkCapabilities.put(service, zoneCapabilities.get(service));


Input:
public void render(float delta, Batcher batcher) {
    RenderUtils.fillPolygon(batcher, getPolygon(), getVelocity().scale(delta), color);
    RenderUtils.tracePolygon(batcher, getPolygon(), getVelocity().scale(delta), Color.GREEN);
}

Output:
 public void render(float delta, Batcher batcher) {
-    RenderUtils.fillPolygon(batcher, getPolygon(), getVelocity().scale(delta), color);
-    RenderUtils.tracePolygon(batcher, getPolygon(), getVelocity().scale(delta), Color.GREEN);
+    RenderUtils.fillPolygon(batcher, getPolygon(), temp.set(getVelocity()), color);
+    RenderUtils.tracePolygon(batcher, getPolygon(), temp.set(getVelocity()), Color.GREEN);
 }


Input:
protected int internalCompare(final int row1, final int row2, final int[] columns, final boolean ascending) {
    for (final int index : columns) {
        final int attributeType = inverseMap[index] >>> AttributeType.SHIFT;
        final int indexMap = inverseMap[index] & AttributeType.MASK;
        if (attributeType == AttributeType.ATTR_TYPE_ID)
            return 0;
        int cmp = 0;
        try {
            String s1 = internalGetValue(row1, index);
            String s2 = internalGetValue(row2, index);
            cmp = (s1 == suppressionString && s2 == suppressionString) ? 0 : (s1 == suppressionString ? +1 : (s2 == suppressionString ? -1 : dataTypes[attributeType][indexMap].compare(s1, s2)));
        } catch (final Exception e) {
            throw new RuntimeException(e);
        }
        if (cmp != 0) {
            if (ascending) {
                return -cmp;
            } else {
                return cmp;
            }
        }
    }
    return 0;
}

Output:
         if (cmp != 0) {
-            if (ascending) {
-                return -cmp;
-            } else {
-                return cmp;
-            }
+            return ascending ? cmp : -cmp;
         }


Input:
public void start() {
    logger.info("String_Node_Str", this.getClass().getSimpleName());
    if (!workerThread.isAlive()) {
        this.isStarted = true;
        this.workerThread.start();
        logger.info("String_Node_Str", this.getClass().getSimpleName());
    } else {
        logger.info("String_Node_Str", this.getClass().getSimpleName());
    }
}

Output:
 public void start() {
-    logger.info("String_Node_Str", this.getClass().getSimpleName());
+    final ThreadFactory threadFactory = new PinpointThreadFactory(this.getClass().getSimpleName(), true);
+    this.workerThread = threadFactory.newThread(this);
+    logger.info("String_Node_Str");
     if (!workerThread.isAlive()) {


Input:
public Builder withTestSize(String testSize) {
    this.testSize = IRemoteAndroidTestRunner.TestSize.getTestSize(testSize);
    return this;
}

Output:
 public Builder withTestSize(String testSize) {
-    this.testSize = IRemoteAndroidTestRunner.TestSize.getTestSize(testSize);
+    this.testSize = (testSize == null ? null : IRemoteAndroidTestRunner.TestSize.getTestSize(testSize));
     return this;


Input:
private void _setActorIcon(String actorClassNameString, ComponentEntity tempActorInstance) throws IllegalActionException {
    String iconFile = actorClassNameString.replace('.', '/') + "String_Node_Str";
    URL xmlFile = tempActorInstance.getClass().getClassLoader().getResource(iconFile);
    if (xmlFile != null) {
        try {
            MoMLParser parser = new MoMLParser(this.workspace());
            parser.setContext(this);
            parser.setContext(tempActorInstance);
            parser.parse(xmlFile, xmlFile);
            List<EditorIcon> tempActorIconList = tempActorInstance.attributeList(EditorIcon.class);
            if (!tempActorIconList.isEmpty()) {
                EditorIcon actorIcon = tempActorIconList.get(0);
                String actorIconMoML = actorIcon.exportMoML();
                MoMLVariableChecker momlChecker = new MoMLVariableChecker();
                String prependMoML = momlChecker.checkCopy(actorIconMoML, tempActorInstance, true);
                parser.setContext(this);
                if (prependMoML != null && !prependMoML.equals("String_Node_Str")) {
                    parser.parse(prependMoML);
                }
                parser.parse(actorIconMoML);
            }
        } catch (Exception ex) {
            throw new IllegalActionException(this, ex, "String_Node_Str" + "String_Node_Str");
        }
    } else {
        ConfigurableAttribute actorIconAttribute = (ConfigurableAttribute) ((ComponentEntity) tempActorInstance).getAttribute("String_Node_Str");
        if (actorIconAttribute != null) {
            String iconDescription = actorIconAttribute.getConfigureText();
            SingletonConfigurableAttribute description = (SingletonConfigurableAttribute) this.getAttribute("String_Node_Str");
            try {
                description.configure(null, null, iconDescription);
            } catch (Exception ex) {
                throw new IllegalActionException(this, ex, "String_Node_Str" + "String_Node_Str");
            }
        }
    }
}

Output:
                 parser.setContext(this);
-                if (prependMoML != null && !prependMoML.equals("String_Node_Str")) {
-                    parser.parse(prependMoML);
-                }
-                parser.parse(actorIconMoML);
+                parser.parse(iconMoML.toString());
             }


Input:
public ByteProcessor getProcessor(String urlString, int mipmapLevel) {
    if ((lastByteProcessor == null) || (!urlString.equals(lastUrlString)) || (mipmapLevel != lastMipmapLevel)) {
        lastByteProcessor = buildByteProcessor(urlString, mipmapLevel);
        lastUrlString = urlString;
        lastMipmapLevel = mipmapLevel;
    }
    return lastByteProcessor;
}

Output:
     if ((lastByteProcessor == null) || (!urlString.equals(lastUrlString)) || (mipmapLevel != lastMipmapLevel)) {
-        lastByteProcessor = buildByteProcessor(urlString, mipmapLevel);
+        lastByteProcessor = buildByteProcessor(urlString, mipmapLevel, isDownSamplingNeeded);
         lastUrlString = urlString;


Input:
public SAMRecordIterator assertSorted(final SortOrder sortOrder) {
    return null;
}

Output:
 public SAMRecordIterator assertSorted(final SortOrder sortOrder) {
-    return null;
+    return this;
 }