Input:
void create(String namespaceId, String name, DatasetInstanceConfiguration props) throws Exception {
    Id.Namespace namespace = ConversionHelpers.toNamespaceId(namespaceId);
    Principal principal = authenticationContext.getPrincipal();
    authorizationEnforcer.enforce(namespace.toEntityId(), principal, Action.WRITE);
    ensureNamespaceExists(namespace);
    Id.DatasetInstance newInstance = ConversionHelpers.toDatasetInstanceId(namespaceId, name);
    DatasetSpecification existing = instanceManager.get(newInstance);
    if (existing != null) {
        throw new DatasetAlreadyExistsException(newInstance);
    }
    DatasetTypeMeta typeMeta = getTypeInfo(namespace, props.getTypeName());
    if (typeMeta == null) {
        throw new DatasetTypeNotFoundException(ConversionHelpers.toDatasetTypeId(namespace, props.getTypeName()));
    }
    DatasetId datasetId = newInstance.toEntityId();
    authorizer.revoke(datasetId);
    authorizer.grant(datasetId, principal, ImmutableSet.of(Action.ALL));
    LOG.info("String_Node_Str", namespaceId, name, props.getTypeName(), props.getProperties());
    try {
        DatasetSpecification spec = opExecutorClient.create(newInstance, typeMeta, DatasetProperties.builder().addAll(props.getProperties()).setDescription(props.getDescription()).build());
        instanceManager.add(namespace, spec);
        metaCache.invalidate(newInstance);
        publishAudit(newInstance, AuditType.CREATE);
        enableExplore(newInstance, spec, props);
    } catch (Exception e) {
        authorizer.revoke(datasetId);
        throw e;
    }
}

Output:
     DatasetId datasetId = newInstance.toEntityId();
-    authorizer.revoke(datasetId);
-    authorizer.grant(datasetId, principal, ImmutableSet.of(Action.ALL));
+    privilegesManager.revoke(datasetId);
+    privilegesManager.grant(datasetId, principal, ImmutableSet.of(Action.ALL));
     LOG.info("String_Node_Str", namespaceId, name, props.getTypeName(), props.getProperties());


Input:
public ClassLoader create(DatasetModuleMeta moduleMeta, ClassLoader parentClassLoader) throws IOException {
    if (moduleMeta.getJarLocation() == null) {
        return parentClassLoader;
    }
    Location jarLocation = locationFactory.create(moduleMeta.getJarLocation());
    File tmpJar = File.createTempFile(jarLocation.getName(), null);
    try {
        MessageDigest messageDigest = MESSAGE_DIGEST.get();
        DigestOutputStream digestOutput = new DigestOutputStream(new FileOutputStream(tmpJar), messageDigest);
        try {
            ByteStreams.copy(Locations.newInputSupplier(jarLocation), digestOutput);
        } finally {
            digestOutput.close();
        }
        String dirName = String.format("String_Node_Str", moduleMeta.getName(), HashCodes.fromBytes(messageDigest.digest()));
        File expandDir = new File(tmpJar.getParent(), dirName);
        if (!expandDir.isDirectory()) {
            File tempDir = Files.createTempDir();
            try {
                BundleJarUtil.unpackProgramJar(Files.newInputStreamSupplier(tmpJar), tempDir);
                if (!tempDir.renameTo(expandDir) && !expandDir.isDirectory()) {
                    throw new IOException("String_Node_Str" + tempDir + "String_Node_Str" + expandDir);
                }
            } finally {
                try {
                    if (tempDir.exists()) {
                        DirUtils.deleteDirectoryContents(tempDir);
                    }
                } catch (IOException e) {
                    LOG.warn("String_Node_Str", tempDir, e);
                }
            }
        }
        return new DirectoryClassLoader(expandDir, parentClassLoader, "String_Node_Str");
    } finally {
        tmpJar.delete();
    }
}

Output:
         }
-        String dirName = String.format("String_Node_Str", moduleMeta.getName(), HashCodes.fromBytes(messageDigest.digest()));
+        String dirName = String.format("String_Node_Str", moduleMeta.getName(), Bytes.toStringBinary(messageDigest.digest()));
         File expandDir = new File(tmpJar.getParent(), dirName);


Input:
public List<DifferentialFunction<X>> diff(List<DifferentialFunction<X>> i_v) {
    return (DifferentialFunction<X>) (i_v == this ? sameDiff.getFunctionFactory().one(i_v.getResultShape()) : sameDiff.getFunctionFactory().zero(i_v.getResultShape()));
}

Output:
 public List<DifferentialFunction<X>> diff(List<DifferentialFunction<X>> i_v) {
-    return (DifferentialFunction<X>) (i_v == this ? sameDiff.getFunctionFactory().one(i_v.getResultShape()) : sameDiff.getFunctionFactory().zero(i_v.getResultShape()));
+    List<DifferentialFunction<X>> ret = new ArrayList<>();
+    if (i_v == this)
+        ret.add((DifferentialFunction<X>) sameDiff.getFunctionFactory().one(i_v.get(0).getResultShape()));
+    else
+        ret.add((DifferentialFunction<X>) sameDiff.getFunctionFactory().zero(i_v.get(0).getResultShape()));
+    return ret;
 }


Input:
public void createIndicesOnUniqueKeys(AbstractSession session, Writer schemaWriter) throws EclipseLinkException {
    if (schemaWriter == null) {
        createIndicesOnUniqueKeysOnDatabase(session);
        return;
    }
    try {
        for (UniqueKeyConstraint uniqueKey : getUniqueKeys()) {
            buildIndexCreationWriter(session, uniqueKey.getName(), uniqueKey.getSourceFields(), schemaWriter);
            if (createSQLFiles) {
                schemaWriter.write(session.getPlatform().getStoredProcedureTerminationToken());
            }
            schemaWriter.write("String_Node_Str");
        }
        for (FieldDefinition field : getFields()) {
            if (field.isUnique()) {
                List<String> columnAsList = new ArrayList<String>();
                columnAsList.add(field.getName());
                buildIndexCreationWriter(session, field.getName(), columnAsList, new StringWriter());
                if (createSQLFiles) {
                    schemaWriter.write(session.getPlatform().getStoredProcedureTerminationToken());
                }
                schemaWriter.write("String_Node_Str");
            }
        }
    } catch (IOException exception) {
        throw ValidationException.fileError(exception);
    }
}

Output:
                 columnAsList.add(field.getName());
