Input:
private void initRowMergeMinsize(List children) {
    int size = children.size();
    Map map = getOwner().getViewer().getVisualPartMap();
    List list = new ArrayList();
    List adjustRow = new ArrayList();
    for (int i = 0; i < size; i++) {
        IFigure figure = (IFigure) children.get(i);
        ITableLayoutCell cellPart = (ITableLayoutCell) map.get(figure);
        int rowNumber = cellPart.getRowNumber();
        int rowSpan = cellPart.getRowSpan();
        if (rowSpan == 1) {
            continue;
        }
        list.add(figure);
        if (rowSpan > 1) {
            for (int j = rowNumber; j < rowNumber + rowSpan; j++) {
                adjustRow.add(new Integer(j));
            }
        }
    }
    caleRowMergeMinHeight(list, adjustRow, new ArrayList());
}

Output:
             for (int j = rowNumber; j < rowNumber + rowSpan; j++) {
-                adjustRow.add(new Integer(j));
+                adjustRow.add(Integer.valueOf(j));
             }


Input:
public void testNavigator() throws DataException, OLAPException {
    ICubeQueryDefinition cqd = creator.createMirroredQueryDefinition("String_Node_Str", true);
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
    EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();
    EdgeCursor columnCursor = cubeView.getColumnEdgeView().getEdgeCursor();
    DimensionCursor countryCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(0);
    DimensionCursor cityCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(1);
    DimensionCursor streetCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(2);
    DimensionCursor yearCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(3);
    DimensionCursor productLineCursor = (DimensionCursor) rowCursor.getDimensionCursor().get(0);
    DimensionCursor productNameCursor = (DimensionCursor) rowCursor.getDimensionCursor().get(1);
    columnCursor.beforeFirst();
    assertTrue(columnCursor.isBeforeFirst());
    assertTrue(countryCursor.isBeforeFirst());
    assertTrue(cityCursor.isBeforeFirst());
    assertTrue(streetCursor.isBeforeFirst());
    assertTrue(yearCursor.isBeforeFirst());
    columnCursor.afterLast();
    assertTrue(columnCursor.isAfterLast());
    assertTrue(countryCursor.isAfterLast());
    assertTrue(cityCursor.isAfterLast());
    assertTrue(streetCursor.isAfterLast());
    assertTrue(yearCursor.isAfterLast());
    columnCursor.first();
    countryCursor.afterLast();
    cityCursor.afterLast();
    streetCursor.afterLast();
    yearCursor.afterLast();
    assertTrue(countryCursor.isAfterLast());
    assertTrue(cityCursor.isAfterLast());
    assertTrue(streetCursor.isAfterLast());
    assertTrue(yearCursor.isAfterLast());
    columnCursor.first();
    columnCursor.next();
    cityCursor.afterLast();
    streetCursor.afterLast();
    yearCursor.afterLast();
    assertTrue(countryCursor.isFirst());
    assertTrue(cityCursor.isAfterLast());
    assertTrue(streetCursor.isAfterLast());
    assertTrue(yearCursor.isAfterLast());
    columnCursor.first();
    assertTrue(columnCursor.isFirst());
    assertTrue(countryCursor.isFirst());
    assertTrue(cityCursor.isFirst());
    assertTrue(streetCursor.isFirst());
    assertTrue(yearCursor.isFirst());
    columnCursor.last();
    assertTrue(columnCursor.last());
    assertTrue(countryCursor.last());
    assertTrue(cityCursor.last());
    assertTrue(streetCursor.last());
    assertTrue(yearCursor.last());
    columnCursor.setPosition(5);
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.setPosition(85);
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.setPosition(220);
    try {
        countryCursor.getObject("String_Node_Str");
        fail("String_Node_Str");
    } catch (OLAPException e) {
    }
    columnCursor.setPosition(225);
    columnCursor.previous();
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.setPosition(86);
    columnCursor.previous();
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.beforeFirst();
    columnCursor.relative(6);
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.beforeFirst();
    columnCursor.next();
    columnCursor.next();
    columnCursor.next();
    columnCursor.setPosition(1);
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.beforeFirst();
    columnCursor.setPosition(80);
    streetCursor.setPosition(1);
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.beforeFirst();
    columnCursor.setPosition(80);
    columnCursor.next();
    countryCursor.next();
    assertTrue(countryCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(cityCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(streetCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    assertTrue(yearCursor.getObject("String_Node_Str").equals("String_Node_Str"));
    columnCursor.afterLast();
    try {
        streetCursor.getObject("String_Node_Str");
        fail("String_Node_Str");
    } catch (OLAPException e) {
    }
    columnCursor.beforeFirst();
    columnCursor.next();
    assertTrue(countryCursor.getEdgeStart() == 0);
    assertTrue(countryCursor.getEdgeEnd() == 79);
    assertTrue(cityCursor.getEdgeStart() == 0);
    assertTrue(cityCursor.getEdgeEnd() == 19);
    assertTrue(streetCursor.getEdgeStart() == 0);
    assertTrue(streetCursor.getEdgeEnd() == 4);
    assertTrue(yearCursor.getEdgeStart() == 0);
    assertTrue(yearCursor.getEdgeEnd() == 0);
    columnCursor.beforeFirst();
    columnCursor.setPosition(1);
    assertTrue(countryCursor.getEdgeStart() == 0);
    assertTrue(countryCursor.getEdgeEnd() == 79);
    assertTrue(cityCursor.getEdgeStart() == 0);
    assertTrue(cityCursor.getEdgeEnd() == 19);
    assertTrue(streetCursor.getEdgeStart() == 0);
    assertTrue(streetCursor.getEdgeEnd() == 4);
    assertTrue(yearCursor.getEdgeStart() == 1);
    assertTrue(yearCursor.getEdgeEnd() == 1);
    columnCursor.setPosition(81);
    assertTrue(countryCursor.getEdgeStart() == 80);
    assertTrue(countryCursor.getEdgeEnd() == 119);
    assertTrue(cityCursor.getEdgeStart() == 80);
    assertTrue(cityCursor.getEdgeEnd() == 99);
    assertTrue(streetCursor.getEdgeStart() == 80);
    assertTrue(streetCursor.getEdgeEnd() == 84);
    assertTrue(yearCursor.getEdgeStart() == 81);
    assertTrue(yearCursor.getEdgeEnd() == 81);
    columnCursor.setPosition(146);
    assertTrue(countryCursor.getEdgeStart() == 120);
    assertTrue(countryCursor.getEdgeEnd() == 159);
    assertTrue(cityCursor.getEdgeStart() == 140);
    assertTrue(cityCursor.getEdgeEnd() == 159);
    assertTrue(streetCursor.getEdgeStart() == 145);
    assertTrue(streetCursor.getEdgeEnd() == 149);
    assertTrue(yearCursor.getEdgeStart() == 146);
    assertTrue(yearCursor.getEdgeEnd() == 146);
    columnCursor.beforeFirst();
    columnCursor.setPosition(220);
    assertTrue(countryCursor.getEdgeStart() == -1);
    assertTrue(countryCursor.getEdgeEnd() == -1);
    assertTrue(cityCursor.getEdgeStart() == -1);
    assertTrue(cityCursor.getEdgeEnd() == -1);
    assertTrue(streetCursor.getEdgeStart() == -1);
    assertTrue(streetCursor.getEdgeEnd() == -1);
    assertTrue(yearCursor.getEdgeStart() == -1);
    assertTrue(yearCursor.getEdgeEnd() == -1);
    this.close(dataCursor);
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube, false);
     EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();


Input:
public RequestClaimDto map(RequestClaim r) {
    RequestClaimDto dto = delegate.map(r);
    if (dto != null) {
        RequestDto request = requestService.findRequest(dto.getId());
        dto.setUrl(createLink(request.getIssueInformation()));
    }
    return dto;
}

Output:
     if (dto != null) {
-        RequestDto request = requestService.findRequest(dto.getId());
+        RequestDto request = requestService.findRequest(r.getRequestId());
         dto.setUrl(createLink(request.getIssueInformation()));


Input:
public void a(World world, int i, int j, int k, Entity entity) {
    if (entity instanceof EntityLiving) {
        CraftServer server = ((WorldServer) world).getServer();
        CraftEntity toPassIn = new CraftLivingEntity(server, (EntityLiving) entity);
        EntityDamageByBlockEvent edbbe = new EntityDamageByBlockEvent(((WorldServer) world).getWorld().getBlockAt(i, j, k), toPassIn, EntityDamageEvent.DamageCause.CONTACT, 1);
        server.getPluginManager().callEvent(edbbe);
        if (!edbbe.isCancelled()) {
            entity.a(((Entity) (null)), edbbe.getDamage());
        }
        return;
    }
    entity.a(((Entity) (null)), 1);
}

Output:
         CraftServer server = ((WorldServer) world).getServer();
-        CraftEntity toPassIn = new CraftLivingEntity(server, (EntityLiving) entity);
-        EntityDamageByBlockEvent edbbe = new EntityDamageByBlockEvent(((WorldServer) world).getWorld().getBlockAt(i, j, k), toPassIn, EntityDamageEvent.DamageCause.CONTACT, 1);
+        org.bukkit.block.Block damager = ((WorldServer) world).getWorld().getBlockAt(i, j, k);
+        org.bukkit.entity.Entity damagee = entity.getBukkitEntity();
+        DamageCause damageType = EntityDamageEvent.DamageCause.CONTACT;
+        int damageDone = 1;
+        EntityDamageByBlockEvent edbbe = new EntityDamageByBlockEvent(damager, damagee, damageType, damageDone);
         server.getPluginManager().callEvent(edbbe);


Input:
public void reset(int p) {
    revive();
    x = (p % Dungeon.level.width()) * DungeonTilemap.SIZE + (DungeonTilemap.SIZE - width) / 2;
    y = (p / Dungeon.level.width()) * DungeonTilemap.SIZE + (DungeonTilemap.SIZE - height) / 2;
    time = TIME_TO_FADE;
}

Output:
     revive();
-    x = (p % Dungeon.level.width()) * DungeonTilemap.SIZE + (DungeonTilemap.SIZE - width) / 2;
-    y = (p / Dungeon.level.width()) * DungeonTilemap.SIZE + (DungeonTilemap.SIZE - height) / 2;
+    point(v.center(this));
     time = TIME_TO_FADE;


Input:
private void set() {
    Block standingblock = player.getLocation().getBlock();
    Block standblock = standingblock.getRelative(BlockFace.DOWN);
    if (standblock.getType() == Material.GLOWSTONE) {
        revert();
    } else if ((FireStream.isIgnitable(player, standingblock) && standblock.getType() != Material.LEAVES) && block == null && !blocks.containsKey(standblock)) {
        block = standingblock;
        normaltype = block.getType();
        normaldata = block.getData();
        block.setType(Material.TORCH);
        blocks.put(block, player);
    } else if ((FireStream.isIgnitable(player, standingblock) && standblock.getType() != Material.LEAVES) && !block.equals(standblock) && !blocks.containsKey(standblock) && GeneralMethods.isSolid(standblock)) {
        revert();
        block = standingblock;
        normaltype = block.getType();
        normaldata = block.getData();
        block.setType(Material.TORCH);
        blocks.put(block, player);
    } else if (block == null) {
        return;
    } else if (player.getWorld() != block.getWorld()) {
        revert();
    } else if (player.getLocation().distance(block.getLocation()) > FireMethods.getFirebendingDayAugment(range, player.getWorld())) {
        revert();
    }
}

Output:
         revert();
-    } else if ((FireStream.isIgnitable(player, standingblock) && standblock.getType() != Material.LEAVES) && block == null && !blocks.containsKey(standblock)) {
+    } else if ((FireStream.isIgnitable(player, standingblock) && standblock.getType() != Material.LEAVES && standblock.getType() != Material.LEAVES_2) && block == null && !blocks.containsKey(standblock)) {
         block = standingblock;


Input:
protected boolean visit(IResourceDelta delta, Collection<Runnable> runnables) {
    IResource resource = delta.getResource();
    IPath path = resource.getFullPath();
    Set<RepositoryNode> topLevelNodes = getTopLevelNodes();
    for (final RepositoryNode repoNode : topLevelNodes) {
        IPath topLevelNodeWorkspaceRelativePath = topLevelNodeToPathMap.get(repoNode);
        if (topLevelNodeWorkspaceRelativePath != null) {
            int matchingFirstSegments = path.matchingFirstSegments(topLevelNodeWorkspaceRelativePath);
            if (path.segmentCount() == matchingFirstSegments || matchingFirstSegments == topLevelNodeWorkspaceRelativePath.segmentCount()) {
                if ((delta.getAffectedChildren().length == 0) && (FileConstants.PROPERTIES_EXTENSION.equals(path.getFileExtension()) || (resource instanceof IContainer))) {
                    if (viewer instanceof RepoViewCommonViewer) {
                        runnables.add(new Runnable() {
                            public void run() {
                                refreshTopLevelNode(repoNode);
                            }
                        });
                    }
                    return false;
                } else {
                    return true;
                }
            }
        }
    }
    return false;
}

Output:
             int matchingFirstSegments = path.matchingFirstSegments(topLevelNodeWorkspaceRelativePath);
-            if (path.segmentCount() == matchingFirstSegments || matchingFirstSegments == topLevelNodeWorkspaceRelativePath.segmentCount()) {
-                if ((delta.getAffectedChildren().length == 0) && (FileConstants.PROPERTIES_EXTENSION.equals(path.getFileExtension()) || (resource instanceof IContainer))) {
+            if (path.segmentCount() == matchingFirstSegments || matchingFirstSegments == topLevelNodeWorkspaceRelativePath.segmentCount() || talendProChange) {
+                if ((delta.getAffectedChildren().length == 0) && (FileConstants.PROPERTIES_EXTENSION.equals(path.getFileExtension()) || talendProChange || (resource instanceof IContainer))) {
                     if (viewer instanceof RepoViewCommonViewer) {


Input:
public static Properties stripPrefixFromConfigKeys(Map<String, String> inputConfiguration) {
    Properties toReturn = new Properties();
    for (String key : inputConfiguration.keySet()) {
        toReturn.put(key.substring(PREFIX_LENGTH), inputConfiguration.get(key));
    }
    return toReturn;
}

Output:
     for (String key : inputConfiguration.keySet()) {
-        toReturn.put(key.substring(PREFIX_LENGTH), inputConfiguration.get(key));
+        toReturn.put(key.substring(PREFIX_LENGTH + 1), inputConfiguration.get(key));
     }


Input:
public RESTCoverageStore createExternaMosaicDatastore(String workspace, String storeName, File mosaicDir, ParameterConfigure configure, ParameterUpdate update) throws FileNotFoundException {
    if (!mosaicDir.isDirectory()) {
        throw new IllegalArgumentException("String_Node_Str" + mosaicDir + "String_Node_Str");
    }
    String sUrl = restURL + "String_Node_Str" + workspace + "String_Node_Str" + storeName + "String_Node_Str" + configure.toString() + "String_Node_Str" + update.toString();
    String sendResult = HTTPUtils.put(sUrl, mosaicDir.toURI().toString(), "String_Node_Str", gsuser, gspass);
    return RESTCoverageStore.build(sendResult);
}

Output:
     if (!mosaicDir.isDirectory()) {
-        throw new IllegalArgumentException("String_Node_Str" + mosaicDir + "String_Node_Str");
+        if (LOGGER.isEnabledFor(Level.WARN))
+            LOGGER.warn("String_Node_Str" + mosaicDir + "String_Node_Str");
     }


Input:
private XPathFragment getXPathFragmentForValue(Object value, MarshalRecord marshalRecord, Marshaller marshaller) {
    if (xmlAnyCollectionMapping.usesXMLRoot() && (value instanceof XMLRoot)) {
        XMLRoot xmlRootValue = (XMLRoot) value;
        XPathFragment xmlRootFragment = new XPathFragment(xmlRootValue.getLocalName(), marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());
        xmlRootFragment.setNamespaceURI(xmlRootValue.getNamespaceURI());
        return xmlRootFragment;
    }
    if (value instanceof Node) {
        XPathFragment frag = null;
        Node n = (Node) value;
        if (n.getNodeType() == Node.ELEMENT_NODE) {
            Element elem = (Element) n;
            String local = elem.getLocalName();
            if (local == null) {
                local = elem.getNodeName();
            }
            String prefix = elem.getPrefix();
            if (prefix != null && !prefix.equals(Constants.EMPTY_STRING)) {
                frag = new XPathFragment(prefix + marshalRecord.getNamespaceSeparator() + elem.getLocalName(), marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());
            } else {
                frag = new XPathFragment(local, marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());
            }
        } else if (n.getNodeType() == Node.ATTRIBUTE_NODE) {
            Attr attr = (Attr) n;
            attr.getLocalName();
            String prefix = attr.getPrefix();
            if (prefix != null && prefix.equals(Constants.EMPTY_STRING)) {
                frag = new XPathFragment(prefix + marshalRecord.getNamespaceSeparator() + attr.getLocalName(), marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());
            } else {
                frag = new XPathFragment(attr.getLocalName(), marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());
            }
        } else if (n.getNodeType() == Node.TEXT_NODE) {
            return SIMPLE_FRAGMENT;
        }
        return frag;
    }
    CoreAbstractSession childSession = null;
    try {
        childSession = marshaller.getXMLContext().getSession(value);
    } catch (XMLMarshalException e) {
        return SIMPLE_FRAGMENT;
    }
    if (childSession != null) {
        Descriptor descriptor = (Descriptor) childSession.getDescriptor(value);
        String defaultRootElementString = descriptor.getDefaultRootElement();
        if (defaultRootElementString != null) {
            return new XPathFragment(defaultRootElementString);
        }
    }
    return null;
}

Output:
 private XPathFragment getXPathFragmentForValue(Object value, MarshalRecord marshalRecord, Marshaller marshaller) {
-    if (xmlAnyCollectionMapping.usesXMLRoot() && (value instanceof XMLRoot)) {
-        XMLRoot xmlRootValue = (XMLRoot) value;
+    if (xmlAnyCollectionMapping.usesXMLRoot() && (value instanceof Root)) {
+        Root xmlRootValue = (Root) value;
         XPathFragment xmlRootFragment = new XPathFragment(xmlRootValue.getLocalName(), marshalRecord.getNamespaceSeparator(), marshalRecord.isNamespaceAware());


Input:
public void createElementsForTypeMappingInfo() {
    if (this.javaClassToTypeMappingInfos != null && !this.javaClassToTypeMappingInfos.isEmpty()) {
        Set<JavaClass> classes = this.javaClassToTypeMappingInfos.keySet();
        for (JavaClass nextClass : classes) {
            TypeMappingInfo nextInfo = this.javaClassToTypeMappingInfos.get(nextClass);
            if (nextInfo != null) {
                boolean xmlAttachmentRef = false;
                String xmlMimeType = null;
                java.lang.annotation.Annotation[] annotations = getAnnotations(nextInfo);
                Class adapterClass = this.typeMappingInfoToAdapterClasses.get(nextInfo);
                if (annotations != null) {
                    for (int j = 0; j < annotations.length; j++) {
                        java.lang.annotation.Annotation nextAnnotation = annotations[j];
                        if (nextAnnotation != null) {
                            if (nextAnnotation instanceof XmlMimeType) {
                                XmlMimeType javaAnnotation = (XmlMimeType) nextAnnotation;
                                xmlMimeType = javaAnnotation.value();
                            } else if (nextAnnotation instanceof XmlAttachmentRef) {
                                xmlAttachmentRef = true;
                            }
                        }
                    }
                }
                if (nextInfo.getXmlTagName() != null) {
                    ElementDeclaration element = new ElementDeclaration(nextInfo.getXmlTagName(), nextClass, nextClass.getQualifiedName(), false);
                    element.setTypeMappingInfo(nextInfo);
                    element.setXmlMimeType(xmlMimeType);
                    element.setXmlAttachmentRef(xmlAttachmentRef);
                    if (adapterClass != null) {
                        Method[] tacMethods = adapterClass.getMethods();
                        Class declJavaType = Object.class;
                        for (int i = 0; i < tacMethods.length; i++) {
                            Method method = tacMethods[i];
                            if (method.getName().equals("String_Node_Str")) {
                                if (!(method.getReturnType() == declJavaType)) {
                                    declJavaType = method.getReturnType();
                                    break;
                                }
                            }
                        }
                        element.setJavaType(helper.getJavaClass(declJavaType));
                    }
                    Class generatedClass = typeMappingInfoToGeneratedClasses.get(nextInfo);
                    if (generatedClass != null) {
                        element.setJavaType(helper.getJavaClass(generatedClass));
                    }
                    if (nextInfo.getElementScope() == TypeMappingInfo.ElementScope.Global) {
                        this.globalElements.put(element.getElementName(), element);
                    } else {
                        this.localElements.add(element);
                    }
                }
            }
        }
    }
}

Output:
                     if (adapterClass != null) {
-                        Method[] tacMethods = adapterClass.getMethods();
+                        Method[] tacMethods = PrivilegedAccessHelper.getMethods(adapterClass);
                         Class declJavaType = Object.class;


Input:
public void save() throws IOException {
    if (isArchiveFileAvailable(af)) {
        af.save();
    } else {
        throw new IOException(Messages.getString(ResourceConstants.FILE_HAS_BEEN_CLOSED));
    }
}

Output:
     } else {
-        throw new IOException(Messages.getString(ResourceConstants.FILE_HAS_BEEN_CLOSED));
+        throw new IOException(CoreMessages.getString(ResourceConstants.FILE_HAS_BEEN_CLOSED));
     }


Input:
public void silenced(int thisPlayerIndex, int thisMinionIndex, HearthTreeNode<BoardState> boardState, Deck deck) throws HSInvalidPlayerIndexException {
    for (Minion minion : boardState.data_.getMinions_p0()) {
        if (minion != this) {
            minion.setAttack((byte) (minion.getAttack() - 1));
        }
    }
}

Output:
 public void silenced(int thisPlayerIndex, int thisMinionIndex, HearthTreeNode<BoardState> boardState, Deck deck) throws HSInvalidPlayerIndexException {
-    for (Minion minion : boardState.data_.getMinions_p0()) {
+    for (Minion minion : boardState.data_.getMinions(thisPlayerIndex)) {
         if (minion != this) {


Input:
private void emit(final String id, final Point clustroid, final int flag, final String oldId, final JsonCollector collector) {
    this.outputNode.clear();
    if (clustroid == null)
        throw new IllegalArgumentException("String_Node_Str" + id);
    this.idNode.setValue(id);
    this.outputNode.put("String_Node_Str", this.idNode);
    this.outputNode.put("String_Node_Str", clustroid.write(this.pointNode));
    this.flagNode.setValue(flag);
    this.outputNode.put("String_Node_Str", this.flagNode);
    this.oldIdNode.setValue(oldId);
    this.outputNode.put("String_Node_Str", this.oldIdNode);
    collector.collect(this.outputNode);
}

Output:
     this.oldIdNode.setValue(oldId);
-    this.outputNode.put("String_Node_Str", this.oldIdNode);
+    clustroid.write(this.pointNode);
+    RepresentationNodes.write(outputNode, idNode, oldIdNode, pointNode);
+    RepresentationNodes.setFlag(outputNode, flagNode);
     collector.collect(this.outputNode);


Input:
private static String doVaribleReplace(String oldName, String newName, String value, List<Point> functionNameAreas, int vStart, int vEnd) {
    StringBuffer replacedString = new StringBuffer();
    int replaceableStart = vStart;
    int replaceableEnd = vEnd;
    for (Point functionNameArea : functionNameAreas) {
        if (vEnd <= functionNameArea.x) {
            break;
        }
        if (functionNameArea.y <= vStart) {
            continue;
        }
        if (replaceableStart < functionNameArea.x) {
            replaceableEnd = functionNameArea.x;
            String replaceableString = value.substring(replaceableStart, replaceableEnd);
            replacedString.append(doReplace(oldName, newName, replaceableString));
            replacedString.append(value.substring(functionNameArea.x, functionNameArea.y));
        } else {
            replacedString.append(value.substring(functionNameArea.x, functionNameArea.y));
        }
        replaceableStart = functionNameArea.y;
    }
    if (replaceableStart < vEnd) {
        String replaceableString = value.substring(replaceableStart, vEnd);
        replacedString.append(doReplace(oldName, newName, replaceableString));
    }
    return replacedString.toString();
}

Output:
             replacedString.append(doReplace(oldName, newName, replaceableString));
-            replacedString.append(value.substring(functionNameArea.x, functionNameArea.y));
+            replacedString.append(doReplace(oldName, newName, value.substring(functionNameArea.x, functionNameArea.y)));
         } else {


Input:
public void execute(CommandSender sender, CommandArgs args) {
    if (Utils.isPlayer(sender)) {
        Player player = (Player) sender;
        Location loc = ACHelper.getInstance().getLocation("String_Node_Str", player.getName() + "String_Node_Str", "String_Node_Str", player.getName());
        if (loc == null) {
            Utils.sI18n(sender, "String_Node_Str");
            return;
        }
        player.teleport(loc);
        Utils.sI18n(sender, "String_Node_Str");
        ACHelper.getInstance().removeLocation("String_Node_Str", player.getName() + "String_Node_Str", "String_Node_Str", player.getName());
    }
}

Output:
         Player player = (Player) sender;
-        Location loc = ACHelper.getInstance().getLocation("String_Node_Str", player.getName() + "String_Node_Str", "String_Node_Str", player.getName());
+        ACPlayer p = ACPlayer.getPlayer(player.getName());
+        Location loc = p.getLastLocation();
         if (loc == null) {


Input:
public static int nextAvailablePort(int port) {
    checkArgument(port >= MIN_PORT_NUMBER && port <= MAX_PORT_NUMBER, "String_Node_Str", port, MIN_PORT_NUMBER, MAX_PORT_NUMBER);
    int originalPort = port;
    while (!isPortAvailable(port) && port <= MAX_PORT_NUMBER) port++;
    if (port > MAX_PORT_NUMBER)
        throw new RuntimeException("String_Node_Str" + originalPort);
    return port;
}

Output:
     int originalPort = port;
-    while (!isPortAvailable(port) && port <= MAX_PORT_NUMBER) port++;
-    if (port > MAX_PORT_NUMBER)
+    while (!isPortAvailable(port) && port < MAX_PORT_NUMBER) port++;
+    if (port >= MAX_PORT_NUMBER)
         throw new RuntimeException("String_Node_Str" + originalPort);


Input:
public void testBasic() throws Exception {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    hier2.createLevel("String_Node_Str");
    cqd.createMeasure("String_Node_Str");
    IBinding binding1 = new Binding("String_Node_Str");
    binding1.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding1);
    IBinding binding2 = new Binding("String_Node_Str");
    binding2.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding2);
    IBinding binding3 = new Binding("String_Node_Str");
    binding3.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding3);
    IBinding binding4 = new Binding("String_Node_Str");
    binding4.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding4);
    IBinding binding5 = new Binding("String_Node_Str");
    binding5.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(binding5);
    cqd.setCacheQueryResults(true);
    FileArchiveWriter writter = new FileArchiveWriter(System.getProperty("String_Node_Str") + "String_Node_Str");
    DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_GENERATION, null, null, writter));
    this.createCube(writter, engine);
    IPreparedCubeQuery pcq = engine.prepare(cqd, null);
    ICubeQueryResults queryResults = pcq.execute(null);
    CubeCursor cursor = queryResults.getCubeCursor();
    cqd.setQueryResultsID(queryResults.getID());
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    writter.finish();
    engine.shutdown();
    FileArchiveReader reader = new FileArchiveReader(System.getProperty("String_Node_Str") + "String_Node_Str");
    engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_PRESENTATION, null, reader, null));
    cqd.setQueryResultsID(queryResults.getID());
    pcq = engine.prepare(cqd, null);
    queryResults = pcq.execute(null);
    cursor = queryResults.getCubeCursor();
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    this.printCube(cursor, columnEdgeBindingNames, "String_Node_Str", "String_Node_Str");
    engine.shutdown();
}

Output:
     cqd.setCacheQueryResults(true);
-    FileArchiveWriter writter = new FileArchiveWriter(System.getProperty("String_Node_Str") + "String_Node_Str");
+    FileArchiveWriter writter = new FileArchiveWriter(documentPath + "String_Node_Str");
     DataEngine engine = DataEngine.newDataEngine(DataEngineContext.newInstance(DataEngineContext.MODE_GENERATION, null, null, writter));


Input:
public DatastoreRead getDatastoreRead(String name) {
    logger.debug("String_Node_Str" + name);
    List<VcDatastoreEntity> entities = dsDao.findByName(name);
    if (entities.isEmpty()) {
        return null;
    }
    DatastoreRead read = new DatastoreRead();
    read.setName(name);
    read.setType(entities.get(0).getType());
    read.setRegex(entities.get(0).getRegex());
    read.setDatastoreReadDetails(new ArrayList<DatastoreReadDetail>());
    for (VcDatastoreEntity entity : entities) {
        DatastoreReadDetail detail = new DatastoreReadDetail();
        detail.setVcDatastoreName(entity.getVcDatastore());
        read.getDatastoreReadDetails().add(detail);
    }
    logger.debug("String_Node_Str" + read);
    return read;
}

Output:
     read.setType(entities.get(0).getType());
-    read.setRegex(entities.get(0).getRegex());
+    read.setRegexByBoolean(entities.get(0).getRegex());
     read.setDatastoreReadDetails(new ArrayList<DatastoreReadDetail>());


Input:
public String get(String key, String defaultValue) {
    return this.map.containsKey(key) ? this.map.get(key) : defaultValue;
}

Output:
 public String get(String key, String defaultValue) {
-    return this.map.containsKey(key) ? this.map.get(key) : defaultValue;
+    String value = this.map.get(key);
+    return value != null ? value : defaultValue;
 }


Input:
public void run() {
    while (true) {
        Task t;
        try {
            t = TASK_QUEUE.take();
        } catch (InterruptedException ex) {
            LOGGER.log(Level.WARNING, "String_Node_Str", ex);
            return;
        }
        switch(t.command) {
            case CONNECT:
                this.connect((PersonalKey) t.args.get(0));
                break;
            case DISCONNECT:
                this.disconnect();
                break;
        }
    }
}

Output:
             case CONNECT:
-                this.connect((PersonalKey) t.args.get(0));
+                this.connectAsync();
                 break;


Input:
void setOnBattery(boolean onBattery, int oldStatus, int level) {
    synchronized (this) {
        boolean doWrite = false;
        Message m = mHandler.obtainMessage(MSG_REPORT_POWER_CHANGE);
        m.arg1 = onBattery ? 1 : 0;
        mHandler.sendMessage(m);
        mOnBattery = mOnBatteryInternal = onBattery;
        long uptime = SystemClock.uptimeMillis() * 1000;
        long mSecRealtime = SystemClock.elapsedRealtime();
        long realtime = mSecRealtime * 1000;
        if (onBattery) {
            if (oldStatus == BatteryManager.BATTERY_STATUS_FULL || level >= 100 || (mDischargeCurrentLevel < 20 && level > 90)) {
                doWrite = true;
                resetAllStatsLocked();
                mDischargeStartLevel = level;
                mLowDischargeAmountSinceCharge = 0;
                mHighDischargeAmountSinceCharge = 0;
            }
            updateKernelWakelocksLocked();
            mHistoryCur.batteryLevel = (byte) level;
            mHistoryCur.states &= ~HistoryItem.STATE_BATTERY_PLUGGED_FLAG;
            if (DEBUG_HISTORY)
                Slog.v(TAG, "String_Node_Str" + Integer.toHexString(mHistoryCur.states));
            addHistoryRecordLocked(mSecRealtime);
            mTrackBatteryUptimeStart = uptime;
            mTrackBatteryRealtimeStart = realtime;
            mUnpluggedBatteryUptime = getBatteryUptimeLocked(uptime);
            mUnpluggedBatteryRealtime = getBatteryRealtimeLocked(realtime);
            mDischargeCurrentLevel = mDischargeUnplugLevel = level;
            doUnplugLocked(mUnpluggedBatteryUptime, mUnpluggedBatteryRealtime);
        } else {
            updateKernelWakelocksLocked();
            mHistoryCur.batteryLevel = (byte) level;
            mHistoryCur.states |= HistoryItem.STATE_BATTERY_PLUGGED_FLAG;
            if (DEBUG_HISTORY)
                Slog.v(TAG, "String_Node_Str" + Integer.toHexString(mHistoryCur.states));
            addHistoryRecordLocked(mSecRealtime);
            mTrackBatteryPastUptime += uptime - mTrackBatteryUptimeStart;
            mTrackBatteryPastRealtime += realtime - mTrackBatteryRealtimeStart;
            mDischargeCurrentLevel = level;
            if (level < mDischargeUnplugLevel) {
                mLowDischargeAmountSinceCharge += mDischargeUnplugLevel - level - 1;
                mHighDischargeAmountSinceCharge += mDischargeUnplugLevel - level;
            }
            doPlugLocked(getBatteryUptimeLocked(uptime), getBatteryRealtimeLocked(realtime));
        }
        if (doWrite || (mLastWriteTime + (60 * 1000)) < mSecRealtime) {
            if (mFile != null) {
                writeAsyncLocked();
            }
        }
    }
}

Output:
         if (onBattery) {
-            if (oldStatus == BatteryManager.BATTERY_STATUS_FULL || level >= 100 || (mDischargeCurrentLevel < 20 && level > 90)) {
+            if (oldStatus == BatteryManager.BATTERY_STATUS_FULL || level >= 95 || (mDischargeCurrentLevel < 30 && level >= 90)) {
                 doWrite = true;


Input:
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + (name == null ? 0 : name.hashCode());
    return result;
}

Output:
     int result = 1;
-    result = prime * result + (name == null ? 0 : name.hashCode());
+    result = prime * result + (getName() == null ? 0 : getName().hashCode());
     return result;


Input:
private void handleAction(final Action action, final Operation operation) {
    if (action == Action.START) {
        startOperation(operation);
    } else {
        throw new UnsupportedOperationException("String_Node_Str");
    }
}

Output:
     if (action == Action.START) {
-        startOperation(operation);
+        handleStart(operation);
     } else {


Input:
public WolfTable getWolfTable(final Location location) {
    return plugin.getDatabase().find(WolfTable.class).where().eq("String_Node_Str", location.getX()).eq("String_Node_Str", location.getY()).eq("String_Node_Str", location.getZ()).findUnique();
}

Output:
 public WolfTable getWolfTable(final Location location) {
-    return plugin.getDatabase().find(WolfTable.class).where().eq("String_Node_Str", location.getX()).eq("String_Node_Str", location.getY()).eq("String_Node_Str", location.getZ()).findUnique();
+    return plugin.getDatabase().find(WolfTable.class).where().eq("String_Node_Str", location.getBlockX()).eq("String_Node_Str", location.getBlockY()).eq("String_Node_Str", location.getBlockZ()).findUnique();
 }


Input:
private int getMinContentHeightHint() {
    if (mIsChildInGroup && (mVisibleType == VISIBLE_TYPE_SINGLELINE || mTransformationStartVisibleType == VISIBLE_TYPE_SINGLELINE)) {
        return mContext.getResources().getDimensionPixelSize(com.android.internal.R.dimen.notification_action_list_height);
    }
    if (mHeadsUpChild != null) {
        return mHeadsUpChild.getHeight();
    } else {
        return mContractedChild.getHeight() + mContext.getResources().getDimensionPixelSize(com.android.internal.R.dimen.notification_action_list_height);
    }
}

Output:
     if (mHeadsUpChild != null) {
-        return mHeadsUpChild.getHeight();
+        hint = mHeadsUpChild.getHeight();
     } else {


Input:
private void checkSetTurns() {
    for (int i = 0; i < groups.length - 3; i++) {
        Group g = groups[i];
        SecStrucState state = (SecStrucState) g.getProperty(Group.SEC_STRUC);
        SecStrucType type = state.getType();
        if (type.isHelixType())
            continue;
        boolean[] turns = state.getTurn();
        for (int t = 0; t < 3; t++) {
            if (turns[t]) {
                for (int l = i + 1; l < i + t + 3; l++) {
                    logger.debug("String_Node_Str" + i + "String_Node_Str" + type);
                    if (l >= groups.length)
                        break;
                    SecStrucType typel = getSecStrucType(l);
                    if (typel.equals(SecStrucType.coil))
                        setSecStrucType(l, SecStrucType.turn);
                }
            }
        }
    }
}

Output:
     for (int i = 0; i < groups.length - 3; i++) {
-        Group g = groups[i];
-        SecStrucState state = (SecStrucState) g.getProperty(Group.SEC_STRUC);
+        SecStrucState state = getSecStrucState(i);
         SecStrucType type = state.getType();


Input:
public void setDateFilter() {
    Blog blog = WordPress.getCurrentBlog();
    if (blog == null)
        return;
    String blogId = String.valueOf(blog.getBlogId());
    GregorianCalendar startDate = new GregorianCalendar(startYear, startMonth, startDay);
    GregorianCalendar endDate = new GregorianCalendar(endYear, endMonth, endDay);
    long one_day = 24 * 60 * 60 * 1000;
    mCursor = WordPress.wpDB.getMediaFilesForBlog(blogId, startDate.getTimeInMillis(), endDate.getTimeInMillis() + one_day);
    mGridAdapter.swapCursor(mCursor);
    if (mCursor != null && mCursor.getCount() > 0 && mGridAdapter != null) {
        mResultView.setVisibility(View.VISIBLE);
        SimpleDateFormat fmt = new SimpleDateFormat("String_Node_Str");
        fmt.setCalendar(startDate);
        String formattedStart = fmt.format(startDate.getTime());
        String formattedEnd = fmt.format(endDate.getTime());
        mResultView.setText("String_Node_Str" + formattedStart + "String_Node_Str" + formattedEnd);
    } else {
        mResultView.setVisibility(View.VISIBLE);
        mResultView.setText(getResources().getString(R.string.empty_fields));
    }
}

Output:
     long one_day = 24 * 60 * 60 * 1000;
-    mCursor = WordPress.wpDB.getMediaFilesForBlog(blogId, startDate.getTimeInMillis(), endDate.getTimeInMillis() + one_day);
-    mGridAdapter.swapCursor(mCursor);
-    if (mCursor != null && mCursor.getCount() > 0 && mGridAdapter != null) {
+    Cursor cursor = WordPress.wpDB.getMediaFilesForBlog(blogId, startDate.getTimeInMillis(), endDate.getTimeInMillis() + one_day);
+    mGridAdapter.swapCursor(cursor);
+    if (cursor != null && cursor.moveToFirst()) {
         mResultView.setVisibility(View.VISIBLE);


Input:
public static Cell parseCif(File cifFile) {
    String line = null;
    double la = 0, lb = 0, lc = 0, a = 0, b = 0, g = 0;
    List<Vect> latVects = null;
    List<Site> sites = new LinkedList<Site>();
    Boolean readingInAtoms = false;
    try {
        BufferedReader r = new BufferedReader(new FileReader(cifFile));
        while ((line = r.readLine()) != null) {
            StringTokenizer t = new StringTokenizer(line);
            if (!t.hasMoreTokens())
                continue;
            if (readingInAtoms) {
                String siteStr = t.nextToken();
                String symbol = siteStr.substring(1, 2).matches("String_Node_Str") ? siteStr.substring(0, 2) : siteStr.substring(0, 1);
                double x = Double.parseDouble(t.nextToken());
                double y = Double.parseDouble(t.nextToken());
                double z = Double.parseDouble(t.nextToken());
                sites.add(new Site(Element.getElemFromSymbol(symbol), new Vect(x, y, z, latVects)));
            } else {
                String firstWord = t.nextToken();
                if (firstWord.equals("String_Node_Str"))
                    la = Double.parseDouble(t.nextToken());
                else if (firstWord.equals("String_Node_Str"))
                    lb = Double.parseDouble(t.nextToken());
                else if (firstWord.equals("String_Node_Str"))
                    lc = Double.parseDouble(t.nextToken());
                else if (firstWord.equals("String_Node_Str"))
                    a = Math.toRadians(Double.parseDouble(t.nextToken()));
                else if (firstWord.equals("String_Node_Str"))
                    b = Math.toRadians(Double.parseDouble(t.nextToken()));
                else if (firstWord.equals("String_Node_Str"))
                    g = Math.toRadians(Double.parseDouble(t.nextToken()));
                else if (firstWord.equals("String_Node_Str")) {
                    readingInAtoms = true;
                    latVects = (new Cell(la, lb, lc, a, b, g, null, null)).getLatticeVectors();
                }
            }
        }
    } catch (FileNotFoundException x) {
        System.out.println("String_Node_Str" + cifFile.getAbsolutePath());
        return null;
    } catch (IOException y) {
        System.out.println("String_Node_Str" + cifFile.getAbsolutePath());
    }
    if (sites.size() == 0)
        return null;
    Cell answer = new Cell(latVects, sites);
    return answer;
}

Output:
                 String siteStr = t.nextToken();
-                String symbol = siteStr.substring(1, 2).matches("String_Node_Str") ? siteStr.substring(0, 2) : siteStr.substring(0, 1);
+                String symbol = null;
+                if (siteStr.length() < 2)
+                    symbol = siteStr;
+                else
+                    symbol = siteStr.substring(1, 2).matches("String_Node_Str") ? siteStr.substring(0, 2) : siteStr.substring(0, 1);
                 double x = Double.parseDouble(t.nextToken());


Input:
public void encodeEnd(FacesContext context, UIComponent component) throws IOException {
    if (!component.isRendered()) {
        return;
    }
    Tree tree = (Tree) component;
    String clientId = tree.getClientId();
    String jqClientId = BsfUtils.EscapeJQuerySpecialCharsInSelector(clientId);
    ResponseWriter rw = context.getResponseWriter();
    final UIForm form = BsfUtils.getClosestForm(tree);
    if (form == null) {
        throw new FacesException("String_Node_Str", null);
    }
    String updateItems = BsfUtils.GetOrDefault("String_Node_Str" + tree.getUpdate() + "String_Node_Str", "String_Node_Str");
    rw.startElement("String_Node_Str", tree);
    rw.writeText("String_Node_Str", null);
    rw.writeText("String_Node_Str" + "String_Node_Str" + TreeModelUtils.renderModelAsJson(tree.getValue(), tree.isRenderRoot()) + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + jqClientId + "String_Node_Str" + (tree.isShowTags() ? "String_Node_Str" : "String_Node_Str") + (tree.isShowIcon() ? "String_Node_Str" : "String_Node_Str") + (tree.isShowCheckbox() ? "String_Node_Str" : "String_Node_Str") + (tree.isEnableLinks() ? "String_Node_Str" : "String_Node_Str") + (BsfUtils.StringIsValued(tree.getCollapseIcon()) ? "String_Node_Str" + tree.getCollapseIcon() + "String_Node_Str" : "String_Node_Str") + (BsfUtils.StringIsValued(tree.getExpandIcon()) ? "String_Node_Str" + tree.getExpandIcon() + "String_Node_Str" : "String_Node_Str") + (BsfUtils.StringIsValued(tree.getColor()) ? "String_Node_Str" + tree.getColor() + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + jqClientId + "String_Node_Str" + "String_Node_Str" + updateItems + "String_Node_Str" + clientId + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + jqClientId + "String_Node_Str" + "String_Node_Str" + updateItems + "String_Node_Str" + clientId + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + jqClientId + "String_Node_Str" + "String_Node_Str" + updateItems + "String_Node_Str" + clientId + "String_Node_Str" + "String_Node_Str", null);
    rw.writeText("String_Node_Str", null);
    rw.endElement("String_Node_Str");
}

Output:
     }
-    String updateItems = BsfUtils.GetOrDefault("String_Node_Str" + tree.getUpdate() + "String_Node_Str", "String_Node_Str");
+    String updateItems = tree.getUpdate();
+    if (updateItems != null)
+        updateItems = ExpressionResolver.getComponentIDs(context, component, updateItems);
     rw.startElement("String_Node_Str", tree);


Input:
public void stop(Ticket ticket) throws IllegalActionException {
    try {
        if ((ticket == null) || (!_requests.containsKey(ticket))) {
            throw new Exception("String_Node_Str" + ticket.getTicketID());
        }
        _requests.get(ticket).getManager().stop();
    } catch (Exception e) {
        _handleException(ticket.getTicketID() + "String_Node_Str" + e.getMessage(), e);
    }
}

Output:
     try {
-        if ((ticket == null) || (!_requests.containsKey(ticket))) {
-            throw new Exception("String_Node_Str" + ticket.getTicketID());
+        if (ticket == null) {
+            throw new IllegalStateException("String_Node_Str" + null);
+        }
+        if (!_requests.containsKey(ticket)) {
+            throw new IllegalStateException("String_Node_Str" + ticket.getTicketID());
         }


Input:
private void readFormatV1(DataInputStream in) throws IOException {
    final Learner classifier = mClassifier;
    final HashMap<String, ArrayList<Gesture>> namedGestures = mNamedGestures;
    namedGestures.clear();
    final int entriesCount = in.readInt();
    for (int i = 0; i < entriesCount; i++) {
        final String name = in.readUTF();
        final int gestureCount = in.readInt();
        final ArrayList<Gesture> gestures = new ArrayList<Gesture>(gestureCount);
        for (int j = 0; j < gestureCount; j++) {
            final Gesture gesture = Gesture.deserialize(in);
            gestures.add(gesture);
            classifier.addInstance(Instance.createInstance(mSequenceType, mOrientationStyle, gesture, name));
        }
        namedGestures.put(name, gestures);
    }
}

Output:
             gestures.add(gesture);
-            classifier.addInstance(Instance.createInstance(mSequenceType, mOrientationStyle, gesture, name));
+            classifier.addInstance(Instance.createInstance(mSequenceType, gesture, name));
         }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_linechart);
    tvX = (TextView) findViewById(R.id.tvXMax);
    tvY = (TextView) findViewById(R.id.tvYMax);
    mSeekBarX = (SeekBar) findViewById(R.id.seekBar1);
    mSeekBarY = (SeekBar) findViewById(R.id.seekBar2);
    mSeekBarX.setProgress(45);
    mSeekBarY.setProgress(100);
    mSeekBarY.setOnSeekBarChangeListener(this);
    mSeekBarX.setOnSeekBarChangeListener(this);
    mChart = (LineChart) findViewById(R.id.chart1);
    mChart.setOnChartValueSelectedListener(this);
    mChart.setStartAtZero(true);
    mChart.setDrawYValues(true);
    mChart.setDrawBorder(true);
    mChart.setBorderPositions(new BorderPosition[] { BorderPosition.BOTTOM });
    mChart.setDescription("String_Node_Str");
    mChart.setInvertYAxisEnabled(true);
    mChart.setHighlightEnabled(true);
    mChart.setTouchEnabled(true);
    mChart.setDragEnabled(true);
    mChart.setPinchZoom(true);
    MyMarkerView mv = new MyMarkerView(this, R.layout.custom_marker_view);
    mv.setOffsets(-mv.getMeasuredWidth() / 2, -mv.getMeasuredHeight());
    mChart.setMarkerView(mv);
    mChart.setHighlightIndicatorEnabled(false);
    XLabels xl = mChart.getXLabels();
    xl.setAvoidFirstLastClipping(true);
    setData(25, 50);
    Legend l = mChart.getLegend();
    l.setForm(LegendForm.LINE);
    mChart.invalidate();
}

Output:
     mChart.setTouchEnabled(true);
-    mChart.setDragEnabled(true);
+    mChart.setDragScaleEnabled(false);
     mChart.setPinchZoom(true);


Input:
public static void square(int[] x, int xOff, int[] zz, int zzOff) {
    long x_0 = x[xOff + 0] & M;
    long zz_1;
    int c = 0, w;
    {
        int i = 6, j = 14;
        do {
            long xVal = (x[xOff + i--] & M);
            long p = xVal * xVal;
            zz[zzOff + --j] = (c << 31) | (int) (p >>> 33);
            zz[zzOff + --j] = (int) (p >>> 1);
            c = (int) p;
        } while (i > 0);
        {
            long p = x_0 * x_0;
            zz_1 = ((c << 31) & M) | (p >>> 33);
            zz[zzOff + 0] = (int) p;
            c = (int) (p >>> 32) & 1;
        }
    }
    long x_1 = x[xOff + 1] & M;
    long zz_2 = zz[zzOff + 2] & M;
    {
        zz_1 += x_1 * x_0;
        w = (int) zz_1;
        zz[zzOff + 1] = (w << 1) | c;
        c = w >>> 31;
        zz_2 += zz_1 >>> 32;
    }
    long x_2 = x[xOff + 2] & M;
    long zz_3 = zz[zzOff + 3] & M;
    long zz_4 = zz[zzOff + 4] & M;
    {
        zz_2 += x_2 * x_0;
        w = (int) zz_2;
        zz[zzOff + 2] = (w << 1) | c;
        c = w >>> 31;
        zz_3 += (zz_2 >>> 32) + x_2 * x_1;
        zz_4 += zz_3 >>> 32;
        zz_3 &= M;
    }
    long x_3 = x[xOff + 3] & M;
    long zz_5 = zz[zzOff + 5] & M;
    long zz_6 = zz[zzOff + 6] & M;
    {
        zz_3 += x_3 * x_0;
        w = (int) zz_3;
        zz[zzOff + 3] = (w << 1) | c;
        c = w >>> 31;
        zz_4 += (zz_3 >>> 32) + x_3 * x_1;
        zz_5 += (zz_4 >>> 32) + x_3 * x_2;
        zz_4 &= M;
        zz_6 += zz_5 >>> 32;
        zz_5 &= M;
    }
    long x_4 = x[xOff + 4] & M;
    long zz_7 = zz[zzOff + 7] & M;
    long zz_8 = zz[zzOff + 8] & M;
    {
        zz_4 += x_4 * x_0;
        w = (int) zz_4;
        zz[zzOff + 4] = (w << 1) | c;
        c = w >>> 31;
        zz_5 += (zz_4 >>> 32) + x_4 * x_1;
        zz_6 += (zz_5 >>> 32) + x_4 * x_2;
        zz_5 &= M;
        zz_7 += (zz_6 >>> 32) + x_4 * x_3;
        zz_6 &= M;
        zz_8 += zz_7 >>> 32;
        zz_7 &= M;
    }
    long x_5 = x[xOff + 5] & M;
    long zz_9 = zz[zzOff + 9] & M;
    long zz_10 = zz[zzOff + 10] & M;
    {
        zz_5 += x_5 * x_0;
        w = (int) zz_5;
        zz[zzOff + 5] = (w << 1) | c;
        c = w >>> 31;
        zz_6 += (zz_5 >>> 32) + x_5 * x_1;
        zz_7 += (zz_6 >>> 32) + x_5 * x_2;
        zz_6 &= M;
        zz_8 += (zz_7 >>> 32) + x_5 * x_3;
        zz_7 &= M;
        zz_9 += (zz_8 >>> 32) + x_5 * x_4;
        zz_8 &= M;
        zz_10 += zz_9 >>> 32;
        zz_9 &= M;
    }
    long x_6 = x[xOff + 6] & M;
    long zz_11 = zz[zzOff + 11] & M;
    long zz_12 = zz[zzOff + 12] & M;
    {
        zz_6 += x_6 * x_0;
        w = (int) zz_6;
        zz[zzOff + 6] = (w << 1) | c;
        c = w >>> 31;
        zz_7 += (zz_6 >>> 32) + x_6 * x_1;
        zz_8 += (zz_7 >>> 32) + x_6 * x_2;
        zz_9 += (zz_8 >>> 32) + x_6 * x_3;
        zz_10 += (zz_9 >>> 32) + x_6 * x_4;
        zz_11 += (zz_10 >>> 32) + x_6 * x_5;
        zz_12 += zz_11 >>> 32;
    }
    w = (int) zz_7;
    zz[zzOff + 7] = (w << 1) | c;
    c = w >>> 31;
    w = (int) zz_8;
    zz[zzOff + 8] = (w << 1) | c;
    c = w >>> 31;
    w = (int) zz_9;
    zz[zzOff + 9] = (w << 1) | c;
    c = w >>> 31;
    w = (int) zz_10;
    zz[zzOff + 10] = (w << 1) | c;
    c = w >>> 31;
    w = (int) zz_11;
    zz[zzOff + 11] = (w << 1) | c;
    c = w >>> 31;
    w = (int) zz_12;
    zz[zzOff + 12] = (w << 1) | c;
    c = w >>> 31;
    w = zz[zzOff + 13] + (int) (zz_12 >> 32);
    zz[zzOff + 13] = (w << 1) | c;
}

Output:
     long x_3 = x[xOff + 3] & M;
-    long zz_5 = zz[zzOff + 5] & M;
-    long zz_6 = zz[zzOff + 6] & M;
+    long zz_5 = (zz[zzOff + 5] & M) + (zz_4 >>> 32);
+    zz_4 &= M;
+    long zz_6 = (zz[zzOff + 6] & M) + (zz_5 >>> 32);
+    zz_5 &= M;
     {


Input:
protected void mouseClicked(int x, int y, int button) {
    Marker marker = this.getMarkerNearScreenPos(x, y);
    Marker prevMarker = this.mw.markerManager.selectedMarker;
    if (button == 0) {
        if (this.dimensionLabel.posWithin(x, y)) {
            if (this.currentTextDialog == null) {
                this.currentTextDialog = new DimensionTextDialog(this.mapView.getDimension());
            }
        } else if (this.optionsLabel.posWithin(x, y)) {
            this.mc.displayGuiScreen(new MwGuiOptions(this.mw, this));
        } else {
            this.mouseLeftHeld = 1;
            this.mouseLeftDragStartX = x;
            this.mouseLeftDragStartY = y;
            this.mw.markerManager.selectedMarker = marker;
            if ((marker != null) && (prevMarker == marker)) {
                this.movingMarker = marker;
                this.movingMarkerXStart = marker.x;
                this.movingMarkerZStart = marker.z;
            }
        }
    } else if (button == 1) {
        this.mouseRightHeld = 1;
        if (this.currentTextDialog == null) {
            if ((marker != null) && (prevMarker == marker)) {
                this.currentTextDialog = new MarkerTextDialog(this.mw.markerManager, marker);
            } else if (marker == null) {
                String group = this.mw.markerManager.getVisibleGroupName();
                if (group.equals("String_Node_Str")) {
                    group = "String_Node_Str";
                }
                int scale = 1;
                if (this.mapView.getDimension() == -1) {
                    scale = 8;
                }
                this.currentTextDialog = new MarkerTextDialog(this.mw.markerManager, "String_Node_Str", group, this.mouseBlockX * scale, (this.mouseBlockY > 0) ? this.mouseBlockY : this.mw.defaultTeleportHeight, this.mouseBlockZ * scale);
            }
        }
    }
    this.viewXStart = this.mapView.getX();
    this.viewZStart = this.mapView.getZ();
}

Output:
                 }
-                int scale = 1;
-                if (this.mapView.getDimension() == -1) {
-                    scale = 8;
+                int mx, my, mz;
+                if (this.isPlayerNearScreenPos(x, y)) {
+                    int scale = 1;
+                    if (this.mw.playerDimension == -1) {
+                        scale = 8;
+                    }
+                    mx = this.mw.playerXInt;
+                    my = this.mw.playerYInt;
+                    mz = this.mw.playerZInt;
+                } else {
+                    int scale = 1;
+                    if (this.mapView.getDimension() == -1) {
+                        scale = 8;
+                    }
+                    mx = this.mouseBlockX * scale;
+                    my = (this.mouseBlockY > 0) ? this.mouseBlockY : this.mw.defaultTeleportHeight;
+                    mz = this.mouseBlockZ * scale;
                 }


Input:
public Class classFromRow(AbstractRecord rowFromDatabase, AbstractSession session) throws DescriptorException {
    ((XMLRecord) rowFromDatabase).setSession(session);
    boolean namespaceAware = ((XMLRecord) rowFromDatabase).isNamespaceAware();
    if (hasClassExtractor() || shouldUseClassNameAsIndicator()) {
        return super.classFromRow(rowFromDatabase, session);
    }
    Object indicator = rowFromDatabase.get(getClassIndicatorField());
    if (indicator == AbstractRecord.noEntry) {
        return null;
    }
    if (indicator == null) {
        return null;
    }
    Class concreteClass;
    if (indicator instanceof String) {
        String indicatorValue = (String) indicator;
        int index = indicatorValue.indexOf(((XMLRecord) rowFromDatabase).getNamespaceSeparator());
        if (index == -1) {
            if (namespaceAware) {
                String uri = ((XMLRecord) rowFromDatabase).resolveNamespacePrefix(null);
                if (uri == null) {
                    concreteClass = (Class) this.classIndicatorMapping.get(new XPathQName(((XMLRecord) rowFromDatabase).getNamespaceResolver().getDefaultNamespaceURI(), indicatorValue, namespaceAware));
                } else {
                    XPathQName qname = new XPathQName(uri, indicatorValue, namespaceAware);
                    concreteClass = (Class) this.classIndicatorMapping.get(qname);
                }
            } else {
                XPathQName qname = new XPathQName(indicatorValue, namespaceAware);
                concreteClass = (Class) this.classIndicatorMapping.get(qname);
            }
        } else {
            String prefix = indicatorValue.substring(0, index);
            String localPart = indicatorValue.substring(index + 1);
            String uri = ((XMLRecord) rowFromDatabase).resolveNamespacePrefix(prefix);
            if (uri != null) {
                XPathQName qname = new XPathQName(uri, localPart, namespaceAware);
                concreteClass = (Class) this.classIndicatorMapping.get(qname);
            } else {
                concreteClass = (Class) this.classIndicatorMapping.get(indicatorValue);
            }
        }
    } else {
        concreteClass = (Class) this.classIndicatorMapping.get(indicator);
    }
    if (concreteClass == null) {
        throw DescriptorException.missingClassForIndicatorFieldValue(indicator, getDescriptor());
    }
    return concreteClass;
}

Output:
         if (index == -1) {
-            if (namespaceAware) {
+            if (namespaceAware && usesXsiType) {
                 String uri = ((XMLRecord) rowFromDatabase).resolveNamespacePrefix(null);


Input:
public void dumpLocked(PrintWriter pw, String reqPackage, long now, boolean dumpSummary, boolean dumpAll) {
    long totalTime = dumpSingleTime(null, null, mMemFactorDurations, mMemFactor, mStartTime, now);
    ArrayMap<String, SparseArray<PackageState>> pkgMap = mPackages.getMap();
    boolean printedHeader = false;
    for (int ip = 0; ip < pkgMap.size(); ip++) {
        String pkgName = pkgMap.keyAt(ip);
        if (reqPackage != null && !reqPackage.equals(pkgName)) {
            continue;
        }
        SparseArray<PackageState> uids = pkgMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            int uid = uids.keyAt(iu);
            PackageState pkgState = uids.valueAt(iu);
            final int NPROCS = pkgState.mProcesses.size();
            final int NSRVS = pkgState.mServices.size();
            if (NPROCS > 0 || NSRVS > 0) {
                if (!printedHeader) {
                    pw.println("String_Node_Str");
                    printedHeader = true;
                }
                pw.print("String_Node_Str");
                pw.print(pkgName);
                pw.print("String_Node_Str");
                UserHandle.formatUid(pw, uid);
                pw.println("String_Node_Str");
            }
            if (!dumpSummary || dumpAll) {
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    ProcessState proc = pkgState.mProcesses.valueAt(iproc);
                    pw.print("String_Node_Str");
                    pw.print(pkgState.mProcesses.keyAt(iproc));
                    pw.print("String_Node_Str");
                    pw.print(proc.mDurationsTableSize);
                    pw.print("String_Node_Str");
                    pw.println("String_Node_Str");
                    dumpProcessState(pw, "String_Node_Str", proc, ALL_SCREEN_ADJ, ALL_MEM_ADJ, ALL_PROC_STATES, now);
                    dumpProcessPss(pw, "String_Node_Str", proc, ALL_SCREEN_ADJ, ALL_MEM_ADJ, ALL_PROC_STATES);
                    dumpProcessInternalLocked(pw, "String_Node_Str", proc, dumpAll);
                }
            } else {
                ArrayList<ProcessState> procs = new ArrayList<ProcessState>();
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    procs.add(pkgState.mProcesses.valueAt(iproc));
                }
                dumpProcessSummaryLocked(pw, "String_Node_Str", procs, ALL_SCREEN_ADJ, ALL_MEM_ADJ, NON_CACHED_PROC_STATES, now, totalTime);
            }
            for (int isvc = 0; isvc < NSRVS; isvc++) {
                if (dumpAll) {
                    pw.print("String_Node_Str");
                } else {
                    pw.print("String_Node_Str");
                }
                pw.print(pkgState.mServices.keyAt(isvc));
                pw.println("String_Node_Str");
                ServiceState svc = pkgState.mServices.valueAt(isvc);
                pw.print("String_Node_Str");
                pw.println(svc.mProcessName);
                dumpServiceStats(pw, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", svc, svc.mRunCount, ServiceState.SERVICE_RUN, svc.mRunState, svc.mRunStartTime, now, totalTime, !dumpSummary || dumpAll);
                dumpServiceStats(pw, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", svc, svc.mStartedCount, ServiceState.SERVICE_STARTED, svc.mStartedState, svc.mStartedStartTime, now, totalTime, !dumpSummary || dumpAll);
                dumpServiceStats(pw, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", svc, svc.mBoundCount, ServiceState.SERVICE_BOUND, svc.mBoundState, svc.mBoundStartTime, now, totalTime, !dumpSummary || dumpAll);
                dumpServiceStats(pw, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", svc, svc.mExecCount, ServiceState.SERVICE_EXEC, svc.mExecState, svc.mExecStartTime, now, totalTime, !dumpSummary || dumpAll);
                if (dumpAll) {
                    pw.print("String_Node_Str");
                    pw.println(svc.mActive);
                }
            }
        }
    }
    if (reqPackage == null) {
        ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();
        printedHeader = false;
        int numShownProcs = 0, numTotalProcs = 0;
        for (int ip = 0; ip < procMap.size(); ip++) {
            String procName = procMap.keyAt(ip);
            SparseArray<ProcessState> uids = procMap.valueAt(ip);
            for (int iu = 0; iu < uids.size(); iu++) {
                int uid = uids.keyAt(iu);
                numTotalProcs++;
                ProcessState proc = uids.valueAt(iu);
                if (proc.mDurationsTableSize == 0 && proc.mCurState == STATE_NOTHING && proc.mPssTableSize == 0) {
                    continue;
                }
                numShownProcs++;
                if (!printedHeader) {
                    pw.println();
                    pw.println("String_Node_Str");
                    printedHeader = true;
                }
                pw.print("String_Node_Str");
                pw.print(procName);
                pw.print("String_Node_Str");
                UserHandle.formatUid(pw, uid);
                pw.print("String_Node_Str");
                pw.print(proc.mDurationsTableSize);
                pw.print("String_Node_Str");
                pw.println("String_Node_Str");
                dumpProcessState(pw, "String_Node_Str", proc, ALL_SCREEN_ADJ, ALL_MEM_ADJ, ALL_PROC_STATES, now);
                dumpProcessPss(pw, "String_Node_Str", proc, ALL_SCREEN_ADJ, ALL_MEM_ADJ, ALL_PROC_STATES);
                if (dumpAll) {
                    dumpProcessInternalLocked(pw, "String_Node_Str", proc, dumpAll);
                }
            }
        }
        if (dumpAll) {
            pw.println();
            pw.print("String_Node_Str");
            pw.print(numShownProcs);
            pw.print("String_Node_Str");
            pw.print(numTotalProcs);
            pw.println("String_Node_Str");
        }
        pw.println();
        if (dumpSummary) {
            pw.println("String_Node_Str");
            dumpSummaryLocked(pw, reqPackage, now);
        } else {
            dumpTotalsLocked(pw, now);
        }
    } else {
        pw.println();
        dumpTotalsLocked(pw, now);
    }
    if (dumpAll) {
        pw.println();
        pw.println("String_Node_Str");
        pw.print("String_Node_Str");
        pw.println(mLongs.size());
        pw.print("String_Node_Str");
        pw.println(mNextLong);
        pw.print("String_Node_Str");
        pw.println(mRunning);
    }
}

Output:
                 for (int iproc = 0; iproc < NPROCS; iproc++) {
-                    procs.add(pkgState.mProcesses.valueAt(iproc));
+                    ProcessState proc = pkgState.mProcesses.valueAt(iproc);
+                    if (activeOnly && !proc.isInUse()) {
+                        continue;
+                    }
+                    procs.add(proc);
                 }


Input:
public List<Long> getResources(final String theUuid, int theFrom, int theTo) {
    if (myNeverUseLocalSearchForUnitTests == false) {
        SearchTask task = myIdToSearchTask.get(theUuid);
        if (task != null) {
            return task.getResourcePids(theFrom, theTo);
        }
    }
    Search search;
    StopWatch sw = new StopWatch();
    while (true) {
        TransactionTemplate txTemplate = new TransactionTemplate(myTxManager);
        txTemplate.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
        search = txTemplate.execute(new TransactionCallback<Search>() {
            public Search doInTransaction(TransactionStatus theStatus) {
                return mySearchDao.findByUuid(theUuid);
            }
        });
        if (search == null) {
            ourLog.info("String_Node_Str", theUuid);
            String msg = myContext.getLocalizer().getMessage(PageMethodBinding.class, "String_Node_Str", theUuid);
            throw new ResourceGoneException(msg);
        }
        verifySearchHasntFailedOrThrowInternalErrorException(search);
        if (search.getStatus() == SearchStatusEnum.FINISHED) {
            ourLog.info("String_Node_Str");
            break;
        }
        if (search.getNumFound() >= theTo) {
            ourLog.info("String_Node_Str", search.getNumFound());
            break;
        }
        if (sw.getMillis() > myMaxMillisToWaitForRemoteResults) {
            throw new InternalErrorException("String_Node_Str" + sw.getMillis() + "String_Node_Str");
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
        }
    }
    Pageable page = toPage(theFrom, theTo);
    if (page == null) {
        return Collections.emptyList();
    }
    Page<SearchResult> searchResults = mySearchResultDao.findWithSearchUuid(search, page);
    List<Long> retVal = new ArrayList<Long>();
    for (SearchResult next : searchResults) {
        retVal.add(next.getResourcePid());
    }
    return retVal;
}

Output:
     }
-    Pageable page = toPage(theFrom, theTo);
+    final Pageable page = toPage(theFrom, theTo);
     if (page == null) {


Input:
public static ClassInfo getTestClassInfoFromTargetClass(IFile javaFile) throws Exception {
    IPreferenceStore store = Activator.getDefault().getPreferenceStore();
    ClassInfo classInfo = new ClassInfo();
    List<MethodInfo> testMethods = new ArrayList<MethodInfo>();
    boolean enabled = store.getBoolean(Preference.TestMethodGen.ENABLE);
    if (!enabled) {
        return classInfo;
    }
    boolean enabledArgs = store.getBoolean(Preference.TestMethodGen.ARGS);
    boolean enabledReturn = store.getBoolean(Preference.TestMethodGen.RETURN);
    boolean enabledNotBlankMethods = store.getBoolean(Preference.TestMethodGen.METHOD_SAMPLE_IMPL);
    boolean enableExcludesAccessors = store.getBoolean(Preference.TestMethodGen.EXLCUDES_ACCESSORS);
    boolean enabledSupportJMock2 = MockGenUtil.isUsingJMock2(store);
    boolean enabledSupportEasyMock = MockGenUtil.isUsingEasyMock(store);
    String delimiter = store.getString(Preference.TestMethodGen.DELIMITER);
    String argsPrefix = store.getString(Preference.TestMethodGen.ARGS_PREFIX);
    String argsDelimiter = store.getString(Preference.TestMethodGen.ARGS_DELIMITER);
    String returnPrefix = store.getString(Preference.TestMethodGen.RETURN_PREFIX);
    String returnDelimiter = store.getString(Preference.TestMethodGen.RETURN_DELIMITER);
    InputStream is = null;
    InputStreamReader isr = null;
    BufferedReader br = null;
    try {
        String encoding = FileResourceUtil.detectEncoding(javaFile);
        is = javaFile.getContents();
        isr = new InputStreamReader(is, encoding);
        br = new BufferedReader(isr);
        StringBuilder tmpsb = new StringBuilder();
        String line = null;
        while ((line = br.readLine()) != null) tmpsb.append(line + "String_Node_Str");
        String targetClassSourceStr = tmpsb.toString();
        if (enabledNotBlankMethods) {
            if (testMethods.size() <= 0 || testMethods.get(0) == null)
                testMethods.add(new MethodInfo());
            String[] importStartLines = targetClassSourceStr.split("String_Node_Str");
            for (String importStartLine : importStartLines) {
                if (!importStartLine.matches("String_Node_Str")) {
                    String importedPackage = importStartLine.split("String_Node_Str")[0];
                    classInfo.importList.add(importedPackage);
                }
            }
            if (enabledSupportJMock2) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
            if (enabledSupportEasyMock) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
        }
        String[] targets = targetClassSourceStr.split("String_Node_Str");
        for (String target : targets) {
            target = target.replaceAll("String_Node_Str" + STR.COMMA, STR.COMMA).replaceAll(STR.COMMA + "String_Node_Str", STR.COMMA).replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", "String_Node_Str");
            if (target.matches(RXP_SEARCH_METHOD)) {
                Matcher matcher = PAT_SEARCH_GROUP_METHOD.matcher(target);
                if (matcher.find()) {
                    MethodInfo each = new MethodInfo();
                    if (enabledNotBlankMethods || enabledReturn) {
                        String returnTypeFull = getType(matcher.group(1));
                        Matcher toGenericsMatcher = Pattern.compile(RXP_GENERICS_PART_GROUP).matcher(returnTypeFull);
                        while (toGenericsMatcher.find()) {
                            String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", STR.EMPTY).replaceAll("String_Node_Str", STR.EMPTY).split("String_Node_Str");
                            for (String generic : generics) {
                                generic = getClassInSourceCode(generic, STR.EMPTY, new ArrayList<String>());
                                each.returnType.generics.add(generic);
                            }
                        }
                        each.returnType.name = returnTypeFull.replace(RXP_GENERICS_PART, STR.EMPTY);
                        each.returnType.nameInMethodName = getTypeAvailableInMethodName(each.returnType.name);
                    }
                    each.methodName = matcher.group(2);
                    String args = matcher.group(3);
                    String[] tmpArr = args.split("String_Node_Str");
                    int tmpArrLen = tmpArr.length;
                    List<String> tmpArrList = new ArrayList<String>();
                    String buf = STR.EMPTY;
                    for (int i = 0; i < tmpArrLen; i++) {
                        String element = tmpArr[i].trim();
                        if (element.matches("String_Node_Str")) {
                            tmpArrList.add(element);
                            continue;
                        }
                        if (element.matches("String_Node_Str")) {
                            buf += element;
                            continue;
                        }
                        if (element.matches("String_Node_Str")) {
                            String result = buf + STR.COMMA + element;
                            tmpArrList.add(result);
                            buf = STR.EMPTY;
                            continue;
                        }
                        if (!buf.equals(STR.EMPTY)) {
                            buf += STR.COMMA + element;
                            continue;
                        }
                        tmpArrList.add(element);
                    }
                    String[] argArr = tmpArrList.toArray(new String[0]);
                    if (enabledNotBlankMethods || enabledArgs) {
                        int argArrLen = argArr.length;
                        for (int i = 0; i < argArrLen; i++) {
                            ArgType argType = new ArgType();
                            String argTypeFull = argArr[i];
                            Matcher toGenericsMatcher = Pattern.compile(RXP_GENERICS_PART_GROUP).matcher(argTypeFull);
                            while (toGenericsMatcher.find()) {
                                String[] generics = toGenericsMatcher.group().replaceAll("String_Node_Str", STR.EMPTY).replaceAll("String_Node_Str", STR.EMPTY).split("String_Node_Str");
                                for (String generic : generics) {
                                    generic = getClassInSourceCode(generic, STR.EMPTY, new ArrayList<String>());
                                    argType.generics.add(generic);
                                }
                            }
                            String argTypeStr = argTypeFull.replaceAll(RXP_GENERICS_PART, STR.EMPTY);
                            argType.name = getType(argTypeStr);
                            argType.nameInMethodName = getTypeAvailableInMethodName(argTypeStr);
                            each.argTypes.add(argType);
                        }
                    }
                    if (enableExcludesAccessors) {
                        String fieldName = null;
                        String fieldType = null;
                        if (each.methodName.matches("String_Node_Str")) {
                            if (each.argTypes.size() == 0)
                                continue;
                            fieldName = each.methodName.substring(3);
                            fieldType = each.argTypes.get(0).name;
                        } else if (each.methodName.matches("String_Node_Str")) {
                            fieldName = each.methodName.substring(3);
                            fieldType = each.returnType.name;
                        } else if (each.methodName.matches("String_Node_Str")) {
                            fieldName = each.methodName.substring(2);
                            fieldType = each.returnType.name;
                        }
                        if (fieldName != null) {
                            fieldName = fieldName.substring(0, 1).toLowerCase() + fieldName.substring(1);
                            String searchRegexp = "String_Node_Str" + fieldType + "String_Node_Str" + fieldName + "String_Node_Str";
                            if (targetClassSourceStr.matches(searchRegexp))
                                continue;
                        }
                    }
                    each.testMethodName = "String_Node_Str" + each.methodName;
                    if (enabledArgs) {
                        each.testMethodName += delimiter + argsPrefix;
                        if (each.argTypes.size() == 0)
                            each.testMethodName += argsDelimiter;
                        for (ArgType argType : each.argTypes) each.testMethodName += argsDelimiter + argType.nameInMethodName;
                    }
                    if (enabledReturn)
                        each.testMethodName += delimiter + returnPrefix + returnDelimiter + each.returnType.nameInMethodName;
                    if (target.matches(RXP_SEARCH_STATIC_METHOD))
                        each.isStatic = true;
                    testMethods.add(each);
                }
            }
        }
    } finally {
        FileResourceUtil.close(br);
        FileResourceUtil.close(isr);
        FileResourceUtil.close(is);
    }
    classInfo.methods = testMethods;
    return classInfo;
}

Output:
                             fieldName = each.methodName.substring(3);
-                            fieldType = each.argTypes.get(0).name;
+                            if (each.argTypes.size() > 0) {
+                                fieldType = each.argTypes.get(0).name;
+                            }
                         } else if (each.methodName.matches("String_Node_Str")) {


Input:
public void setGrossValue(long grossValue) {
    triggerGrossValue(grossValue);
    if (shares != 0) {
        BigDecimal newQuote = new BigDecimal(grossValue * Values.Share.factor() / (shares * Values.Amount.divider()));
        firePropertyChange(Properties.quote.name(), this.quote, this.quote = newQuote);
    }
    firePropertyChange(Properties.calculationStatus.name(), this.calculationStatus, this.calculationStatus = calculateStatus());
}

Output:
     if (shares != 0) {
-        BigDecimal newQuote = new BigDecimal(grossValue * Values.Share.factor() / (shares * Values.Amount.divider()));
+        BigDecimal newQuote = BigDecimal.valueOf(grossValue * Values.Share.factor() / (shares * Values.Amount.divider()));
         firePropertyChange(Properties.quote.name(), this.quote, this.quote = newQuote);


Input:
protected void tearDown() throws Exception {
    if (connection != null) {
        if (shouldRollBack()) {
            connection.rollback();
        }
    }
    super.tearDown();
}

Output:
 protected void tearDown() throws Exception {
-    if (connection != null) {
+    if (database != null) {
         if (shouldRollBack()) {


Input:
public void testImplementingInterface4() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testImplementingInterface4() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
private void waitAllPlayers(int playerIndex) {
    synchronized (this) {
        wait_count += 1;
        if (wait_count < playerNum) {
            while (wait_count < playerNum) {
                try {
                    this.wait();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        } else {
            playerState[playerIndex] = 0;
            seen_card_count = 0;
            gamble_count = 0;
            desert_count = 0;
            for (int i = 0; i < playerNum; i++) {
                allPlayers[i].stratDecision = GambleChecker.DEPOSIT;
                allPlayers[i].fireTarget = -1;
                allPlayers[i].moveDirection = -1;
                availableFireTarget[i] = -1;
                availableMoveDirection[i] = -1;
                decisionChoices[i] = GambleChecker.DEPOSIT;
                seenCardChoices[i] = 0;
                gambleChoices[i] = GambleChecker.PAPER;
                cardNumList[i] = 0;
                playerWinList[i] = 0;
                fireList[i] = -1;
            }
            this.notifyAll();
        }
    }
}

Output:
         } else {
-            playerState[playerIndex] = 0;
+            phaseState = PhaseState.PREPARE;
             seen_card_count = 0;


Input:
public void addValue(Data value) {
    if (value != null) {
        if (getMultiValues() == null) {
            setMultiValues(new ConcurrentHashSet<Data>() {
                public boolean add(Data e) {
                    return e != null && super.add(e);
                }
            });
        }
        getMultiValues().add(value);
    }
}

Output:
         }
-        getMultiValues().add(value);
+        getMultiValues().add(new ValueHolder(value));
     }


Input:
public static void spawnObject(Location location, String object) {
    if (object == "String_Node_Str") {
        if (world.generateTree(location, TreeType.values()[random(0, TreeType.values().length)])) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else if (object == "String_Node_Str") {
        if (world.spawnBoat(location) != null) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else if (object == "String_Node_Str") {
        if (world.spawnMinecart(location) != null) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else if (object == "String_Node_Str") {
        if (world.spawnPoweredMinecart(location) != null) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else if (object == "String_Node_Str") {
        if (world.spawnStorageMinecart(location) != null) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else if (object == "String_Node_Str") {
        if (world.strikeLightning(location) != null) {
            log.info("String_Node_Str");
        } else {
            log.severe("String_Node_Str");
        }
    } else {
        log.severe("String_Node_Str");
    }
}

Output:
 public static void spawnObject(Location location, String object) {
-    if (object == "String_Node_Str") {
-        if (world.generateTree(location, TreeType.values()[random(0, TreeType.values().length)])) {
+    if (object.trim().equalsIgnoreCase("String_Node_Str")) {
+        if (world.generateTree(location, TreeType.values()[random(0, TreeType.values().length - 1)])) {
             log.info("String_Node_Str");


Input:
public static void updateDeploymentPolicy(org.apache.stratos.rest.endpoint.bean.autoscaler.policy.deployment.DeploymentPolicy deploymentPolicyBean) throws RestAPIException {
    log.info(String.format("String_Node_Str", deploymentPolicyBean.getId()));
    AutoscalerServiceClient autoscalerServiceClient = getAutoscalerServiceClient();
    if (autoscalerServiceClient != null) {
        org.apache.stratos.autoscaler.stub.policy.model.DeploymentPolicy deploymentPolicy = PojoConverter.convetToCCDeploymentPolicyPojo(deploymentPolicyBean);
        try {
            autoscalerServiceClient.updateDeploymentPolicy(deploymentPolicy);
        } catch (RemoteException e) {
            log.error(e.getMessage(), e);
            throw new RestAPIException(e.getMessage(), e);
        } catch (AutoScalerServiceInvalidPolicyExceptionException e) {
            String message = e.getFaultMessage().getInvalidPolicyException().getMessage();
            log.error(message, e);
            throw new RestAPIException(message, e);
        }
    }
}

Output:
     if (autoscalerServiceClient != null) {
-        org.apache.stratos.autoscaler.stub.policy.model.DeploymentPolicy deploymentPolicy = PojoConverter.convetToCCDeploymentPolicyPojo(deploymentPolicyBean);
+        org.apache.stratos.autoscaler.stub.deployment.policy.DeploymentPolicy deploymentPolicy = PojoConverter.convetToCCDeploymentPolicyPojo(deploymentPolicyBean);
         try {


Input:
private void createNestedTermAggregation(ProjectParsed queryData, Collection<Selector> groupingSelectors) throws ExecutionException {
    Select select = queryData.getSelect();
    OrderBy orderBy = queryData.getOrderBy();
    Integer limit = null;
    Integer internalLimit = 10;
    if (queryData.getLimit() != null) {
        internalLimit = limit = queryData.getLimit().getLimit();
    }
    if (groupingSelectors.size() > 1 && orderBy != null && !orderBy.getIds().isEmpty()) {
        for (OrderByClause clause : orderBy.getIds()) {
            if (clause.getSelector() instanceof FunctionSelector) {
                internalLimit = 0;
                break;
            }
        }
    }
    Map<String, OrderByClause> orderByMap = new HashMap<>();
    if (orderBy != null && !orderBy.getIds().isEmpty()) {
        for (OrderByClause clause : orderBy.getIds()) {
            orderByMap.put(SelectorUtils.calculateAlias(clause.getSelector()), clause);
        }
    }
    AggregationBuilder aggregationBuilder = null;
    AggregationBuilder lastAggregationBuilder = null;
    for (Selector term : groupingSelectors) {
        String fieldName = SelectorUtils.getSelectorFieldName(term);
        if (aggregationBuilder == null) {
            lastAggregationBuilder = aggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
            if (limit != null) {
                ((TermsBuilder) lastAggregationBuilder).size(limit);
            }
            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
        } else {
            lastAggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
            ((TermsBuilder) lastAggregationBuilder).size(internalLimit);
            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
            aggregationBuilder.subAggregation(lastAggregationBuilder);
        }
    }
    if (aggregationBuilder != null) {
        for (Selector selector : select.getColumnMap().keySet()) {
            if (SelectorUtils.isFunction(selector, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
                FunctionSelector functionSelector = (FunctionSelector) selector;
                String fieldName = SelectorUtils.calculateAlias(selector);
                if (orderByMap.containsKey(fieldName)) {
                    boolean asc = orderByMap.get(fieldName).getDirection().equals(OrderDirection.ASC);
                    ((TermsBuilder) lastAggregationBuilder).order(Terms.Order.aggregation(fieldName, asc));
                }
                lastAggregationBuilder.subAggregation(buildAggregation((FunctionSelector) selector, functionSelector.getFunctionName().toLowerCase()));
            }
        }
    }
    requestBuilder.addAggregation(aggregationBuilder);
    requestBuilder.setSize(0);
}

Output:
     }
-    Map<String, OrderByClause> orderByMap = new HashMap<>();
-    if (orderBy != null && !orderBy.getIds().isEmpty()) {
-        for (OrderByClause clause : orderBy.getIds()) {
-            orderByMap.put(SelectorUtils.calculateAlias(clause.getSelector()), clause);
-        }
-    }
-    AggregationBuilder aggregationBuilder = null;
-    AggregationBuilder lastAggregationBuilder = null;
-    for (Selector term : groupingSelectors) {
-        String fieldName = SelectorUtils.getSelectorFieldName(term);
-        if (aggregationBuilder == null) {
-            lastAggregationBuilder = aggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
-            if (limit != null) {
-                ((TermsBuilder) lastAggregationBuilder).size(limit);
-            }
-            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
-        } else {
-            lastAggregationBuilder = AggregationBuilders.terms(fieldName).field(fieldName);
-            ((TermsBuilder) lastAggregationBuilder).size(internalLimit);
-            sortSubAggregation(fieldName, orderByMap, (TermsBuilder) lastAggregationBuilder);
-            aggregationBuilder.subAggregation(lastAggregationBuilder);
-        }
-    }
-    if (aggregationBuilder != null) {
-        for (Selector selector : select.getColumnMap().keySet()) {
-            if (SelectorUtils.isFunction(selector, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
-                FunctionSelector functionSelector = (FunctionSelector) selector;
-                String fieldName = SelectorUtils.calculateAlias(selector);
-                if (orderByMap.containsKey(fieldName)) {
-                    boolean asc = orderByMap.get(fieldName).getDirection().equals(OrderDirection.ASC);
-                    ((TermsBuilder) lastAggregationBuilder).order(Terms.Order.aggregation(fieldName, asc));
-                }
-                lastAggregationBuilder.subAggregation(buildAggregation((FunctionSelector) selector, functionSelector.getFunctionName().toLowerCase()));
-            }
-        }
-    }
+    AggregationBuilder aggregationBuilder = buildAggregationBuilder(groupingSelectors, limit, internalLimit, queryData);
     requestBuilder.addAggregation(aggregationBuilder);


Input:
private void checkError(Throwable e) {
    if (e instanceof UnauthorizedException) {
        onErrorUnauthorized();
    } else {
        onGenericError();
    }
}

Output:
         onErrorUnauthorized();
-    } else {
+    } else if (!(e instanceof TwoFactorAppException || e instanceof TwoFactorAuthException)) {
         onGenericError();


Input:
protected void verifyEjbUserResponse(String response, String ejbBean, String ejbBeanMethod, String getEjbUserPrincipal) {
    Log.info(logClass, "String_Node_Str", "String_Node_Str" + ejbBean + "String_Node_Str" + ejbBeanMethod + "String_Node_Str" + getEjbUserPrincipal);
    mustContain(response, ejbBean);
    mustContain(response, ejbBeanMethod);
    mustContain(response, getEjbUserPrincipal);
}

Output:
     mustContain(response, ejbBeanMethod);
-    mustContain(response, getEjbUserPrincipal);
+    mustContain(response, getEjbRemoteUser);
 }


Input:
void fillQuickActionMenu(final QuickAction qa, final EditorView view) {
    ActionItem changeData = new ActionItem();
    changeData.setTitle("String_Node_Str");
    changeData.setIcon(mContext.getResources().getDrawable(R.drawable.production));
    changeData.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            ChangeDataDialogServiceRequest changeDataDialog = new ChangeDataDialogServiceRequest(mContext, view, ServiceRequest.this);
            changeDataDialog.show();
            qa.dismiss();
        }
    });
    qa.addActionItem(changeData);
    ActionItem bigLoop = new ActionItem();
    bigLoop.setTitle("String_Node_Str");
    bigLoop.setIcon(mContext.getResources().getDrawable(R.drawable.production));
    bigLoop.setOnClickListener(new OnClickListener() {

        public void onClick(View v) {
            view.setCreateLoopState(mId);
            qa.dismiss();
        }
    });
    qa.addActionItem(bigLoop);
    fillCommonQuickactionItems(qa, view);
}

Output:
     qa.addActionItem(changeData);
-    ActionItem bigLoop = new ActionItem();
-    bigLoop.setTitle("String_Node_Str");
-    bigLoop.setIcon(mContext.getResources().getDrawable(R.drawable.production));
-    bigLoop.setOnClickListener(new OnClickListener() {
+    if (mLoop == null) {
+        ActionItem bigLoop = new ActionItem();
+        bigLoop.setTitle("String_Node_Str");
+        bigLoop.setIcon(mContext.getResources().getDrawable(R.drawable.production));
+        bigLoop.setOnClickListener(new OnClickListener() {


Input:
private Plan buildPlanWithReadableSinks() {
    final Collection<FileDataSink> existingSinks = this.getDataSinks();
    final Collection<GenericDataSink> wrappedSinks = new ArrayList<GenericDataSink>();
    for (final FileDataSink fileSink : existingSinks) if (!fileSink.getFormatClass().equals(SequentialOutputFormat.class)) {
        TestPairs expectedValues = this.expectedOutputs.get(fileSink);
        if (expectedValues == null)
            continue;
        final FileDataSink safeSink = createDefaultSink(fileSink.getName());
        safeSink.setInputs(fileSink.getInputs());
        wrappedSinks.add(fileSink);
        wrappedSinks.add(safeSink);
        this.expectedOutputs.put(safeSink, expectedValues);
        this.actualOutputs.put(safeSink, this.getActualOutput(fileSink));
        this.getActualOutput(fileSink).fromFile(SequentialInputFormat.class, safeSink.getFilePath());
    } else {
        wrappedSinks.add(fileSink);
        this.getActualOutput(fileSink).fromFile(SequentialInputFormat.class, fileSink.getFilePath());
    }
    return new Plan(wrappedSinks);
}

Output:
     for (final FileDataSink fileSink : existingSinks) if (!fileSink.getFormatClass().equals(SequentialOutputFormat.class)) {
-        TestPairs expectedValues = this.expectedOutputs.get(fileSink);
+        TestRecords expectedValues = this.expectedOutputs.get(fileSink);
         if (expectedValues == null)