-                buildIndexCreationWriter(session, field.getName(), columnAsList, new StringWriter());
+                buildIndexCreationWriter(session, field.getName(), columnAsList, schemaWriter);
                 if (createSQLFiles) {


Input:
public static void main(String[] args) throws Exception {
    System.out.printf("String_Node_Str");
    if (args.length < 1) {
        System.out.println("String_Node_Str");
        return;
    }
    if (Os.type == Os._32Bit) {
        System.out.println("String_Node_Str");
        return;
    }
    String dir = args[0];
    extractSite(dir);
    File conf = new File(dir, "String_Node_Str");
    if (!conf.exists()) {
        System.out.println("String_Node_Str" + conf);
        return;
    }
    final HttpServerConfiguration configuration = new HttpServerConfiguration(conf);
    configureLoggers(configuration);
    final SimpleUrlMatcher matcher = new SimpleUrlMatcher();
    JournalFactory factory = new JournalFactory(configuration.getDbPath().getAbsolutePath());
    matcher.put("String_Node_Str", new ImportHandler(factory));
    matcher.put("String_Node_Str", new QueryHandler(new JournalFactoryPool(factory.getConfiguration(), configuration.getJournalPoolSize())));
    matcher.put("String_Node_Str", new ExistenceCheckHandler(factory));
    matcher.setDefaultHandler(new StaticContentHandler(configuration.getHttpPublic(), new MimeTypes(configuration.getMimeTypes())));
    HttpServer server = new HttpServer(configuration, matcher);
    server.start(LogFactory.INSTANCE.getJobs());
    StringBuilder welcome = new StringBuilder();
    welcome.append("String_Node_Str").append(configuration.getHttpIP()).append(':').append(configuration.getHttpPort());
    if (configuration.getSslConfig().isSecure()) {
        welcome.append("String_Node_Str");
    } else {
        welcome.append("String_Node_Str");
    }
    System.out.println(welcome);
}

Output:
     String dir = args[0];
-    extractSite(dir);
+    String flag = args.length > 1 ? args[1] : null;
+    extractSite(dir, "String_Node_Str".equals(flag));
     File conf = new File(dir, "String_Node_Str");


Input:
private List<String> unescape(String rawParameter, boolean split) throws CommandParameterParseException {
    String string = rawParameter;
    List<String> params = new ArrayList<>();
    int i = -1;
    while (i < string.length()) {
        i++;
        char c = string.charAt(i);
        if (c == Command.ARRAY_DELIMITER_ESCAPE_CHARACTER) {
            if (i >= string.length() - 1) {
                throw new CommandParameterParseException("String_Node_Str", rawParameter);
            }
            string = string.substring(0, i) + string.substring(i + 1);
            char following = string.charAt(i);
            if (following != Command.ARRAY_DELIMITER_ESCAPE_CHARACTER && (!split || following != arrayDelimiter)) {
                throw new CommandParameterParseException("String_Node_Str" + following + "String_Node_Str", rawParameter);
            }
            continue;
        }
        if (split && c == arrayDelimiter) {
            String param = string.substring(0, i);
            string = string.substring(i + 1);
            i = -1;
            params.add(param);
        }
    }
    if (string.length() > 0) {
        params.add(string);
    }
    return params;
}

Output:
     List<String> params = new ArrayList<>();
-    int i = -1;
+    int i = 0;
     while (i < string.length()) {


Input:
public Ternary isInterfaceMethod() {
    if (getMethodInfo() != null) {
        return Ternary.valueOf(methodInfo.getClassInfo().isInterface());
    }
    return classRef.isInterface();
}

Output:
 public Ternary isInterfaceMethod() {
-    if (getMethodInfo() != null) {
+    if (methodInfo != null) {
         return Ternary.valueOf(methodInfo.getClassInfo().isInterface());


Input:
public boolean progress() {
    if (player.isDead() || !player.isOnline()) {
        instances.remove(id);
        return false;
    }
    if (Methods.isRegionProtectedFromBuild(player, "String_Node_Str", location)) {
        instances.remove(id);
        return false;
    }
    speedfactor = speed * (ProjectKorra.time_step / 1000.);
    ticks++;
    if (ticks > maxticks) {
        instances.remove(id);
        return false;
    }
    Block block = location.getBlock();
    for (Block testblock : Methods.getBlocksAroundPoint(location, affectingradius)) {
        if (testblock.getType() == Material.FIRE) {
            testblock.setType(Material.AIR);
            testblock.getWorld().playEffect(testblock.getLocation(), Effect.EXTINGUISH, 0);
        }
        if (((block.getType() == Material.LEVER) || (block.getType() == Material.STONE_BUTTON)) && !affectedlevers.contains(block)) {
            affectedlevers.add(block);
        }
    }
    if ((Methods.isSolid(block) || block.isLiquid()) && !affectedlevers.contains(block)) {
        if (block.getType() == Material.LAVA || block.getType() == Material.STATIONARY_LAVA) {
            if (block.getData() == full) {
                block.setType(Material.OBSIDIAN);
            } else {
                block.setType(Material.COBBLESTONE);
            }
        }
        instances.remove(id);
        return false;
    }
    if (location.distance(origin) > range) {
        instances.remove(id);
        return false;
    }
    for (Entity entity : Methods.getEntitiesAroundPoint(location, affectingradius)) {
        affect(entity);
    }
    advanceLocation();
    return true;
}

Output:
     }
-    if (location.distance(origin) > range) {
+    double dist = location.distance(origin);
+    if (Double.isNaN(dist) || dist > range) {
         instances.remove(id);


Input:
public void setUp() throws Exception {
    OpenAPITestUtil.removeAllApplication(server);
    OpenAPITestUtil.changeServerPorts(server, server.getHttpDefaultPort(), server.getHttpDefaultSecurePort());
    server.setMarkToEndOfLog();
}

Output:
     OpenAPITestUtil.changeServerPorts(server, server.getHttpDefaultPort(), server.getHttpDefaultSecurePort());
-    server.setMarkToEndOfLog();
+    OpenAPITestUtil.setMarkToEndOfAllLogs(server);
 }


Input:
public void processAction(FormDef model, TreeReference contextRef) {
    TreeReference qualifiedReference = contextRef == null ? target : target.contextualize(contextRef);
    if (contextRef != null) {
        if (!contextRef.isParentOf(qualifiedReference, false)) {
            return;
        }
    }
    EvaluationContext context = new EvaluationContext(model.getEvaluationContext(), qualifiedReference);
    Object result;
    if (explicitValue != null) {
        result = explicitValue;
    } else {
        result = XPathFuncExpr.unpack(value.eval(model.getMainInstance(), context));
    }
    AbstractTreeElement node = context.resolveReference(qualifiedReference);
    if (node == null) {
        throw new NullPointerException("String_Node_Str" + qualifiedReference.toString(true) + "String_Node_Str");
    }
    int dataType = node.getDataType();
    IAnswerData val = Recalculate.wrapData(result, dataType);
    model.setValue(val == null ? null : AnswerDataFactory.templateByDataType(dataType).cast(val.uncast()), qualifiedReference);
}

Output:
     if (node == null) {
-        throw new NullPointerException("String_Node_Str" + qualifiedReference.toString(true) + "String_Node_Str");
+        throw new NullPointerException(failMessage);
     }


Input:
private Port _deletePort(String portName, String entityName) throws Exception {
    Port toDelete = null;
    Entity portContainer = null;
    if (entityName == null) {
        toDelete = _searchForPort(portName);
        if (toDelete != null) {
            portContainer = (Entity) toDelete.getContainer();
        }
    } else {
        portContainer = _searchForEntity(entityName, _current);
        if (portContainer != null) {
            toDelete = portContainer.getPort(portName);
        }
    }
    if (toDelete == null) {
        throw new XmlException("String_Node_Str" + portName, _currentExternalEntity(), _parser.getLineNumber(), _parser.getColumnNumber());
    }
    if (portContainer == null) {
        throw new XmlException("String_Node_Str" + portName, _currentExternalEntity(), _parser.getLineNumber(), _parser.getColumnNumber());
    }
    if (toDelete.isDerived()) {
        throw new IllegalActionException(toDelete, "String_Node_Str");
    }
    StringBuffer undoMoML = new StringBuffer();
    try {
        Iterator heritage = toDelete.getDerivedList().iterator();
        List reverse = new LinkedList();
        while (heritage.hasNext()) {
            reverse.add(0, heritage.next());
        }
        heritage = reverse.iterator();
        while (heritage.hasNext()) {
            Port inherited = (Port) heritage.next();
            String toUndo = _getUndoForDeletePort(inherited);
            inherited.setContainer(null);
            undoMoML.insert(0, toUndo);
        }
        String toUndo = _getUndoForDeletePort(toDelete);
        toDelete.setContainer(null);
        undoMoML.insert(0, toUndo);
    } finally {
        if (_undoEnabled && _undoContext.isUndoable()) {
            undoMoML.insert(0, "String_Node_Str");
            undoMoML.append("String_Node_Str");
            _undoContext.appendUndoMoML(undoMoML.toString());
        }
    }
    return toDelete;
}

Output:
     if (toDelete == null) {
-        throw new XmlException("String_Node_Str" + portName, _currentExternalEntity(), _parser.getLineNumber(), _parser.getColumnNumber());
+        return null;
     }


Input:
public void pageChanged(PageChangedEvent event) {
    if (event.getSelectedPage() == this) {
        FishersExactTestWizard wizard = (FishersExactTestWizard) getWizard();
        DataCellInfo info1 = wizard.getInfo1();
        DataCellInfo info2 = wizard.getInfo2();
        IDataClassifier classifier1 = wizard.getCell1Classifier();
        IDataClassifier classifier2 = wizard.getCell2Classifier();
        IDMappingManager mappingManager = IDMappingManagerRegistry.get().getIDMappingManager(info1.columnPerspective.getIdType());
        IIDTypeMapper<Object, Object> mapper = mappingManager.getIDTypeMapper(info1.columnPerspective.getIdType(), info2.columnPerspective.getIdType());
        contingencyTable = new int[2][2];
        for (int cell1ColumnID : info1.columnPerspective.getVirtualArray()) {
            int index1 = getContingencyIndex(info1.dataDomain, info1.columnPerspective.getIdType(), cell1ColumnID, info1.rowIDType, info1.rowID, classifier1);
            if (index1 == -1)
                continue;
            Set<Object> cell2ColumnIDs = mapper.apply(cell1ColumnID);
            if (cell2ColumnIDs != null && !cell2ColumnIDs.isEmpty()) {
                Integer cell2ColumnID = (Integer) cell2ColumnIDs.iterator().next();
                if (info2.columnPerspective.getVirtualArray().contains(cell2ColumnID)) {
                    int index2 = getContingencyIndex(info2.dataDomain, info2.columnPerspective.getIdType(), cell2ColumnID, info2.rowIDType, info2.rowID, classifier2);
                    if (index2 == -1)
                        continue;
                    contingencyTable[index1][index2]++;
                }
            }
        }
        double[] result = FishersExactTest.fishersExactTest(contingencyTable[0][0], contingencyTable[0][1], contingencyTable[1][0], contingencyTable[1][1]);
        twoSidedPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[0], result[0]));
        leftTailPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[1]));
        rightTailPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[2]));
        visited = true;
        columnHeaderProvider.setClassifier(classifier1);
        rowHeaderProvider.setClassifier(classifier2);
        buildTable(contingencyTableGroup);
        table.refresh();
        getShell().layout(true, true);
        getShell().pack();
        getWizard().getContainer().updateButtons();
    }
}

Output:
         }
-        double[] result = FishersExactTest.fishersExactTest(contingencyTable[0][0], contingencyTable[0][1], contingencyTable[1][0], contingencyTable[1][1]);
-        twoSidedPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[0], result[0]));
+        result = FishersExactTest.fishersExactTest(contingencyTable[0][0], contingencyTable[0][1], contingencyTable[1][0], contingencyTable[1][1]);
+        twoSidedPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[0]));
         leftTailPValueLabel.setText(String.format(Locale.ENGLISH, "String_Node_Str", result[1]));


Input:
private void triggerAfterHostChildRemoved(Component child) {
    List<ShadowElement> shadowRoots = getShadowRoots();
    if (!shadowRoots.isEmpty()) {
        try {
            initIndexCacheMap();
            for (ShadowElement se : getShadowRoots()) {
                if (se instanceof ShadowElementCtrl) {
                    ((ShadowElementCtrl) se).afterHostChildRemoved(child);
                }
            }
        } finally {
            destroyIndexCacheMap();
        }
    }
}

Output:
             initIndexCacheMap();
-            for (ShadowElement se : getShadowRoots()) {
+            for (ShadowElement se : new LinkedList<ShadowElement>(shadowRoots)) {
                 if (se instanceof ShadowElementCtrl) {


Input:
public void actionPerformed(ActionEvent e) {
    downloadTask = new DownloadTask();
    downloadTask.execute();
}

Output:
 public void actionPerformed(ActionEvent e) {
-    downloadTask = new DownloadTask();
-    downloadTask.execute();
+    if (downloadTaskRunning) {
+        downloadTask.cancel(true);
+        status.setText("String_Node_Str");
+        actionButton.setText("String_Node_Str");
+    } else {
+        downloadTask = new DownloadTask();
+        progressBar.setIndeterminate(true);
+        downloadTask.execute();
+        status.setText("String_Node_Str");
+        actionButton.setText("String_Node_Str");
+    }
 }


Input:
protected Data addDataContent(IDataContent data) {
    float height = getContentHeight(data);
    HyperlinkDef url = parseHyperLink(data);
    BookmarkDef bookmark = getBookmark(data);
    Data excelData = null;
    Object generateBy = data.getGenerateBy();
    IStyle style = data.getComputedStyle();
    DataFormatValue dataformat = style.getDataFormat();
    MapDesign map = null;
    if (generateBy instanceof DataItemDesign) {
        DataItemDesign design = (DataItemDesign) generateBy;
        map = design.getMap();
    }
    if (map != null && map.getRuleCount() > 0 && data.getLabelText() != null) {
        excelData = engine.addData(data.getLabelText().trim(), style, url, bookmark, height);
    } else {
        String locale = null;
        int type = ExcelUtil.getType(data.getValue());
        if (type == SheetData.STRING) {
            if (dataformat != null) {
                locale = dataformat.getStringLocale();
            }
            excelData = engine.addData(data.getText(), style, url, bookmark, locale, height);
        } else if (type == Data.NUMBER) {
            if (dataformat != null) {
                locale = dataformat.getNumberLocale();
            }
            excelData = engine.addData(data.getValue(), style, url, bookmark, locale, height);
        } else {
            if (dataformat != null) {
                locale = dataformat.getDateTimeLocale();
            }
            excelData = engine.addDateTime(data, style, url, bookmark, locale, height);
        }
    }
    return excelData;
}

Output:
     if (map != null && map.getRuleCount() > 0 && data.getLabelText() != null) {
-        excelData = engine.addData(data.getLabelText().trim(), style, url, bookmark, height);
+        excelData = engine.addData(data.getText(), style, url, bookmark, height);
     } else {


Input:
private static Object handleMatchingValue(Indicator indicator) {
    Object tempObject;
    PatternMatchingExt patternExt = new PatternMatchingExt();
    if (UDIHelper.isUDI(indicator)) {
        UserDefIndicator udi = (UserDefIndicator) indicator;
        if (udi.getMatchingValueCount() != null) {
            patternExt.setMatchingValueCount(udi.getMatchingValueCount());
        }
        if (udi.getNotMatchingValueCount() != null) {
            patternExt.setNotMatchingValueCount(udi.getNotMatchingValueCount());
        }
    } else {
        patternExt.setMatchingValueCount(((PatternMatchingIndicator) indicator).getMatchingValueCount());
        patternExt.setNotMatchingValueCount(((PatternMatchingIndicator) indicator).getNotMatchingValueCount());
    }
    tempObject = patternExt;
    return tempObject;
}

Output:
     }
-    tempObject = patternExt;
-    return tempObject;
+    return patternExt;
 }


Input:
protected boolean calculateEnabled() {
    slotHandle = getDefaultSlotHandle(insertType);
    return DNDUtil.handleValidateTargetCanContainType(slotHandle, insertType) && DNDUtil.handleValidateTargetCanContainMore(slotHandle, 0);
}

Output:
     slotHandle = getDefaultSlotHandle(insertType);
-    return DNDUtil.handleValidateTargetCanContainType(slotHandle, insertType) && DNDUtil.handleValidateTargetCanContainMore(slotHandle, 0);
+    propertyHandle = getDefaultPropertyHandle(insertType);
+    Object obj = slotHandle;
+    if (obj == null) {
+        obj = model;
+    }
+    return DNDUtil.handleValidateTargetCanContainType(obj, insertType) && DNDUtil.handleValidateTargetCanContainMore(obj, 0);
 }


Input:
protected void paintTag(GL gl, Tag tag, TaggedAxis1D taggedAxis, GlimpseBounds bounds) {
    int height = bounds.getHeight();
    int x = taggedAxis.valueToScreenPixel(tag.getValue());
    int yMin = getTagMinY(height);
    int yMid = getTagPointerMaxY(height);
    int yMax = getTagMaxY(height);
    float[] color = tagColor;
    Object colorValue = tag.getAttribute(Tag.TAG_COLOR_ATTR);
    if (colorValue != null && colorValue instanceof float[]) {
        color = (float[]) colorValue;
    }
    GL3 gl3 = gl.getGL3();
    FloatBuffer xy = tagXyVbo.mapFloats(gl, 18);
    xy.put(x).put(yMin);
    xy.put(x - tagHalfWidth).put(yMid);
    xy.put(x + tagHalfWidth).put(yMid);
    xy.put(x - tagHalfWidth).put(yMax);
    xy.put(x - tagHalfWidth).put(yMid);
    xy.put(x + tagHalfWidth).put(yMid);
    xy.put(x + tagHalfWidth).put(yMid);
    xy.put(x + tagHalfWidth).put(yMax);
    xy.put(x - tagHalfWidth).put(yMax);
    tagXyVbo.seal(gl);
    GLUtils.enableStandardBlending(gl);
    flatColorProg.begin(gl3);
    try {
        flatColorProg.setPixelOrtho(gl3, bounds);
        flatColorProg.setColor(gl3, color[0], color[1], color[2], 0.3f);
        flatColorProg.draw(gl3, GL.GL_TRIANGLES, tagXyVbo, 0, 9);
    } finally {
        flatColorProg.end(gl3);
        gl.glDisable(GL.GL_BLEND);
    }
    tagStyle.rgba = color;
    tagStyle.thickness_PX = tagPointerOutlineWidth;
    pathOutline.clear();
    pathOutline.moveTo(x, yMin);
    pathOutline.lineTo(x + tagHalfWidth, yMid);
    pathOutline.lineTo(x + tagHalfWidth, yMax);
    pathOutline.lineTo(x - tagHalfWidth, yMax);
    pathOutline.lineTo(x - tagHalfWidth, yMid);
    pathOutline.lineTo(x, yMin);
    progOutline.begin(gl3);
    try {
        progOutline.setPixelOrtho(gl3, bounds);
        progOutline.setViewport(gl3, bounds);
        progOutline.draw(gl3, tagStyle, pathOutline);
    } finally {
        progOutline.end(gl3);
    }
}

Output:
     pathOutline.lineTo(x - tagHalfWidth, yMid);
-    pathOutline.lineTo(x, yMin);
+    pathOutline.closeLoop();
     progOutline.begin(gl3);


Input:
public void selectSplitOffset() {
    SplitMergeLineFitLoop alg = new SplitMergeLineFitLoop(0.001, 1, 100);
    alg.contour = new ArrayList<Point2D_I32>();
    for (int i = 0; i < 10; i++) alg.contour.add(new Point2D_I32(i, 0));
    alg.contour.get(4).y = 10;
    alg.N = alg.contour.size();
    alg.line.slope.x = 1;
    int found = alg.selectSplitOffset(0, 9);
    assertEquals(4, found);
    found = alg.selectSplitOffset(0, 5);
    assertEquals(4, found);
    found = alg.selectSplitOffset(0, 4);
    assertEquals(-1, found);
    found = alg.selectSplitOffset(0, 3);
    assertEquals(-1, found);
    found = alg.selectSplitOffset(3, 5);
    assertEquals(1, found);
    found = alg.selectSplitOffset(5, 6);
    assertEquals(-1, found);
    found = alg.selectSplitOffset(5, 8);
    assertEquals(-1, found);
    found = alg.selectSplitOffset(5, 10);
    assertEquals(9, found);
    found = alg.selectSplitOffset(9, 8);
    assertEquals(5, found);
    fail("String_Node_Str");
}

Output:
 public void selectSplitOffset() {
-    SplitMergeLineFitLoop alg = new SplitMergeLineFitLoop(0.001, 1, 100);
+    SplitMergeLineFitLoop alg = new SplitMergeLineFitLoop(0.001, MINIMUM_SPLIT_FRACTION, 100);
     alg.contour = new ArrayList<Point2D_I32>();


Input:
protected void onImpact(MovingObjectPosition mop) {
    if (!this.worldObj.isRemote && this.shootingEntity != null && this.shootingEntity instanceof EntityPlayer) {
        if (alredyHit) {
            return;
        } else {
            alredyHit = true;
        }
        EntityPlayer ep = (EntityPlayer) this.shootingEntity;
        int next = (ep.inventory.currentItem + 1) % 10;
        ItemStack toUse = ep.inventory.getStackInSlot(next);
        if (toUse != null && toUse.getItem() instanceof IWireCoil) {
            if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
                if (toUse.getItem().onItemUseFirst(toUse, ep, this.worldObj, mop.blockX, mop.blockY, mop.blockZ, mop.sideHit, (float) mop.hitVec.xCoord % 1, (float) mop.hitVec.yCoord % 1, (float) mop.hitVec.zCoord % 1)) {
                    this.worldObj.playSoundAtEntity(ep, "String_Node_Str", .8F, 1.2F / (this.rand.nextFloat() * .2F + .9F));
                }
            }
        }
        if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.ENTITY) {
            mop.entityHit.attackEntityFrom(IEDamageSources.causeCasullDamage(this, shootingEntity), .5F);
        }
    }
}

Output:
         if (toUse != null && toUse.getItem() instanceof IWireCoil) {
-            if (mop.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
-                if (toUse.getItem().onItemUseFirst(toUse, ep, this.worldObj, mop.blockX, mop.blockY, mop.blockZ, mop.sideHit, (float) mop.hitVec.xCoord % 1, (float) mop.hitVec.yCoord % 1, (float) mop.hitVec.zCoord % 1)) {
+            if (mop.typeOfHit == RayTraceResult.Type.BLOCK) {
+                if (toUse.getItem().onItemUseFirst(toUse, ep, this.worldObj, mop.getBlockPos(), mop.sideHit, (float) mop.hitVec.xCoord % 1, (float) mop.hitVec.yCoord % 1, (float) mop.hitVec.zCoord % 1)) {
                     this.worldObj.playSoundAtEntity(ep, "String_Node_Str", .8F, 1.2F / (this.rand.nextFloat() * .2F + .9F));


Input:
public void executeWork(int command) throws Exception {
    if (command == COMMAND_UNKNOWN)
        return;
    if (commandArgs.size() != COMMAND_ARGS[command])
        consolePropertyMessage("String_Node_Str", COMMANDS[command]);
    int min;
    int max;
    switch(command) {
        case COMMAND_START:
            shutdownDatabasesOnShutdown = true;
            blockingStart(makePrintWriter(System.out));
            break;
        case COMMAND_SHUTDOWN:
            shutdown();
            consolePropertyMessage("String_Node_Str", new String[] { att_srvclsnm, versionString });
            break;
        case COMMAND_TRACE:
            {
                boolean on = isOn((String) commandArgs.get(0));
                trace(sessionArg, on);
                consoleTraceMessage(sessionArg, on);
                break;
            }
        case COMMAND_TRACEDIRECTORY:
            String directory = (String) commandArgs.get(0);
            sendSetTraceDirectory(directory);
            consolePropertyMessage("String_Node_Str", directory);
            break;
        case COMMAND_TESTCONNECTION:
            ping();
            consolePropertyMessage("String_Node_Str", new String[] { hostArg, Integer.toString(portNumber) });
            break;
        case COMMAND_LOGCONNECTIONS:
            {
                boolean on = isOn((String) commandArgs.get(0));
                logConnections(on);
                consolePropertyMessage("String_Node_Str", on ? "String_Node_Str" : "String_Node_Str");
                break;
            }
        case COMMAND_SYSINFO:
            {
                String info = sysinfo();
                consoleMessage(info, false);
                break;
            }
        case COMMAND_MAXTHREADS:
            max = 0;
            try {
                max = Integer.parseInt((String) commandArgs.get(0));
            } catch (NumberFormatException e) {
                consolePropertyMessage("String_Node_Str", new String[] { (String) commandArgs.get(0), "String_Node_Str" });
            }
            if (max < MIN_MAXTHREADS)
                consolePropertyMessage("String_Node_Str", new String[] { Integer.toString(max), "String_Node_Str" });
            netSetMaxThreads(max);
            break;
        case COMMAND_RUNTIME_INFO:
            String reply = runtimeInfo();
            consoleMessage(reply, false);
            break;
        case COMMAND_TIMESLICE:
            int timeslice = 0;
            String timeSliceArg = (String) commandArgs.get(0);
            try {
                timeslice = Integer.parseInt(timeSliceArg);
            } catch (NumberFormatException e) {
                consolePropertyMessage("String_Node_Str", new String[] { (String) commandArgs.get(0), "String_Node_Str" });
            }
            if (timeslice < MIN_TIMESLICE)
                consolePropertyMessage("String_Node_Str", new String[] { Integer.toString(timeslice), "String_Node_Str" });
            netSetTimeSlice(timeslice);
            break;
        default:
            if (SanityManager.DEBUG)
                SanityManager.THROWASSERT("String_Node_Str" + command);
    }
}

Output:
                 logConnections(on);
-                consolePropertyMessage("String_Node_Str", on ? "String_Node_Str" : "String_Node_Str");
+                logConnectionsChange(on);
                 break;


Input:
public void widgetSelected(final SelectionEvent arg0) {
    if (comboMetric.getSelectionIndex() != -1) {
        selectMetricAction(METRICS.get(comboMetric.getSelectionIndex()));
    }
}

Output:
     if (comboMetric.getSelectionIndex() != -1) {
-        selectMetricAction(METRICS.get(comboMetric.getSelectionIndex()));
+        MetricDescription metric = METRICS.get(comboMetric.getSelectionIndex());
+        if (metric != null && model != null) {
+            model.setMetricDescription(metric);
+            controller.update(new ModelEvent(this, ModelPart.METRIC, model.getMetricDescription()));
+            updateControls();
+        }
     }


Input:
public JadeNode extractDraftSubtreeForTipNodes(Iterable<Node> tips) {
    Map<Node, ArrayList<Node>> treeTipRootPathMap = getTreeTipRootPathMap(tips);
    HashMap<Node, JadeNode> graphNodeTreeNodeMap = new HashMap<Node, JadeNode>();
    HashMap<JadeNode, Node> treeNodeGraphNodeMap = new HashMap<JadeNode, Node>();
    HashMap<JadeNode, LinkedList<Node>> treeTipGraphMRCADescendantsMap = new HashMap<JadeNode, LinkedList<Node>>();
    for (Node tipNode : treeTipRootPathMap.keySet()) {
        JadeNode treeTip = new JadeNode();
        treeTip.assocObject("String_Node_Str", tipNode);
        treeTip.setName((String) tipNode.getProperty("String_Node_Str"));
        graphNodeTreeNodeMap.put(tipNode, treeTip);
        treeNodeGraphNodeMap.put(treeTip, tipNode);
        LinkedList<Node> tipDescendants = new LinkedList<Node>();
        for (long nid : (long[]) tipNode.getProperty("String_Node_Str")) {
            tipDescendants.add(graphDb.getNodeById(nid));
        }
        treeTipGraphMRCADescendantsMap.put(treeTip, tipDescendants);
    }
    HashMap<JadeNode, LinkedList<JadeNode>> treeNodeTreeTipDescendantsMap = new HashMap<JadeNode, LinkedList<JadeNode>>();
    LinkedList<JadeNode> stack = new LinkedList<JadeNode>();
    JadeNode root = new JadeNode();
    stack.add(root);
    treeNodeTreeTipDescendantsMap.put(root, new LinkedList<JadeNode>(graphNodeTreeNodeMap.values()));
    while (stack.size() > 0) {
        System.out.println(stack.size() + "String_Node_Str");
        JadeNode treeNode = stack.remove(0);
        LinkedList<Node> allDescendantGraphTips = new LinkedList<Node>();
        for (JadeNode treeTip : treeNodeTreeTipDescendantsMap.get(treeNode)) {
            System.out.println(treeTip.getName());
            allDescendantGraphTips.addAll(treeTipGraphMRCADescendantsMap.get(treeTip));
        }
        Node graphNode = LicaUtil.getDraftTreeLICA(allDescendantGraphTips);
        treeNode.assocObject("String_Node_Str", graphNode);
        if (graphNode.hasProperty("String_Node_Str")) {
            treeNode.setName((String) graphNode.getProperty("String_Node_Str"));
        }
        System.out.println("String_Node_Str" + treeNode.getName());
        HashMap<Node, LinkedList<JadeNode>> childNodeTreeTipDescendantsMap = new HashMap<Node, LinkedList<JadeNode>>();
        for (JadeNode curDescendantTreeNode : treeNodeTreeTipDescendantsMap.get(treeNode)) {
            System.out.println("String_Node_Str" + curDescendantTreeNode.getName());
            Node curDescendantGraphNode = treeNodeGraphNodeMap.get(curDescendantTreeNode);
            Node curDeepestAncestor = null;
            if (treeTipRootPathMap.get(curDescendantGraphNode).size() > 0) {
                curDeepestAncestor = treeTipRootPathMap.get(curDescendantGraphNode).remove(0);
            } else {
                curDeepestAncestor = (Node) treeNode.getObject("String_Node_Str");
            }
            if (curDeepestAncestor.hasProperty("String_Node_Str")) {
                System.out.println("String_Node_Str" + curDeepestAncestor.getProperty("String_Node_Str"));
            }
            if (!childNodeTreeTipDescendantsMap.containsKey(curDeepestAncestor)) {
                childNodeTreeTipDescendantsMap.put(curDeepestAncestor, new LinkedList<JadeNode>());
            }
            childNodeTreeTipDescendantsMap.get(curDeepestAncestor).add(curDescendantTreeNode);
        }
        for (Entry<Node, LinkedList<JadeNode>> childToAdd : childNodeTreeTipDescendantsMap.entrySet()) {
            LinkedList<JadeNode> childTreeTipDescendants = childToAdd.getValue();
            if (childTreeTipDescendants.size() == 1) {
                treeNode.addChild(childTreeTipDescendants.get(0));
                continue;
            }
            Node childGraphNode = childToAdd.getKey();
            JadeNode childTreeNode = new JadeNode();
            childTreeNode.assocObject("String_Node_Str", childGraphNode);
            if (childGraphNode.hasProperty("String_Node_Str")) {
                childTreeNode.setName((String) childGraphNode.getProperty("String_Node_Str"));
            }
            if (childTreeTipDescendants.size() == 2) {
                for (JadeNode treeTip : childTreeTipDescendants) {
                    childTreeNode.addChild(treeTip);
                }
            } else {
                System.out.println(treeNode.getName() + "String_Node_Str");
                ArrayList<Node> startNodeAncestors = treeTipRootPathMap.get(childTreeTipDescendants.get(0));
                Node startShallowestAncestor = null;
                if (startNodeAncestors.size() > 0) {
                    startShallowestAncestor = startNodeAncestors.get(startNodeAncestors.size() - 1);
                }
                boolean isPolytomy = true;
                for (JadeNode treeTip : childTreeTipDescendants) {
                    ArrayList<Node> curAncestors = treeTipRootPathMap.get(treeTip);
                    Node curShallowestAncestor = curAncestors.get(curAncestors.size() - 1);
                    if (!startShallowestAncestor.equals(curShallowestAncestor)) {
                        stack.add(0, childTreeNode);
                        treeNodeTreeTipDescendantsMap.put(childTreeNode, childTreeTipDescendants);
                        isPolytomy = false;
                        break;
                    }
                }
                if (isPolytomy) {
                    for (JadeNode treeTip : childTreeTipDescendants) {
                        childTreeNode.addChild(treeTip);
                    }
                }
            }
            treeNode.addChild(childTreeNode);
        }
    }
    return root;
}

Output:
         }
-        Node graphNode = LicaUtil.getDraftTreeLICA(allDescendantGraphTips);
+        Node graphNode = getDraftTreeMRCAForNodes(allDescendantGraphTips);
         treeNode.assocObject("String_Node_Str", graphNode);


Input:
public Map<String, List<String>> getServiceProviders() {
    Map<String, List<String>> serviceProviderMap = null;
    if (serviceProviderList != null && !serviceProviderList.isEmpty()) {
        serviceProviderMap = new HashMap<String, List<String>>();
        Collection servicesCollection = serviceProviderList.values();
        Iterator iter = servicesCollection.iterator();
        while (iter.hasNext()) {
            HashMap<String, String> services = (HashMap<String, String>) iter.next();
            String service = services.get("String_Node_Str");
            String provider = services.get("String_Node_Str");
            List<String> providerList = null;
            if (serviceProviderMap.containsKey(service)) {
                providerList = serviceProviderMap.get(service);
            } else {
                providerList = new ArrayList<String>();
            }
            providerList.add(provider);
            serviceProviderMap.put(service, providerList);
        }
    }
    return serviceProviderMap;
}

Output:
         serviceProviderMap = new HashMap<String, List<String>>();
-        Collection servicesCollection = serviceProviderList.values();
-        Iterator iter = servicesCollection.iterator();
+        Collection<? extends Map<String, String>> servicesCollection = serviceProviderList.values();
+        Iterator<? extends Map<String, String>> iter = servicesCollection.iterator();
         while (iter.hasNext()) {


Input:
private void computeImageMatrix() {
    final int viewWidth = getWidth() - getPaddingLeft() - getPaddingRight();
    final int viewHeight = getHeight() - getPaddingTop() - getPaddingBottom();
    if (cropType != CropType.NONE && viewHeight > 0 && viewWidth > 0) {
        final Matrix matrix = getImageMatrix();
        int drawableWidth = getDrawable().getIntrinsicWidth();
        int drawableHeight = getDrawable().getIntrinsicHeight();
        final float scaleY = (float) viewHeight / (float) drawableHeight;
        final float scaleX = (float) viewWidth / (float) drawableWidth;
        final float scale = scaleX > scaleY ? scaleX : scaleY;
        matrix.setScale(scale, scale);
        final boolean verticalImageMode = scaleX > scaleY;
        final float postDrawableWidth = drawableWidth * scale;
        final float xTranslation = getXTranslation(cropType, viewWidth, postDrawableWidth, verticalImageMode);
        final float postDrawabeHeigth = drawableHeight * scale;
        final float yTranslation = getYTranslation(cropType, viewHeight, postDrawabeHeigth, verticalImageMode);
        matrix.postTranslate(xTranslation, yTranslation);
        setImageMatrix(matrix);
    }
}

Output:
         final Matrix matrix = getImageMatrix();
-        int drawableWidth = getDrawable().getIntrinsicWidth();
-        int drawableHeight = getDrawable().getIntrinsicHeight();
+        int drawableWidth = drawable.getIntrinsicWidth();
+        int drawableHeight = drawable.getIntrinsicHeight();
         final float scaleY = (float) viewHeight / (float) drawableHeight;


Input:
public String getAttribute(Attribute attribute) {
    if (attribute == null)
        return "String_Node_Str";
    if (player_name == null)
        return Element.NULL.getAttribute(attribute);
    if (attribute.startsWith("String_Node_Str")) {
        dB.log(debug());
        return new Element(Boolean.TRUE.toString()).getAttribute(attribute.fulfill(2));
    }
    if (attribute.startsWith("String_Node_Str")) {
        return new Element(ChatColor.stripColor(debug())).getAttribute(attribute.fulfill(2));
    }
    if (attribute.startsWith("String_Node_Str")) {
        return new Element(debug()).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str"))
        return new Element(prefix).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new dList(PlayerTags.playerChatHistory.get(player_name)).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str")) {
        int x = 1;
        if (attribute.hasContext(1) && aH.matchesInteger(attribute.getContext(1)))
            x = attribute.getIntContext(1);
        if (!PlayerTags.playerChatHistory.containsKey(player_name))
            return Element.NULL.getAttribute(attribute.fulfill(1));
        else
            return new Element(PlayerTags.playerChatHistory.get(player_name).get(x - 1)).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str")) {
        String flag_name;
        if (attribute.hasContext(1))
            flag_name = attribute.getContext(1);
        else
            return Element.NULL.getAttribute(attribute.fulfill(1));
        attribute.fulfill(1);
        if (attribute.startsWith("String_Node_Str") || attribute.startsWith("String_Node_Str"))
            return new Element(!FlagManager.playerHasFlag(this, flag_name)).getAttribute(attribute.fulfill(1));
        if (attribute.startsWith("String_Node_Str") && !FlagManager.playerHasFlag(this, flag_name))
            return new Element(0).getAttribute(attribute.fulfill(1));
        if (FlagManager.playerHasFlag(this, flag_name))
            return new dList(DenizenAPI.getCurrentInstance().flagManager().getPlayerFlag(getName(), flag_name)).getAttribute(attribute);
        else
            return Element.NULL.getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str")) {
        String flag_name;
        if (attribute.hasContext(1))
            flag_name = attribute.getContext(1);
        else
            return Element.NULL.getAttribute(attribute.fulfill(1));
        return new Element(FlagManager.playerHasFlag(this, flag_name)).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str")) {
        String outcome = "String_Node_Str";
        if (attribute.hasContext(1)) {
            try {
                outcome = DenizenAPI.getCurrentInstance().getSaves().getString("String_Node_Str" + getName() + "String_Node_Str" + dScript.valueOf(attribute.getContext(1)).getName() + "String_Node_Str");
            } catch (Exception e) {
                outcome = "String_Node_Str";
            }
        }
        return new Element(outcome).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str")) {
        if (Depends.economy != null) {
            if (attribute.startsWith("String_Node_Str"))
                return new Element(Depends.economy.currencyNameSingular()).getAttribute(attribute.fulfill(2));
            if (attribute.startsWith("String_Node_Str"))
                return new Element(Depends.economy.currencyNamePlural()).getAttribute(attribute.fulfill(2));
            return new Element(Depends.economy.getBalance(player_name)).getAttribute(attribute.fulfill(1));
        } else {
            dB.echoError("String_Node_Str");
            return Element.NULL.getAttribute(attribute.fulfill(1));
        }
    }
    if (attribute.startsWith("String_Node_Str")) {
        List<String> players = new ArrayList<String>();
        if (attribute.startsWith("String_Node_Str")) {
            for (Player player : Bukkit.getOnlinePlayers()) players.add(player.getName());
            return new dList(players).getAttribute(attribute.fulfill(2));
        } else if (attribute.startsWith("String_Node_Str")) {
            for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
                if (!Bukkit.getOnlinePlayers().toString().contains(player.getName()))
                    players.add(player.getName());
            }
            return new dList(players).getAttribute(attribute.fulfill(2));
        } else {
            for (OfflinePlayer player : Bukkit.getOfflinePlayers()) players.add(player.getName());
            return new dList(players).getAttribute(attribute.fulfill(1));
        }
    }
    if (attribute.startsWith("String_Node_Str") && !isOnline())
        return new Element(player_name).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new dLocation(getOfflinePlayer().getBedSpawnLocation()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getOfflinePlayer().getFirstPlayed()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(true).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isHealthScaled()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getHealthScale()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getOfflinePlayer().isBanned()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(isOnline()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getOfflinePlayer().isOp()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getOfflinePlayer().isWhitelisted()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getOfflinePlayer().getLastPlayed()).getAttribute(attribute.fulfill(1));
    if (!isOnline())
        return new Element(identify()).getAttribute(attribute);
    if (attribute.startsWith("String_Node_Str")) {
        if (getPlayerEntity().hasMetadata("String_Node_Str"))
            return getSelectedNPC().getAttribute(attribute.fulfill(1));
        else
            return Element.NULL.getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str") && !attribute.startsWith("String_Node_Str"))
        return new dEntity(getPlayerEntity()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str") || attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getAddress().getHostName()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getDisplayName()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getPlayerListName()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(player_name).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new dInventory(getPlayerEntity().getInventory()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new dItem(getPlayerEntity().getItemOnCursor()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str") || attribute.startsWith("String_Node_Str")) {
        if (Depends.permissions == null) {
            dB.echoError("String_Node_Str");
            return null;
        }
        String permission = attribute.getContext(1);
        if (attribute.getAttribute(2).startsWith("String_Node_Str"))
            return new Element(Depends.permissions.has((World) null, player_name, permission)).getAttribute(attribute.fulfill(2));
        else if (attribute.getAttribute(2).startsWith("String_Node_Str"))
            return new Element(Depends.permissions.has(attribute.getContext(2), player_name, permission)).getAttribute(attribute.fulfill(2));
        return new Element(Depends.permissions.has(getPlayerEntity(), permission)).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str") || attribute.startsWith("String_Node_Str")) {
        if (Depends.permissions == null) {
            dB.echoError("String_Node_Str");
            return Element.NULL.getAttribute(attribute.fulfill(1));
        }
        String group = attribute.getContext(1);
        if (attribute.getAttribute(2).startsWith("String_Node_Str"))
            return new Element(Depends.permissions.playerInGroup((World) null, player_name, group)).getAttribute(attribute.fulfill(2));
        else if (attribute.getAttribute(2).startsWith("String_Node_Str"))
            return new Element(Depends.permissions.playerInGroup(attribute.getContext(2), player_name, group)).getAttribute(attribute.fulfill(2));
        return new Element(Depends.permissions.playerInGroup(getPlayerEntity(), group)).getAttribute(attribute.fulfill(1));
    }
    if (attribute.startsWith("String_Node_Str"))
        return new dLocation(getPlayerEntity().getCompassTarget()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getAllowFlight()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getFlySpeed()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str")) {
        double maxHunger = getPlayerEntity().getMaxHealth();
        if (attribute.hasContext(2))
            maxHunger = attribute.getIntContext(2);
        if (getPlayerEntity().getFoodLevel() / maxHunger < .10)
            return new Element("String_Node_Str").getAttribute(attribute.fulfill(2));
        else if (getPlayerEntity().getFoodLevel() / maxHunger < .40)
            return new Element("String_Node_Str").getAttribute(attribute.fulfill(2));
        else if (getPlayerEntity().getFoodLevel() / maxHunger < .75)
            return new Element("String_Node_Str").getAttribute(attribute.fulfill(2));
        else if (getPlayerEntity().getFoodLevel() / maxHunger < 1)
            return new Element("String_Node_Str").getAttribute(attribute.fulfill(2));
        else
            return new Element("String_Node_Str").getAttribute(attribute.fulfill(2));
    }
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getSaturation()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getFoodLevel()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getMaximumAir()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getRemainingAir()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getGameMode().getValue()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getGameMode().name()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isBlocking()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isFlying()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isSleeping()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isSneaking()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().isSprinting()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Duration(getPlayerEntity().getSleepTicks() / 20).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getPlayerTime()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getWalkSpeed()).getAttribute(attribute.fulfill(1));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getPlayerWeather().name()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getLevel()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getExpToLevel()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getTotalExperience()).getAttribute(attribute.fulfill(2));
    if (attribute.startsWith("String_Node_Str"))
        return new Element(getPlayerEntity().getExp() * 100).getAttribute(attribute.fulfill(1));
    return new dEntity(getPlayerEntity()).getAttribute(attribute);
}

Output:
         else
-            return Element.NULL.getAttribute(attribute.fulfill(1));
+            return Element.NULL.getAttribute(attribute);
     }


Input:
private void saveProvider(PushProvider provider) {
    mAppContext.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE).edit().putString(KEY_LAST_PROVIDER_NAME, provider.getName()).apply();
}

Output:
 private void saveProvider(PushProvider provider) {
-    mAppContext.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE).edit().putString(KEY_LAST_PROVIDER_NAME, provider.getName()).apply();
+    if (provider == null) {
+        mAppContext.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE).edit().remove(KEY_LAST_PROVIDER_NAME).apply();
+    } else {
+        mAppContext.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE).edit().putString(KEY_LAST_PROVIDER_NAME, provider.getName()).apply();
+    }
 }


Input:
public void listChanged(ListEvent<E> listChanges) {
    final Barcode toDoList = new Barcode();
    toDoList.addWhite(0, barcode.size());
    final LinkedList removedValues = new LinkedList();
    while (listChanges.next()) {
        final int changeIndex = listChanges.getIndex();
        final int changeType = listChanges.getType();
        if (changeType == ListEvent.INSERT) {
            barcode.add(changeIndex, UNIQUE, 1);
            toDoList.add(changeIndex, TODO, 1);
        } else if (changeType == ListEvent.UPDATE) {
            if (barcode.get(changeIndex) == UNIQUE) {
                if (changeIndex + 1 < barcode.size() && barcode.get(changeIndex + 1) == DUPLICATE) {
                    barcode.set(changeIndex, UNIQUE, 2);
                    toDoList.set(changeIndex, TODO, 1);
                }
            }
        } else if (changeType == ListEvent.DELETE) {
            Object deleted = barcode.get(changeIndex);
            barcode.remove(changeIndex, 1);
            toDoList.remove(changeIndex, 1);
            if (deleted == UNIQUE) {
                if (changeIndex < barcode.size() && barcode.get(changeIndex) == DUPLICATE) {
                    barcode.set(changeIndex, UNIQUE, 1);
                    deleted = UNIQUE_WITH_DUPLICATE;
                }
            }
            removedValues.addLast(deleted);
        }
    }
    TryJoinResult<E> tryJoinResult = new TryJoinResult<E>();
    listChanges.reset();
    while (listChanges.next()) {
        final int changeIndex = listChanges.getIndex();
        final int changeType = listChanges.getType();
        E newValue = listChanges.getNewValue();
        E oldValue = listChanges.getOldValue();
        if (changeType == ListEvent.INSERT) {
            tryJoinExistingGroup(changeIndex, toDoList, tryJoinResult);
            if (tryJoinResult.group == NO_GROUP) {
                client.groupChanged(changeIndex, tryJoinResult.groupIndex, ListEvent.INSERT, true, changeType, ListEvent.<E>unknownValue(), tryJoinResult.newFirstInGroup);
            } else {
                client.groupChanged(changeIndex, tryJoinResult.groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
            }
        } else if (changeType == ListEvent.UPDATE) {
            int oldGroup = 0;
            if (toDoList.get(changeIndex) == TODO)
                oldGroup = RIGHT_GROUP;
            else if (barcode.get(changeIndex) == DUPLICATE)
                oldGroup = LEFT_GROUP;
            else if (barcode.get(changeIndex) == UNIQUE)
                oldGroup = NO_GROUP;
            tryJoinExistingGroup(changeIndex, toDoList, tryJoinResult);
            int groupIndex = tryJoinResult.groupIndex;
            if (tryJoinResult.group == NO_GROUP) {
                if (oldGroup == NO_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, oldValue, tryJoinResult.newFirstInGroup);
                } else if (oldGroup == LEFT_GROUP) {
                    E firstFromPreviousGroup = sortedList.get(barcode.getIndex(groupIndex - 1, UNIQUE));
                    client.groupChanged(changeIndex, groupIndex - 1, ListEvent.UPDATE, false, changeType, firstFromPreviousGroup, firstFromPreviousGroup);
                    client.groupChanged(changeIndex, groupIndex, ListEvent.INSERT, true, changeType, ListEvent.<E>unknownValue(), tryJoinResult.newFirstInGroup);
                } else if (oldGroup == RIGHT_GROUP) {
                    E firstFromNextGroup = sortedList.get(barcode.getIndex(groupIndex + 1, UNIQUE));
                    client.groupChanged(changeIndex, groupIndex, ListEvent.INSERT, true, changeType, ListEvent.<E>unknownValue(), tryJoinResult.newFirstInGroup);
                    client.groupChanged(changeIndex, groupIndex + 1, ListEvent.UPDATE, false, changeType, oldValue, firstFromNextGroup);
                }
            } else if (tryJoinResult.group == LEFT_GROUP) {
                if (oldGroup == NO_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                    client.groupChanged(changeIndex, groupIndex + 1, ListEvent.DELETE, false, changeType, oldValue, ListEvent.<E>unknownValue());
                } else if (oldGroup == LEFT_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                } else if (oldGroup == RIGHT_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                    if (groupIndex + 1 < barcode.blackSize()) {
                        E firstFromNextGroup = sortedList.get(barcode.getIndex(groupIndex + 1, UNIQUE));
                        client.groupChanged(changeIndex, groupIndex + 1, ListEvent.UPDATE, false, changeType, oldValue, firstFromNextGroup);
                    }
                }
            } else if (tryJoinResult.group == RIGHT_GROUP) {
                if (oldGroup == NO_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.DELETE, false, changeType, oldValue, ListEvent.<E>unknownValue());
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                } else if (oldGroup == LEFT_GROUP) {
                    if (groupIndex - 1 >= 0) {
                        E firstFromPreviousGroup = sortedList.get(barcode.getIndex(groupIndex - 1, UNIQUE));
                        client.groupChanged(changeIndex, groupIndex - 1, ListEvent.UPDATE, false, changeType, firstFromPreviousGroup, firstFromPreviousGroup);
                    }
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                } else if (oldGroup == RIGHT_GROUP) {
                    client.groupChanged(changeIndex, groupIndex, ListEvent.UPDATE, true, changeType, tryJoinResult.oldFirstInGroup, tryJoinResult.newFirstInGroup);
                }
            }
        } else if (changeType == ListEvent.DELETE) {
            final Object deleted = removedValues.removeFirst();
            final int sourceDeletedIndex = deleted == DUPLICATE ? changeIndex - 1 : changeIndex;
            final int groupDeletedIndex = sourceDeletedIndex < barcode.size() ? barcode.getBlackIndex(sourceDeletedIndex, true) : barcode.blackSize();
            if (deleted == UNIQUE) {
                client.groupChanged(changeIndex, groupDeletedIndex, ListEvent.DELETE, true, changeType, oldValue, ListEvent.<E>unknownValue());
            } else {
                E oldValueInGroup;
                E newValueInGroup;
                if (groupDeletedIndex < barcode.blackSize()) {
                    int firstInGroupIndex = barcode.getIndex(groupDeletedIndex, UNIQUE);
                    newValueInGroup = sortedList.get(firstInGroupIndex);
                } else {
                    newValueInGroup = ListEvent.<E>unknownValue();
                }
                if (deleted == UNIQUE_WITH_DUPLICATE) {
                    oldValueInGroup = oldValue;
                } else {
                    oldValueInGroup = newValueInGroup;
                }
                client.groupChanged(changeIndex, groupDeletedIndex, ListEvent.UPDATE, true, changeType, oldValueInGroup, newValueInGroup);
            }
        }
    }
}

Output:
                 if (changeIndex + 1 < barcode.size() && barcode.get(changeIndex + 1) == DUPLICATE) {
-                    barcode.set(changeIndex, UNIQUE, 2);
-                    toDoList.set(changeIndex, TODO, 1);
+                    if (changeIndex != lastFakedUniqueChangeIndex) {
+                        barcode.set(changeIndex, UNIQUE, 2);
+                        toDoList.set(changeIndex, TODO, 1);
+                        lastFakedUniqueChangeIndex = changeIndex + 1;
+                    }
                 }


Input:
private void refreshDataSets() {
    String selectedDataSetName = dataSetChooser.getText();
    String[] oldList = dataSetChooser.getItems();
    List dataSetList = new ArrayList();
    for (Iterator iterator = inputParameter.getModuleHandle().getVisibleDataSets().iterator(); iterator.hasNext(); ) {
        DataSetHandle DataSetHandle = (DataSetHandle) iterator.next();
        dataSetList.add(DataSetHandle.getQualifiedName());
    }
    if (!dataSetList.contains(inputParameter.getDataSetName())) {
        dataSetList.add(0, inputParameter.getDataSetName());
    }
    if (oldList.length != dataSetList.size()) {
        dataSetChooser.setItems((String[]) dataSetList.toArray(new String[] {}));
        if (StringUtil.isBlank(selectedDataSetName)) {
            dataSetChooser.select(0);
            refreshColumns(false);
        } else {
            dataSetChooser.setText(selectedDataSetName);
        }
    }
}

Output:
     }
-    if (!dataSetList.contains(inputParameter.getDataSetName())) {
+    if (inputParameter.getDataSetName() != null && !dataSetList.contains(inputParameter.getDataSetName())) {
         dataSetList.add(0, inputParameter.getDataSetName());


Input:
public void _case(MethodMember x) {
    if (hasTestModifier(x.methodDecl.modifiers)) {
        methodNames.add(x.methodDecl.name.value);
    }
}

Output:
     if (hasTestModifier(x.methodDecl.modifiers)) {
-        methodNames.add(x.methodDecl.name.value);
+        RealLoc realLoc = (RealLoc) x.methodDecl.name.loc;
+        ApexCodeLocation loc = new ApexCodeLocation(file, realLoc.line, realLoc.column);
+        testMethods.put(x.methodDecl.name.value, loc);
     }


Input:
public void runAndRenderReport(IViewerReportDesignHandle design, String outputDocName, InputOptions options, Map parameters, OutputStream out, List activeIds) throws ReportServiceException {
    String reportDesignName = design.getFileName();
    HttpServletRequest request = (HttpServletRequest) options.getOption(InputOptions.OPT_REQUEST);
    Locale locale = (Locale) options.getOption(InputOptions.OPT_LOCALE);
    Boolean isMasterPageContent = (Boolean) options.getOption(InputOptions.OPT_IS_MASTER_PAGE_CONTENT);
    Boolean svgFlag = (Boolean) options.getOption(InputOptions.OPT_IS_MASTER_PAGE_CONTENT);
    String format = (String) options.getOption(InputOptions.OPT_RENDER_FORMAT);
    Boolean isRtl = (Boolean) options.getOption(InputOptions.OPT_RTL);
    try {
        IReportRunnable runnable = ReportEngineService.getInstance().openReportDesign(reportDesignName);
        Map parsedParams = getParsedParameters(design, options, parameters);
        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parsedParams, isMasterPageContent.booleanValue(), svgFlag.booleanValue());
    } catch (RemoteException e) {
        throw new ReportServiceException(e.getLocalizedMessage());
    } catch (EngineException e) {
        throw new ReportServiceException(e.getLocalizedMessage());
    }
}

Output:
     try {
-        IReportRunnable runnable = ReportEngineService.getInstance().openReportDesign(reportDesignName);
-        Map parsedParams = getParsedParameters(design, options, parameters);
-        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parsedParams, isMasterPageContent.booleanValue(), svgFlag.booleanValue());
+        IReportRunnable runnable = (IReportRunnable) design.getDesignObject();
+        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parameters, isMasterPageContent.booleanValue(), svgFlag.booleanValue());
     } catch (RemoteException e) {


Input:
public void processTriple(TripleString triple, long pos) {
    this.insert(triple.getSubject(), triple.getPredicate(), triple.getObject());
}

Output:
 public void processTriple(TripleString triple, long pos) {
-    this.insert(triple.getSubject(), triple.getPredicate(), triple.getObject());
+    triples.add(new TripleString(triple));
 }


Input:
protected State getNAThingProperty(String channelId) {
    if (device != null) {
        NADashboardData dashboardData = device.getDashboardData();
        switch(channelId) {
            case CHANNEL_CO2:
                return toDecimalType(dashboardData.getCO2());
            case CHANNEL_TEMPERATURE:
                return toDecimalType(dashboardData.getTemperature());
            case CHANNEL_MIN_TEMP:
                return toDecimalType(dashboardData.getMinTemp());
            case CHANNEL_MAX_TEMP:
                return toDecimalType(dashboardData.getMaxTemp());
            case CHANNEL_TEMP_TREND:
                return toStringType(dashboardData.getTempTrend());
            case CHANNEL_NOISE:
                return toDecimalType(dashboardData.getNoise());
            case CHANNEL_PRESSURE:
                return toDecimalType(dashboardData.getPressure());
            case CHANNEL_PRESS_TREND:
                return toStringType(dashboardData.getPressureTrend());
            case CHANNEL_ABSOLUTE_PRESSURE:
                return toDecimalType(dashboardData.getAbsolutePressure());
            case CHANNEL_TIMEUTC:
                return toDateTimeType(dashboardData.getTimeUtc());
            case CHANNEL_DATE_MIN_TEMP:
                return toDateTimeType(dashboardData.getDateMinTemp());
            case CHANNEL_DATE_MAX_TEMP:
                return toDateTimeType(dashboardData.getDateMaxTemp());
            case CHANNEL_HUMIDITY:
                return toDecimalType(dashboardData.getHumidity());
            case CHANNEL_HUMIDEX:
                return toDecimalType(WeatherUtils.getHumidex(dashboardData.getTemperature(), dashboardData.getHumidity()));
            case CHANNEL_HEATINDEX:
                return toDecimalType(WeatherUtils.getHeatIndex(dashboardData.getTemperature(), dashboardData.getHumidity()));
            case CHANNEL_DEWPOINT:
                return toDecimalType(WeatherUtils.getDewPoint(dashboardData.getTemperature(), dashboardData.getHumidity()));
            case CHANNEL_DEWPOINTDEP:
                Double dewpoint = WeatherUtils.getDewPoint(dashboardData.getTemperature(), dashboardData.getHumidity());
                return toDecimalType(WeatherUtils.getDewPointDep(dashboardData.getTemperature(), dewpoint));
            case CHANNEL_WIND_UNIT:
                return userAdministrative != null ? new DecimalType(userAdministrative.getWindunit()) : UnDefType.UNDEF;
            case CHANNEL_PRESSURE_UNIT:
                return userAdministrative != null ? new DecimalType(userAdministrative.getPressureunit()) : UnDefType.UNDEF;
        }
    }
    return super.getNAThingProperty(channelId);
}

Output:
             case CHANNEL_DEWPOINTDEP:
-                Double dewpoint = WeatherUtils.getDewPoint(dashboardData.getTemperature(), dashboardData.getHumidity());
-                return toDecimalType(WeatherUtils.getDewPointDep(dashboardData.getTemperature(), dewpoint));
+                Double dewPoint = WeatherUtils.getDewPoint(dashboardData.getTemperature(), dashboardData.getHumidity());
+                return toDecimalType(WeatherUtils.getDewPointDep(dashboardData.getTemperature(), dewPoint));
             case CHANNEL_WIND_UNIT:


Input:
public boolean apply(Game game, Ability source) {
    Permanent permanent = game.getPermanent(source.getFirstTarget());
    Player controller = game.getPlayer(source.getControllerId());
    Permanent sourcePermanent = game.getPermanentOrLKIBattlefield(source.getSourceId());
    if (controller != null && permanent != null && sourcePermanent != null) {
        if (controller.moveCardToExileWithInfo(permanent, source.getSourceId(), sourcePermanent.getIdName(), source.getSourceId(), game, Zone.BATTLEFIELD, true)) {
            MageObject mageObject = game.getObject(permanent.getId());
            if (mageObject != null) {
                CopyEffect copyEffect = new CopyEffect(Duration.EndOfTurn, mageObject, source.getSourceId());
                game.addEffect(copyEffect, source);
            }
            AtTheBeginOfNextEndStepDelayedTriggeredAbility delayedAbility = new AtTheBeginOfNextEndStepDelayedTriggeredAbility(new ReturnFromExileEffect(source.getSourceId(), Zone.BATTLEFIELD, false));
            delayedAbility.setSourceId(source.getSourceId());
            delayedAbility.setControllerId(source.getControllerId());
            delayedAbility.setSourceObject(source.getSourceObject(game), game);
            game.addDelayedTriggeredAbility(delayedAbility);
            return true;
        }
    }
    return false;
}

Output:
         if (controller.moveCardToExileWithInfo(permanent, source.getSourceId(), sourcePermanent.getIdName(), source.getSourceId(), game, Zone.BATTLEFIELD, true)) {
-            MageObject mageObject = game.getObject(permanent.getId());
-            if (mageObject != null) {
-                CopyEffect copyEffect = new CopyEffect(Duration.EndOfTurn, mageObject, source.getSourceId());
-                game.addEffect(copyEffect, source);
-            }
+            game.addEffect(copyEffect, source);
             AtTheBeginOfNextEndStepDelayedTriggeredAbility delayedAbility = new AtTheBeginOfNextEndStepDelayedTriggeredAbility(new ReturnFromExileEffect(source.getSourceId(), Zone.BATTLEFIELD, false));


Input:
public void handle(Long timerID) {
    JsonObject json = new JsonObject().putString("String_Node_Str", "String_Node_Str");
    _websocket.writeTextFrame(json.encode());
}

Output:
     JsonObject json = new JsonObject().putString("String_Node_Str", "String_Node_Str");
-    _websocket.writeTextFrame(json.encode());
+    try {
+        _sendTextFrame(json);
+    } catch (IllegalActionException e) {
+        e.printStackTrace();
+    }
 }


Input:
private static void test1() throws Exception {
    MultiLabelClfDataSet dataSet = TRECFormat.loadMultiLabelClfDataSet(new File(DATASETS, "String_Node_Str"), DataSetType.ML_CLF_SPARSE, true);
    MultiLabelClfDataSet testSet = TRECFormat.loadMultiLabelClfDataSet(new File(DATASETS, "String_Node_Str"), DataSetType.ML_CLF_SPARSE, true);
    BMMClassifier bmmClassifier = new BMMClassifier(dataSet.getNumClasses(), 2, dataSet.getNumFeatures());
    BMMOptimizer optimizer = new BMMOptimizer(bmmClassifier, dataSet, 10000);
    bmmClassifier.setNumSample(1000);
    System.out.println("String_Node_Str");
    System.out.println("String_Node_Str" + Accuracy.accuracy(bmmClassifier, dataSet));
    System.out.println("String_Node_Str" + Accuracy.accuracy(bmmClassifier, testSet));
    for (int i = 1; i <= 10; i++) {
        optimizer.iterate();
        System.out.println("String_Node_Str" + i);
        System.out.println("String_Node_Str" + Accuracy.accuracy(bmmClassifier, dataSet));
        System.out.println("String_Node_Str" + Overlap.overlap(bmmClassifier, dataSet));
        System.out.println("String_Node_Str" + Accuracy.accuracy(bmmClassifier, testSet));
        System.out.println("String_Node_Str" + Overlap.overlap(bmmClassifier, testSet));
    }
    System.out.println("String_Node_Str" + optimizer.getTerminator().getHistory());
    System.out.println(bmmClassifier);
}

Output:
     BMMOptimizer optimizer = new BMMOptimizer(bmmClassifier, dataSet, 10000);
-    bmmClassifier.setNumSample(1000);
+    bmmClassifier.setNumSample(100);
     System.out.println("String_Node_Str");


Input:
public BrowseInfo browseMini(BrowserScope bs) throws BrowseException {
    log.info(LogManager.getHeader(context, "String_Node_Str", "String_Node_Str"));
    this.scope = bs;
    browseIndex = scope.getBrowseIndex();
    dao.setTable(browseIndex.getTableName(scope.inCommunity(), scope.inCollection()));
    dao.setAscending(scope.isAscending());
    if (scope.inCollection() || scope.inCommunity()) {
        if (scope.inCollection()) {
            Collection col = (Collection) scope.getBrowseContainer();
            dao.setContainerIDField("String_Node_Str");
            dao.setContainerID(col.getID());
        } else if (scope.inCommunity()) {
            Community com = (Community) scope.getBrowseContainer();
            dao.setContainerIDField("String_Node_Str");
            dao.setContainerID(com.getID());
        }
    }
    dao.setLimit(scope.getResultsPerPage());
    String orderBy = browseIndex.getSortField();
    if (scope.getSortBy() > 0) {
        orderBy = "String_Node_Str" + Integer.toString(scope.getSortBy());
    }
    dao.setOrderField(orderBy);
    List results = dao.doQuery();
    BrowseInfo browseInfo = new BrowseInfo(results, 0, scope.getResultsPerPage(), 0);
    browseInfo.setBrowseIndex(browseIndex);
    browseInfo.setSortOption(scope.getSortOption());
    browseInfo.setAscending(scope.isAscending());
    if (scope.inCollection() || scope.inCommunity()) {
        browseInfo.setBrowseContainer(scope.getBrowseContainer());
    }
    browseInfo.setResultsPerPage(scope.getResultsPerPage());
    browseInfo.setEtAl(scope.getEtAl());
    return browseInfo;
}

Output:
     dao.setLimit(scope.getResultsPerPage());
-    String orderBy = browseIndex.getSortField();
+    String orderBy = browseIndex.getSortField(scope.isSecondLevel());
     if (scope.getSortBy() > 0) {


Input:
private static void convertGarbageCollectionExpression(String gcExpression, HColumnDescriptor columnDescriptor) {
    if (Strings.isNullOrEmpty(gcExpression)) {
        columnDescriptor.setMaxVersions(0);
        return;
    }
    String maxVersionExpression = null;
    String minVersionExpression = null;
    String ttlExpression = null;
    if (gcExpression.contains("String_Node_Str")) {
        for (String expression : gcExpressionOrSplitter.split(gcExpression)) {
            if (expression.contains("String_Node_Str")) {
                for (String expressionComponent : gcExpressionAndSplitter.split(expression)) {
                    if (expressionComponent.contains("String_Node_Str") && expressionComponent.contains("String_Node_Str")) {
                        ttlExpression = expressionComponent.replaceAll("String_Node_Str", "String_Node_Str");
                    } else if (expressionComponent.contains("String_Node_Str") && expressionComponent.contains("String_Node_Str")) {
                        minVersionExpression = expressionComponent.replaceAll("String_Node_Str", "String_Node_Str");
                    } else {
                        throw new IllegalStateException(String.format("String_Node_Str", expression));
                    }
                }
            } else if (expression.contains("String_Node_Str") && expression.contains("String_Node_Str")) {
                maxVersionExpression = expression.replaceAll("String_Node_Str", "String_Node_Str");
            } else {
                throw new IllegalStateException(String.format("String_Node_Str", expression));
            }
        }
    } else if (gcExpression.contains("String_Node_Str") && gcExpression.contains("String_Node_Str")) {
        maxVersionExpression = gcExpression.replaceAll("String_Node_Str", "String_Node_Str");
    } else {
        throw new IllegalStateException(String.format("String_Node_Str", maxVersionExpression));
    }
    int maxVersions = getInteger(maxVersionExpression);
    columnDescriptor.setMaxVersions(maxVersions);
    if (minVersionExpression != null) {
        int minVersions = getInteger(minVersionExpression);
        Preconditions.checkState(minVersions < maxVersions, "String_Node_Str");
        columnDescriptor.setMinVersions(minVersions);
    }
    if (ttlExpression != null) {
        long bigtableTtl = getLong(ttlExpression);
        int ttlSeconds = (int) TimeUnit.SECONDS.convert(bigtableTtl, BigtableConstants.BIGTABLE_TIMEUNIT);
        if (ttlSeconds != HColumnDescriptor.DEFAULT_TTL) {
            columnDescriptor.setTimeToLive(ttlSeconds);
        }
    }
}

Output:
     if (Strings.isNullOrEmpty(gcExpression)) {
-        columnDescriptor.setMaxVersions(0);
+        columnDescriptor.setMaxVersions(Integer.MAX_VALUE);
         return;


Input:
private static void removeCheckpointMetaData(final Path pathPrefix) throws IOException {
    Path p = pathPrefix.suffix(COMPLETED_CHECKPOINT_SUFFIX);
    FileSystem fs = p.getFileSystem();
    if (fs.exists(p)) {
        fs.delete(p, false);
        return;
    }
    p = pathPrefix.suffix("String_Node_Str");
    if (fs.exists(p)) {
        fs.delete(p, false);
    }
    p = pathPrefix.suffix("String_Node_Str");
    if (fs.exists(p)) {
        fs.delete(p, false);
    }
}

Output:
         fs.delete(p, false);
-        return;
+        removed = true;
     }


Input:
public int getAbsoluteLeft(Element elem) {
    Document doc = elem.getOwnerDocument();
    return getBoundingClientRectLeft(elem) + doc.getScrollLeft();
}

Output:
 public int getAbsoluteLeft(Element elem) {
-    Document doc = elem.getOwnerDocument();
-    return getBoundingClientRectLeft(elem) + doc.getScrollLeft();
+    int left = getBoundingClientRectLeft(elem) + getDocumentScrollLeftImpl();
+    if (isRTL(elem)) {
+        left += getParentOffsetDelta(elem);
+    }
+    return left;
 }


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    final ReaderTag tag = mTags.get(position);
    final TagViewHolder holder;
    if (convertView == null) {
        convertView = mInflater.inflate(R.layout.reader_tag_toolbar_menu_item, parent, false);
        holder = new TagViewHolder(convertView);
        convertView.setTag(holder);
    } else {
        holder = (TagViewHolder) convertView.getTag();
    }
    holder.textView.setText(tag.getCapitalizedTagName());
    if (isCurrentTag(tag)) {
        holder.textView.setBackground(mSelectedBackground);
    } else {
        holder.textView.setBackground(null);
    }
    return convertView;
}

Output:
     if (isCurrentTag(tag)) {
-        holder.textView.setBackground(mSelectedBackground);
+        holder.textView.setBackgroundDrawable(mSelectedBackground);
     } else {


Input:
public void setUp() throws CTFReaderException {
    StructDeclaration structDec;
    StructDefinition structDef;
    IntegerDeclaration id = new IntegerDeclaration(8, false, 8, ByteOrder.LITTLE_ENDIAN, Encoding.UTF8, null);
    String lengthName = "String_Node_Str";
    structDec = new StructDeclaration(0);
    structDec.addField(lengthName, id);
    structDef = new StructDefinition(structDec, null, "String_Node_Str");
    structDef.lookupInteger(lengthName).setValue(seqLen);
    SequenceDeclaration sd = new SequenceDeclaration(lengthName, id);
    fixture = new SequenceDefinition(sd, structDef, "String_Node_Str");
    BitBuffer input = new BitBuffer(java.nio.ByteBuffer.allocateDirect(seqLen * 8));
    for (int i = 0; i < seqLen; i++) {
        input.putInt(i);
    }
    fixture.read(input);
    assert (fixture != null);
}

Output:
     StructDefinition structDef;
-    IntegerDeclaration id = new IntegerDeclaration(8, false, 8, ByteOrder.LITTLE_ENDIAN, Encoding.UTF8, null);
+    IntegerDeclaration id = new IntegerDeclaration(8, false, 8, ByteOrder.LITTLE_ENDIAN, Encoding.UTF8, null, 8);
     String lengthName = "String_Node_Str";


Input:
protected int getHScrollSelectionInPixels() {
    ScrollBar hScrollBar = getHorizontalBar();
    int res = hScrollBar.getSelection() * COLUMN_WIDTH;
    int max = hScrollBar.getMaximum();
    if (max > 3 && hScrollBar.getSelection() >= max - 3) {
        return res + 100;
    }
    return res;
}

Output:
     int max = hScrollBar.getMaximum();
-    if (max > 3 && hScrollBar.getSelection() >= max - 3) {
+    if (max > 1 && hScrollBar.getSelection() >= max - 1) {
         return res + 100;


Input:
public boolean exists() {
    return fResource.exists();
}

Output:
 public boolean exists() {
-    return fResource.exists();
+    return fFile.exists();
 }


Input:
private String _generateTypeConvertVariableDeclaration() throws IllegalActionException {
    StringBuffer code = new StringBuffer();
    Iterator<?> channels = getStrategy().getTypeConvertChannels().iterator();
    while (channels.hasNext()) {
        Channel channel = (Channel) channels.next();
        Type portType = ((TypedIOPort) channel.port).getType();
        if (getStrategy().isPrimitive(portType)) {
            code.append("String_Node_Str");
            code.append(targetType(portType));
            getStrategy();
            code.append("String_Node_Str" + ProgramCodeGeneratorAdapterStrategy.getTypeConvertReference(channel));
            int bufferSize = Math.max(DFUtilities.getTokenProductionRate(channel.port), DFUtilities.getTokenConsumptionRate(channel.port));
            if (bufferSize > 1) {
                code.append("String_Node_Str" + bufferSize + "String_Node_Str");
            }
            code.append("String_Node_Str" + _eol);
        }
    }
    return code.toString();
}

Output:
     StringBuffer code = new StringBuffer();
-    Iterator<?> channels = getStrategy().getTypeConvertChannels().iterator();
+    Iterator<?> channels = target.getStrategy().getTypeConvertChannels().iterator();
     while (channels.hasNext()) {


Input:
public InputStream getContentAsStream() {
    try {
        return new ByteArrayInputStream(content.getBytes(charset));
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException("String_Node_Str", e);
    }
}

Output:
     } catch (UnsupportedEncodingException e) {
-        throw new RuntimeException("String_Node_Str", e);
+        throw new TestUtilRuntimeException("String_Node_Str", e);
     }


Input:
public void topicSubjectLocatorChanged(Topic t, Locator newLocator, Locator oldLocator) throws TopicMapException {
    for (Locator l : t.getSubjectIdentifiers()) {
        removeTopicFromIndex(l);
    }
    if (topicMapListeners.size() > 0) {
        LayeredTopic lt = makeLayeredTopic(t);
        for (TopicMapListener listener : topicMapListeners) {
            listener.topicSubjectLocatorChanged(lt, newLocator, oldLocator);
        }
    }
}

Output:
     }
-    if (topicMapListeners.size() > 0) {
+    if (!topicMapListeners.isEmpty()) {
         LayeredTopic lt = makeLayeredTopic(t);


Input:
private static void usage() {
    HelpFormatter formatter = new HelpFormatter();
    String args = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    formatter.printHelp("String_Node_Str" + args, getOptions());
    System.exit(0);
}

Output:
     String args = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
-    formatter.printHelp("String_Node_Str" + args, getOptions());
+    formatter.printHelp(toolName + "String_Node_Str" + args, getOptions());
     System.exit(0);


Input:
public void migration(IProgressMonitor monitor) {
    if (monitor == null) {
        monitor = new NullProgressMonitor();
    }
    if (versionFile != null && versionFile.exists()) {
        ProductVersion version = WorkspaceVersionHelper.getVesion(new Path(versionFile.getAbsolutePath()));
        final List<IMigrationTask> migrationTasks = MigrationTaskManager.findWorkspaceTaskByType(MigrationTaskType.FILE, version);
        MigrationTaskManager.doMigrationTask(migrationTasks, monitor);
    }
}

Output:
     }
-    if (versionFile != null && versionFile.exists()) {
-        ProductVersion version = WorkspaceVersionHelper.getVesion(new Path(versionFile.getAbsolutePath()));
-        final List<IMigrationTask> migrationTasks = MigrationTaskManager.findWorkspaceTaskByType(MigrationTaskType.FILE, version);
-        MigrationTaskManager.doMigrationTask(migrationTasks, monitor);
-    }
+    MigrationTaskManager.doMigrationTask(migrationTasks, monitor);
 }


Input:
public Connection getConnection(String driverClass, String url, String jndiNameUrl, Properties connectionProperties) throws SQLException, OdaException {
    validateConnectionUrl(url);
    if (logger.isLoggable(Level.FINE))
        logger.fine("String_Node_Str" + driverClass + "String_Node_Str" + url + "String_Node_Str" + jndiNameUrl);
    return doConnect(driverClass, url, jndiNameUrl, connectionProperties);
}

Output:
         logger.fine("String_Node_Str" + driverClass + "String_Node_Str" + url + "String_Node_Str" + jndiNameUrl);
-    return doConnect(driverClass, url, jndiNameUrl, connectionProperties);
+    return doConnect(driverClass, url, jndiNameUrl, connectionProperties, driverClassPath);
 }


Input:
public void callback(Pointer instance, final GdkEventButton event) {
    if (event.type == 4) {
        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                if (GtkSystemTray.this.jmenu.isVisible()) {
                    GtkSystemTray.this.jmenu.setVisible(false);
                } else {
                    int iconX = (int) (event.x_root - event.x);
                    int iconY = (int) (event.y_root - event.y);
                    Dimension size = GtkSystemTray.this.jmenu.getPreferredSize();
                    iconX -= size.width / 2;
                    if (iconY > 240) {
                        iconY -= size.height;
                    } else {
                        iconY += ICON_SIZE;
                    }
                    GtkSystemTray.this.jmenu.setInvoker(GtkSystemTray.this.jmenu);
                    GtkSystemTray.this.jmenu.setLocation(iconX, iconY);
                    GtkSystemTray.this.jmenu.setVisible(true);
                }
            }
        });
    }
}

Output:
     if (event.type == 4) {
-        SwingUtilities.invokeLater(new Runnable() {
+        SwingUtil.invokeLater(new Runnable() {


Input:
List<BoundaryPart> getEligibleParts(final Point point) {
    if (boundary.size() <= 1) {
        return new ArrayList<BoundaryPart>();
    }
    int size = boundary.size();
    ArrayList<BoundaryPart> ret = new ArrayList<BoundaryPart>();
    if (boundary.get(1).isConstraintRightPoint(point)) {
        ret.add(boundary.get(0));
        ret.addAll(getUpperSameRightPoint(0, boundary.get(0)));
        return ret;
    }
    if (boundary.get(1).pointIsLower(point)) {
        ret.add(boundary.get(0));
        return ret;
    }
    if (boundary.get(size - 1).isConstraintRightPoint(point)) {
        ret.addAll(getLowerSameRightPoint(size - 1, boundary.get(size - 1)));
        ret.add(boundary.get(size - 1));
        return ret;
    }
    if (boundary.get(size - 1).pointIsUpper(point)) {
        ret.add(boundary.get(size - 1));
        return ret;
    }
    BoundaryPart bp = boundary.get(0);
    BoundaryPart bpo;
    int index = boundary.size() / 2;
    int delta = index;
    boolean next = true;
    while (next) {
        bp = boundary.get(index);
        if (bp.pointIsUpper(point)) {
            bpo = boundary.get(index + 1);
            if (bpo.pointIsLower(point)) {
                ret.add(bp);
                return ret;
            } else if (bpo.isConstraintRightPoint(point)) {
                ret.add(bp);
                ret.addAll(getUpperSameRightPoint(index + 1, bpo));
                return ret;
            } else {
                delta = delta / 2 > 0 ? delta / 2 : 1;
                index = index + delta;
            }
        } else if (bp.isConstraintRightPoint(point)) {
            ret.addAll(getLowerSameRightPoint(index, bp));
            ret.add(bp);
            ret.addAll(getUpperSameRightPoint(index, bp));
            return ret;
        } else {
            bpo = boundary.get(index - 1);
            if (bpo.pointIsUpper(point)) {
                ret.add(bpo);
                return ret;
            } else if (bpo.isConstraintRightPoint(point)) {
                ret.add(bp);
                ret.addAll(getUpperSameRightPoint(index - 1, bpo));
                return ret;
            } else {
                delta = delta / 2 > 0 ? delta / 2 : 1;
                index = index - delta;
            }
        }
    }
    return ret;
}

Output:
         ret.add(boundary.get(0));
-        ret.addAll(getUpperSameRightPoint(0, boundary.get(0)));
+        ret.add(boundary.get(1));
+        ret.addAll(getUpperSameRightPoint(1, boundary.get(1)));
         return ret;


Input:
private void configureList(EventList<VisualSearchResult> eventList) {
    resultsList = new ConfigurableTable<VisualSearchResult>(false);
    resultsList.setEventList(eventList);
    resultsList.setTableFormat(new ListViewTableFormat());
    ListViewTableCellEditor renderer = new ListViewTableCellEditor(actionRenderer);
    resultsList.setDefaultRenderer(VisualSearchResult.class, renderer);
    ListViewTableCellEditor editor = new ListViewTableCellEditor(actionEditor);
    resultsList.setDefaultEditor(VisualSearchResult.class, editor);
    resultsList.setRowHeight(ListViewTableCellEditor.HEIGHT);
    resultsList.setColumnWidth(0, ListViewTableCellEditor.WIDTH);
    resultsList.setRowHeight(42);
}

Output:
     resultsList.setEventList(eventList);
-    resultsList.setTableFormat(new ListViewTableFormat());
+    ListViewTableFormat tableFormat = new ListViewTableFormat();
+    resultsList.setTableFormat(tableFormat);
     ListViewTableCellEditor renderer = new ListViewTableCellEditor(actionRenderer);


Input:
public boolean foundInterruptible(int x, int y, int z, VoxelData start) {
    int[] pos = new int[] { x, y, z };
    boolean escaped;
    for (int i = 0; i < paths.length; i++) {
        if (canIgnore(i, x, y, z)) {
            return true;
        }
        escaped = true;
        paths[i].init(pos, grid.getWidth(), grid.getHeight(), grid.getDepth());
        while (paths[i].next(pos)) {
            VoxelData vd = grid.getData(pos[0], pos[1], pos[2]);
            if (vd.getState() != Grid.OUTSIDE && vd.getMaterial() != material) {
                escaped = false;
                break;
            }
        }
        if (!escaped) {
            allEscaped = false;
            return false;
        }
        addIgnoredVoxels(i, x, y, z);
        return true;
    }
    return true;
}

Output:
 public boolean foundInterruptible(int x, int y, int z, VoxelData start) {
-    int[] pos = new int[] { x, y, z };
-    boolean escaped;
+    if (!canEscape())
+        return false;
+    boolean[] badPaths = new boolean[paths.length];
+    badPathCount = 0;
     for (int i = 0; i < paths.length; i++) {


Input:
public void run() {
    Plugins.getInstance().onRemoveCard((MagePermanent) comp, count);
    comp.setVisible(false);
    BattlefieldPanel.this.remove(comp);
}

Output:
     comp.setVisible(false);
-    BattlefieldPanel.this.remove(comp);
+    BattlefieldPanel.this.jPanel.remove(comp);
 }


Input:
public static List<Integer> tableSendPos(List<Predicate> bodyP) {
    List<Integer> sendPos = new ArrayList<Integer>();
    Predicate prevp = null;
    for (Predicate p : bodyP) {
        if (prevp != null) {
            if (!prevp.first().equals(p.first())) {
                sendPos.add(p.getPos());
            }
        }
        prevp = p;
    }
    return sendPos;
}

Output:
     for (Predicate p : bodyP) {
-        if (prevp != null) {
-            if (!prevp.first().equals(p.first())) {
-                sendPos.add(p.getPos());
+        if (prevp == null || prevp instanceof PrivPredicate) {
+            prevp = p;
+            continue;
+        }
+        if (requireTransfer(prevp, p, tableMap)) {
+            if (collectLiveVarsAt(r, p.getPos()).isEmpty()) {
+                Assert.impossible();
+                continue;
             }


Input:
protected void doExecuteCommand() {
    try {
        UIManager.setLookAndFeel(lookAndFeelClass);
        for (ApplicationWindow appWindow : ValkyrieRepository.getInstance().getApplicationConfig().windowManager().getWindows()) {
            JXFrame control = appWindow.getControl();
            SwingUtilities.updateComponentTreeUI(control);
            for (Window window : control.getOwnedWindows()) {
                updateWindow(window);
            }
        }
    } catch (Exception e) {
        throw new ApplicationException("String_Node_Str");
    }
}

Output:
         for (ApplicationWindow appWindow : ValkyrieRepository.getInstance().getApplicationConfig().windowManager().getWindows()) {
-            JXFrame control = appWindow.getControl();
+            JFrame control = appWindow.getControl();
             SwingUtilities.updateComponentTreeUI(control);


Input:
public boolean isSafeTermination() {
    for (Role r : this.states.keySet()) {
        EndpointState s = this.states.get(r);
        if ((s.isTerminal() && !this.buffs.isEmpty(r)) || (!s.isTerminal() && (!(s.getStateKind().equals(Kind.UNARY_INPUT) && s.getAcceptable().iterator().next().isAccept()) || this.states.keySet().stream().anyMatch((rr) -> !r.equals(rr) && this.buffs.isConnected(r, rr))))) {
            return false;
        }
    }
    return true;
}

Output:
     for (Role r : this.states.keySet()) {
-        EndpointState s = this.states.get(r);
-        if ((s.isTerminal() && !this.buffs.isEmpty(r)) || (!s.isTerminal() && (!(s.getStateKind().equals(Kind.UNARY_INPUT) && s.getAcceptable().iterator().next().isAccept()) || this.states.keySet().stream().anyMatch((rr) -> !r.equals(rr) && this.buffs.isConnected(r, rr))))) {
+        if (!canSafelyTerminate(r)) {
             return false;