Input:
Object doReadObject(int leadByte, final boolean unshared) throws IOException, ClassNotFoundException {
    depth++;
    try {
        for (; ; ) switch(leadByte) {
            case ID_NULL:
                {
                    return null;
                }
            case ID_REPEAT_OBJECT_FAR:
                {
                    if (unshared) {
                        throw new InvalidObjectException("String_Node_Str");
                    }
                    final int index = readInt();
                    try {
                        final Object obj = instanceCache.get(index);
                        if (obj != null)
                            return obj;
                    } catch (IndexOutOfBoundsException e) {
                    }
                    throw new InvalidObjectException("String_Node_Str" + index + "String_Node_Str");
                }
            case ID_REPEAT_OBJECT_NEAR:
                {
                    if (unshared) {
                        throw new InvalidObjectException("String_Node_Str");
                    }
                    final int index = readByte() | 0xffffff00;
                    try {
                        final Object obj = instanceCache.get(index + instanceCache.size());
                        if (obj != null)
                            return obj;
                    } catch (IndexOutOfBoundsException e) {
                    }
                    throw new InvalidObjectException("String_Node_Str" + index + "String_Node_Str");
                }
            case ID_REPEAT_OBJECT_NEARISH:
                {
                    if (unshared) {
                        throw new InvalidObjectException("String_Node_Str");
                    }
                    final int index = readShort() | 0xffff0000;
                    try {
                        final Object obj = instanceCache.get(index + instanceCache.size());
                        if (obj != null)
                            return obj;
                    } catch (IndexOutOfBoundsException e) {
                    }
                    throw new InvalidObjectException("String_Node_Str" + index + "String_Node_Str");
                }
            case ID_NEW_OBJECT:
            case ID_NEW_OBJECT_UNSHARED:
                {
                    if (unshared != (leadByte == ID_NEW_OBJECT_UNSHARED)) {
                        throw sharedMismatch();
                    }
                    return doReadNewObject(readUnsignedByte(), unshared);
                }
            case ID_STRING_EMPTY:
                {
                    return "String_Node_Str";
                }
            case ID_STRING_SMALL:
                {
                    int length = readUnsignedByte();
                    final String s = UTFUtils.readUTFBytes(this, length == 0 ? 0x100 : length);
                    instanceCache.add(s);
                    return s;
                }
            case ID_STRING_MEDIUM:
                {
                    int length = readUnsignedShort();
                    final String s = UTFUtils.readUTFBytes(this, length == 0 ? 0x10000 : length);
                    instanceCache.add(s);
                    return s;
                }
            case ID_STRING_LARGE:
                {
                    int length = readInt();
                    if (length <= 0) {
                        throw new StreamCorruptedException("String_Node_Str" + length + "String_Node_Str");
                    }
                    final String s = UTFUtils.readUTFBytes(this, length);
                    instanceCache.add(s);
                    return s;
                }
            case ID_ARRAY_EMPTY:
            case ID_ARRAY_EMPTY_UNSHARED:
                {
                    if (unshared != (leadByte == ID_ARRAY_EMPTY_UNSHARED)) {
                        throw sharedMismatch();
                    }
                    final ArrayList<Object> instanceCache = this.instanceCache;
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Array.newInstance(doReadClassDescriptor(readUnsignedByte()).getType(), 0);
                    instanceCache.set(idx, obj);
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (unshared) {
                        instanceCache.set(idx, null);
                    } else if (obj != resolvedObject) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return obj;
                }
            case ID_ARRAY_SMALL:
            case ID_ARRAY_SMALL_UNSHARED:
                {
                    if (unshared != (leadByte == ID_ARRAY_SMALL_UNSHARED)) {
                        throw sharedMismatch();
                    }
                    final int len = readUnsignedByte();
                    return doReadArray(len == 0 ? 0x100 : len, unshared);
                }
            case ID_ARRAY_MEDIUM:
            case ID_ARRAY_MEDIUM_UNSHARED:
                {
                    if (unshared != (leadByte == ID_ARRAY_MEDIUM_UNSHARED)) {
                        throw sharedMismatch();
                    }
                    final int len = readUnsignedShort();
                    return doReadArray(len == 0 ? 0x10000 : len, unshared);
                }
            case ID_ARRAY_LARGE:
            case ID_ARRAY_LARGE_UNSHARED:
                {
                    if (unshared != (leadByte == ID_ARRAY_LARGE_UNSHARED)) {
                        throw sharedMismatch();
                    }
                    final int len = readInt();
                    if (len <= 0) {
                        throw new StreamCorruptedException("String_Node_Str" + len + "String_Node_Str");
                    }
                    return doReadArray(len, unshared);
                }
            case ID_PREDEFINED_OBJECT:
                {
                    if (unshared) {
                        throw new InvalidObjectException("String_Node_Str");
                    }
                    return objectTable.readObject(this);
                }
            case ID_BOOLEAN_OBJECT_TRUE:
                {
                    return objectResolver.readResolve(Boolean.TRUE);
                }
            case ID_BOOLEAN_OBJECT_FALSE:
                {
                    return objectResolver.readResolve(Boolean.FALSE);
                }
            case ID_BYTE_OBJECT:
                {
                    return objectResolver.readResolve(Byte.valueOf(readByte()));
                }
            case ID_SHORT_OBJECT:
                {
                    return objectResolver.readResolve(Short.valueOf(readShort()));
                }
            case ID_INTEGER_OBJECT:
                {
                    return objectResolver.readResolve(Integer.valueOf(readInt()));
                }
            case ID_LONG_OBJECT:
                {
                    return objectResolver.readResolve(Long.valueOf(readLong()));
                }
            case ID_FLOAT_OBJECT:
                {
                    return objectResolver.readResolve(Float.valueOf(readFloat()));
                }
            case ID_DOUBLE_OBJECT:
                {
                    return objectResolver.readResolve(Double.valueOf(readDouble()));
                }
            case ID_CHARACTER_OBJECT:
                {
                    return objectResolver.readResolve(Character.valueOf(readChar()));
                }
            case ID_PRIM_BYTE:
                {
                    return byte.class;
                }
            case ID_PRIM_BOOLEAN:
                {
                    return boolean.class;
                }
            case ID_PRIM_CHAR:
                {
                    return char.class;
                }
            case ID_PRIM_DOUBLE:
                {
                    return double.class;
                }
            case ID_PRIM_FLOAT:
                {
                    return float.class;
                }
            case ID_PRIM_INT:
                {
                    return int.class;
                }
            case ID_PRIM_LONG:
                {
                    return long.class;
                }
            case ID_PRIM_SHORT:
                {
                    return short.class;
                }
            case ID_VOID:
                {
                    return void.class;
                }
            case ID_BYTE_CLASS:
                {
                    return Byte.class;
                }
            case ID_BOOLEAN_CLASS:
                {
                    return Boolean.class;
                }
            case ID_CHARACTER_CLASS:
                {
                    return Character.class;
                }
            case ID_DOUBLE_CLASS:
                {
                    return Double.class;
                }
            case ID_FLOAT_CLASS:
                {
                    return Float.class;
                }
            case ID_INTEGER_CLASS:
                {
                    return Integer.class;
                }
            case ID_LONG_CLASS:
                {
                    return Long.class;
                }
            case ID_SHORT_CLASS:
                {
                    return Short.class;
                }
            case ID_VOID_CLASS:
                {
                    return Void.class;
                }
            case ID_OBJECT_CLASS:
                {
                    return Object.class;
                }
            case ID_CLASS_CLASS:
                {
                    return Class.class;
                }
            case ID_STRING_CLASS:
                {
                    return String.class;
                }
            case ID_ENUM_CLASS:
                {
                    return Enum.class;
                }
            case ID_BYTE_ARRAY_CLASS:
                {
                    return byte[].class;
                }
            case ID_BOOLEAN_ARRAY_CLASS:
                {
                    return boolean[].class;
                }
            case ID_CHAR_ARRAY_CLASS:
                {
                    return char[].class;
                }
            case ID_DOUBLE_ARRAY_CLASS:
                {
                    return double[].class;
                }
            case ID_FLOAT_ARRAY_CLASS:
                {
                    return float[].class;
                }
            case ID_INT_ARRAY_CLASS:
                {
                    return int[].class;
                }
            case ID_LONG_ARRAY_CLASS:
                {
                    return long[].class;
                }
            case ID_SHORT_ARRAY_CLASS:
                {
                    return short[].class;
                }
            case ID_CC_ARRAY_LIST:
                {
                    return ArrayList.class;
                }
            case ID_CC_LINKED_LIST:
                {
                    return LinkedList.class;
                }
            case ID_CC_HASH_SET:
                {
                    return HashSet.class;
                }
            case ID_CC_LINKED_HASH_SET:
                {
                    return LinkedHashSet.class;
                }
            case ID_CC_TREE_SET:
                {
                    return TreeSet.class;
                }
            case ID_CC_IDENTITY_HASH_MAP:
                {
                    return IdentityHashMap.class;
                }
            case ID_CC_HASH_MAP:
                {
                    return HashMap.class;
                }
            case ID_CC_HASHTABLE:
                {
                    return Hashtable.class;
                }
            case ID_CC_LINKED_HASH_MAP:
                {
                    return LinkedHashMap.class;
                }
            case ID_CC_TREE_MAP:
                {
                    return TreeMap.class;
                }
            case ID_CC_ENUM_SET_PROXY:
                {
                    return enumSetProxyClass;
                }
            case ID_CC_ENUM_SET:
                {
                    return EnumSet.class;
                }
            case ID_CC_ENUM_MAP:
                {
                    return EnumMap.class;
                }
            case ID_ABSTRACT_COLLECTION:
                {
                    return AbstractCollection.class;
                }
            case ID_ABSTRACT_LIST:
                {
                    return AbstractList.class;
                }
            case ID_ABSTRACT_QUEUE:
                {
                    return AbstractQueue.class;
                }
            case ID_ABSTRACT_SEQUENTIAL_LIST:
                {
                    return AbstractSequentialList.class;
                }
            case ID_ABSTRACT_SET:
                {
                    return AbstractSet.class;
                }
            case ID_CC_CONCURRENT_HASH_MAP:
                {
                    return ConcurrentHashMap.class;
                }
            case ID_CC_COPY_ON_WRITE_ARRAY_LIST:
                {
                    return CopyOnWriteArrayList.class;
                }
            case ID_CC_COPY_ON_WRITE_ARRAY_SET:
                {
                    return CopyOnWriteArraySet.class;
                }
            case ID_CC_VECTOR:
                {
                    return Vector.class;
                }
            case ID_CC_STACK:
                {
                    return Stack.class;
                }
            case ID_CC_NCOPIES:
                {
                    return nCopiesClass;
                }
            case ID_SINGLETON_LIST_OBJECT:
                {
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Collections.singletonList(doReadNestedObject(false, "String_Node_Str"));
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (!unshared) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return resolvedObject;
                }
            case ID_SINGLETON_SET_OBJECT:
                {
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Collections.singleton(doReadNestedObject(false, "String_Node_Str"));
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (!unshared) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return resolvedObject;
                }
            case ID_SINGLETON_MAP_OBJECT:
                {
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Collections.singletonMap(doReadNestedObject(false, "String_Node_Str"), doReadNestedObject(false, "String_Node_Str"));
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (!unshared) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return resolvedObject;
                }
            case ID_REVERSE_ORDER2_OBJECT:
                {
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Collections.reverseOrder((Comparator<?>) doReadNestedObject(false, "String_Node_Str"));
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (!unshared) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return resolvedObject;
                }
            case ID_EMPTY_LIST_OBJECT:
                {
                    return Collections.emptyList();
                }
            case ID_EMPTY_SET_OBJECT:
                {
                    return Collections.emptySet();
                }
            case ID_EMPTY_MAP_OBJECT:
                {
                    return Collections.emptyMap();
                }
            case ID_REVERSE_ORDER_OBJECT:
                {
                    return Collections.reverseOrder();
                }
            case ID_COLLECTION_EMPTY:
            case ID_COLLECTION_EMPTY_UNSHARED:
            case ID_COLLECTION_SMALL:
            case ID_COLLECTION_SMALL_UNSHARED:
            case ID_COLLECTION_MEDIUM:
            case ID_COLLECTION_MEDIUM_UNSHARED:
            case ID_COLLECTION_LARGE:
            case ID_COLLECTION_LARGE_UNSHARED:
                {
                    final int len;
                    switch(leadByte) {
                        case ID_COLLECTION_EMPTY:
                        case ID_COLLECTION_EMPTY_UNSHARED:
                            {
                                len = 0;
                                break;
                            }
                        case ID_COLLECTION_SMALL:
                        case ID_COLLECTION_SMALL_UNSHARED:
                            {
                                int b = readUnsignedByte();
                                len = b == 0 ? 0x100 : b;
                                break;
                            }
                        case ID_COLLECTION_MEDIUM:
                        case ID_COLLECTION_MEDIUM_UNSHARED:
                            {
                                int b = readUnsignedShort();
                                len = b == 0 ? 0x10000 : b;
                                break;
                            }
                        case ID_COLLECTION_LARGE:
                        case ID_COLLECTION_LARGE_UNSHARED:
                            {
                                len = readInt();
                                break;
                            }
                        default:
                            {
                                throw new IllegalStateException();
                            }
                    }
                    final int id = readUnsignedByte();
                    switch(id) {
                        case ID_CC_ARRAY_LIST:
                            {
                                return readCollectionData(unshared, -1, len, new ArrayList(len));
                            }
                        case ID_CC_HASH_SET:
                            {
                                return readCollectionData(unshared, -1, len, new HashSet(len));
                            }
                        case ID_CC_LINKED_HASH_SET:
                            {
                                return readCollectionData(unshared, -1, len, new LinkedHashSet(len));
                            }
                        case ID_CC_LINKED_LIST:
                            {
                                return readCollectionData(unshared, -1, len, new LinkedList());
                            }
                        case ID_CC_TREE_SET:
                            {
                                int idx = instanceCache.size();
                                instanceCache.add(null);
                                Comparator comp = (Comparator) doReadNestedObject(false, "String_Node_Str");
                                return readCollectionData(unshared, idx, len, new TreeSet(comp));
                            }
                        case ID_CC_ENUM_SET_PROXY:
                            {
                                final ClassDescriptor nestedDescriptor = doReadClassDescriptor(readUnsignedByte());
                                final Class<? extends Enum> elementType = nestedDescriptor.getType().asSubclass(Enum.class);
                                return readCollectionData(unshared, -1, len, EnumSet.noneOf(elementType));
                            }
                        case ID_CC_VECTOR:
                            {
                                return readCollectionData(unshared, -1, len, new Vector(len));
                            }
                        case ID_CC_STACK:
                            {
                                return readCollectionData(unshared, -1, len, new Stack());
                            }
                        case ID_CC_ARRAY_DEQUE:
                            {
                                return readCollectionData(unshared, -1, len, new ArrayDeque(len));
                            }
                        case ID_CC_HASH_MAP:
                            {
                                return readMapData(unshared, -1, len, new HashMap(len));
                            }
                        case ID_CC_HASHTABLE:
                            {
                                return readMapData(unshared, -1, len, new Hashtable(len));
                            }
                        case ID_CC_IDENTITY_HASH_MAP:
                            {
                                return readMapData(unshared, -1, len, new IdentityHashMap(len));
                            }
                        case ID_CC_LINKED_HASH_MAP:
                            {
                                return readMapData(unshared, -1, len, new LinkedHashMap(len));
                            }
                        case ID_CC_TREE_MAP:
                            {
                                int idx = instanceCache.size();
                                instanceCache.add(null);
                                Comparator comp = (Comparator) doReadNestedObject(false, "String_Node_Str");
                                return readMapData(unshared, idx, len, new TreeMap(comp));
                            }
                        case ID_CC_ENUM_MAP:
                            {
                                final ClassDescriptor nestedDescriptor = doReadClassDescriptor(readUnsignedByte());
                                final Class<? extends Enum> elementType = nestedDescriptor.getType().asSubclass(Enum.class);
                                return readMapData(unshared, -1, len, new EnumMap(elementType));
                            }
                        case ID_CC_NCOPIES:
                            {
                                final int idx = instanceCache.size();
                                instanceCache.add(null);
                                final Object obj = Collections.nCopies(len, doReadNestedObject(false, "String_Node_Str"));
                                final Object resolvedObject = objectResolver.readResolve(obj);
                                if (!unshared) {
                                    instanceCache.set(idx, resolvedObject);
                                }
                                return resolvedObject;
                            }
                        default:
                            {
                                throw new StreamCorruptedException("String_Node_Str" + leadByte);
                            }
                    }
                }
            case ID_PAIR:
                {
                    final int idx = instanceCache.size();
                    instanceCache.add(null);
                    final Object obj = Pair.create(doReadNestedObject(unshared, "String_Node_Str"), doReadNestedObject(unshared, "String_Node_Str"));
                    final Object resolvedObject = objectResolver.readResolve(obj);
                    if (!unshared) {
                        instanceCache.set(idx, resolvedObject);
                    }
                    return resolvedObject;
                }
            case ID_CLEAR_CLASS_CACHE:
                {
                    if (depth > 1) {
                        throw new StreamCorruptedException("String_Node_Str");
                    }
                    classCache.clear();
                    instanceCache.clear();
                    leadByte = readUnsignedByte();
                    continue;
                }
            case ID_CLEAR_INSTANCE_CACHE:
                {
                    if (depth > 1) {
                        throw new StreamCorruptedException("String_Node_Str");
                    }
                    instanceCache.clear();
                    continue;
                }
            default:
                {
                    throw new StreamCorruptedException("String_Node_Str" + leadByte);
                }
        }
    } finally {
        depth--;
    }
}

Output:
                                 final Class<? extends Enum> elementType = nestedDescriptor.getType().asSubclass(Enum.class);
-                                return readMapData(unshared, -1, len, new EnumMap(elementType));
+                                return readMapData(unshared, idx, len, new EnumMap(elementType));
                             }


Input:
public static boolean validateSearchStringIsValidIdna(String searchString) {
    if (StringUtils.isBlank(searchString)) {
        return false;
    }
    if (searchString.contains(BLANK_IN_DOMAIN)) {
        return false;
    }
    if (1 < StringUtils.countMatches(searchString, StringUtil.ASTERISK)) {
        return false;
    }
    String domainName = searchString.replace(StringUtil.ASTERISK, "String_Node_Str");
    if (validateDomainNameIsValidIdna(domainName)) {
        return true;
    }
    domainName = searchString.replace(StringUtil.ASTERISK, StringUtil.TLD_SPLITOR);
    if (validateDomainNameIsValidIdna(domainName)) {
        return true;
    }
    domainName = searchString.replace(StringUtil.ASTERISK, "String_Node_Str");
    if (validateDomainNameIsValidIdna(domainName)) {
        return true;
    }
    domainName = searchString.replace("String_Node_Str", "String_Node_Str");
    if (validateDomainNameIsValidIdna(domainName)) {
        return true;
    }
    domainName = searchString.replace("String_Node_Str", "String_Node_Str");
    if (validateDomainNameIsValidIdna(domainName)) {
        return true;
    }
    return false;
}

Output:
     String domainName = searchString.replace(StringUtil.ASTERISK, "String_Node_Str");
-    if (validateDomainNameIsValidIdna(domainName)) {
+    if (validateDomainNameIsValidIdna(domainName, true)) {
         return true;


Input:
public int addPlot(IPlot plot) throws Exception {
    int index = -1;
    ISeries independent = null;
    List<ISeries> dependent = null;
    if (plot != null && drawnPlots.size() < rows * columns && (independent = plot.getIndependentSeries()) != null && (dependent = plot.getAllDependentSeries(null)) != null) {
        if (dependent.size() > 0 && independent.getBounds() != null) {
            final DrawnPlot drawnPlot = new DrawnPlot(gridComposite, plot);
            drawnPlot.setBackground(getBackground());
            try {
                drawnPlot.draw();
            } catch (Exception e) {
                drawnPlot.dispose();
                throw e;
            }
            index = drawnPlots.size();
            drawnPlots.add(drawnPlot);
            drawnPlotMap.put(drawnPlot, index);
            drawnPlot.addDisposeListener(plotDisposeListener);
            GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
            drawnPlot.setLayoutData(gridData);
            refreshLayout();
        }
    }
    return index;
}

Output:
     int index = -1;
-    ISeries independent = null;
-    List<ISeries> dependent = null;
-    if (plot != null && drawnPlots.size() < rows * columns && (independent = plot.getIndependentSeries()) != null && (dependent = plot.getAllDependentSeries(null)) != null) {
-        if (dependent.size() > 0 && independent.getBounds() != null) {
-            final DrawnPlot drawnPlot = new DrawnPlot(gridComposite, plot);
-            drawnPlot.setBackground(getBackground());
-            try {
-                drawnPlot.draw();
-            } catch (Exception e) {
-                drawnPlot.dispose();
-                throw e;
-            }
-            index = drawnPlots.size();
-            drawnPlots.add(drawnPlot);
-            drawnPlotMap.put(drawnPlot, index);
-            drawnPlot.addDisposeListener(plotDisposeListener);
-            GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
-            drawnPlot.setLayoutData(gridData);
-            refreshLayout();
+    if (plot != null && drawnPlots.size() < rows * columns && plot.getIndependentSeries() != null && plot.getCategories().length > 0) {
+        final DrawnPlot drawnPlot = new DrawnPlot(gridComposite, plot);
+        drawnPlot.setBackground(getBackground());
+        try {
+            drawnPlot.draw();
+        } catch (Exception e) {
+            drawnPlot.dispose();
+            throw e;
         }


Input:
public InputStream getInputStream(String url) throws IOException {
    HttpGet get = new HttpGet(url);
    HttpResponse response = this.client.execute(get);
    StatusLine statusLine = response.getStatusLine();
    if (!SardineUtil.isGoodResponse(statusLine.getStatusCode()))
        throw new IOException("String_Node_Str" + statusLine.getStatusCode() + "String_Node_Str" + statusLine.getReasonPhrase() + "String_Node_Str" + url);
    return response.getEntity().getContent();
}

Output:
     HttpGet get = new HttpGet(url);
-    HttpResponse response = this.client.execute(get);
+    HttpResponse response = this.executeWrapper(get);
     StatusLine statusLine = response.getStatusLine();


Input:
private String getValidURL(String url) {
    if (url.indexOf("String_Node_Str") != 0) {
        url = url.replace("String_Node_Str", "String_Node_Str");
    }
    return url;
}

Output:
     }
-    return url;
+    setConnectionURL(url);
+    urlText.setText(getConnectionURL());
 }


Input:
protected CAstNode copyNodes(CAstNode root, RewriteContext context, Map<Pair<CAstNode, ExpanderKey>, CAstNode> nodeMap) {
    int kind = root.getKind();
    if (kind == CAstNode.OBJECT_REF && context.inRead()) {
        CAstNode readLoop;
        CAstNode receiver = copyNodes(root.getChild(0), READ, nodeMap);
        CAstNode element = copyNodes(root.getChild(1), READ, nodeMap);
        if (element.getKind() == CAstNode.CONSTANT && element.getValue() instanceof String) {
            readLoop = makeConstRead(root, receiver, element, context, nodeMap);
        } else {
            readLoop = makeVarRead(root, receiver, element, context, nodeMap);
        }
        return readLoop;
    } else if (kind == CAstNode.ASSIGN_PRE_OP || kind == CAstNode.ASSIGN_POST_OP) {
        AssignPreOrPostOpContext ctxt = new AssignPreOrPostOpContext();
        CAstNode lval = copyNodes(root.getChild(0), ctxt, nodeMap);
        CAstNode rval = copyNodes(root.getChild(1), READ, nodeMap);
        CAstNode op = copyNodes(root.getChild(2), READ, nodeMap);
        if (ctxt.receiverTemp != null) {
            String temp1 = TEMP_NAME + (readTempCounter++);
            String temp2 = TEMP_NAME + (readTempCounter++);
            CAstNode copy = Ast.makeNode(CAstNode.BLOCK_EXPR, Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp1, true, false)), lval), rval, Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp2, true, false)), Ast.makeNode(CAstNode.BINARY_EXPR, op, Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp1)), rval)), Ast.makeNode(CAstNode.ASSIGN, Ast.makeNode(CAstNode.OBJECT_REF, ctxt.receiverTemp, ctxt.elementTemp), Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp2))), Ast.makeNode(CAstNode.VAR, Ast.makeConstant((kind == CAstNode.ASSIGN_PRE_OP) ? temp2 : temp1)));
            nodeMap.put(Pair.make(root, context.key()), copy);
            return copy;
        } else {
            CAstNode copy = Ast.makeNode(kind, lval, rval, op);
            nodeMap.put(Pair.make(root, context.key()), copy);
            return copy;
        }
    } else if (kind == CAstNode.ASSIGN) {
        CAstNode copy = Ast.makeNode(CAstNode.ASSIGN, copyNodes(root.getChild(0), ASSIGN, nodeMap), copyNodes(root.getChild(1), READ, nodeMap));
        nodeMap.put(Pair.make(root, context.key()), copy);
        return copy;
    } else if (kind == CAstNode.BLOCK_EXPR) {
        CAstNode[] children = new CAstNode[root.getChildCount()];
        int last = (children.length - 1);
        for (int i = 0; i < last; i++) {
            children[i] = copyNodes(root.getChild(i), READ, nodeMap);
        }
        children[last] = copyNodes(root.getChild(last), context, nodeMap);
        CAstNode copy = Ast.makeNode(CAstNode.BLOCK_EXPR, children);
        nodeMap.put(Pair.make(root, context.key()), copy);
        return copy;
    } else if (root.getKind() == CAstNode.CONSTANT) {
        CAstNode copy = Ast.makeConstant(root.getValue());
        nodeMap.put(Pair.make(root, context.key()), copy);
        return copy;
    } else if (root.getKind() == CAstNode.OPERATOR) {
        nodeMap.put(Pair.make(root, context.key()), root);
        return root;
    } else {
        CAstNode[] children = new CAstNode[root.getChildCount()];
        for (int i = 0; i < children.length; i++) {
            children[i] = copyNodes(root.getChild(i), READ, nodeMap);
        }
        CAstNode copy = Ast.makeNode(kind, children);
        nodeMap.put(Pair.make(root, context.key()), copy);
        return copy;
    }
}

Output:
             String temp2 = TEMP_NAME + (readTempCounter++);
-            CAstNode copy = Ast.makeNode(CAstNode.BLOCK_EXPR, Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp1, true, false)), lval), rval, Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp2, true, false)), Ast.makeNode(CAstNode.BINARY_EXPR, op, Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp1)), rval)), Ast.makeNode(CAstNode.ASSIGN, Ast.makeNode(CAstNode.OBJECT_REF, ctxt.receiverTemp, ctxt.elementTemp), Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp2))), Ast.makeNode(CAstNode.VAR, Ast.makeConstant((kind == CAstNode.ASSIGN_PRE_OP) ? temp2 : temp1)));
+            CAstNode copy = Ast.makeNode(CAstNode.BLOCK_EXPR, Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp1, true, false)), lval), Ast.makeNode(CAstNode.DECL_STMT, Ast.makeConstant(new InternalCAstSymbol(temp2, true, false)), Ast.makeNode(CAstNode.BINARY_EXPR, op, Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp1)), rval)), Ast.makeNode(CAstNode.ASSIGN, Ast.makeNode(CAstNode.OBJECT_REF, ctxt.receiverTemp, ctxt.elementTemp), Ast.makeNode(CAstNode.VAR, Ast.makeConstant(temp2))), Ast.makeNode(CAstNode.VAR, Ast.makeConstant((kind == CAstNode.ASSIGN_PRE_OP) ? temp2 : temp1)));
             nodeMap.put(Pair.make(root, context.key()), copy);


Input:
void handleLaunchTaskBehindCompleteLocked(ActivityRecord r) {
    r.mLaunchTaskBehind = false;
    final TaskRecord task = r.task;
    task.setLastThumbnailLocked(task.stack.screenshotActivitiesLocked(r));
    mRecentTasks.addLocked(task);
    mService.notifyTaskStackChangedLocked();
    mWindowManager.setAppVisibility(r.appToken, false);
}

Output:
     final TaskRecord task = r.task;
-    task.setLastThumbnailLocked(task.stack.screenshotActivitiesLocked(r));
+    final ActivityStack stack = task.stack;
+    r.mLaunchTaskBehind = false;
+    task.setLastThumbnailLocked(stack.screenshotActivitiesLocked(r));
     mRecentTasks.addLocked(task);


Input:
public GuidedDecisionTree load(final Path path) {
    try {
        final String content = ioService.readAllString(Paths.convert(path));
        final GuidedDecisionTree model = GuidedDecisionTreeXMLPersistence.getInstance().unmarshal(content);
        final TypeNode type = new TypeNodeImpl("String_Node_Str");
        final ConstraintNode c1 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
        final ConstraintNode c2 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
        final ConstraintNode c3 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new IntegerValue(20));
        final ConstraintNode c4 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new IntegerValue(30));
        model.setRoot(type);
        type.getChildren().add(c1);
        type.getChildren().add(c2);
        c1.getChildren().add(c3);
        c1.getChildren().add(c4);
        return model;
    } catch (Exception e) {
        throw ExceptionUtilities.handleException(e);
    }
}

Output:
         final TypeNode type = new TypeNodeImpl("String_Node_Str");
-        final ConstraintNode c1 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
-        final ConstraintNode c2 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
-        final ConstraintNode c3 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new IntegerValue(20));
-        final ConstraintNode c4 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", new IntegerValue(30));
+        final ConstraintNode c1 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
+        final ConstraintNode c2 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", "String_Node_Str", new StringValue("String_Node_Str"));
+        final ConstraintNode c3 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", "String_Node_Str", new IntegerValue(20));
+        final ConstraintNode c4 = new ConstraintNodeImpl("String_Node_Str", "String_Node_Str", "String_Node_Str", new IntegerValue(30));
         model.setRoot(type);


Input:
private void createResultDataComposite(final Composite comp, final ColumnIndicator columnIndicator) {
    if (columnIndicator.getIndicators().length != 0) {
        final TdColumn column = columnIndicator.getTdColumn();
        IRunnableWithProgress rwp = new IRunnableWithProgress() {

            public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                monitor.beginTask(DefaultMessagesImpl.getString("String_Node_Str", column.getName()), IProgressMonitor.UNKNOWN);
                Display.getDefault().asyncExec(new Runnable() {
                    public void run() {
                        Map<EIndicatorChartType, List<IndicatorUnit>> indicatorComposite = CompositeIndicator.getInstance().getIndicatorComposite(columnIndicator);
                        for (EIndicatorChartType chartType : indicatorComposite.keySet()) {
                            List<IndicatorUnit> units = indicatorComposite.get(chartType);
                            if (!units.isEmpty()) {
                                IChartTypeStates chartTypeState = ChartTypeStatesOperator.getChartState(chartType, units);
                                ChartWithData chartData = new ChartWithData(chartType, chartTypeState.getChart(), chartTypeState.getDataEntity());
                                ExpandableComposite subComp = toolkit.createExpandableComposite(comp, ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT | ExpandableComposite.EXPANDED);
                                subComp.setText(chartData.getChartType().getLiteral());
                                subComp.setLayoutData(new GridData(GridData.FILL_BOTH));
                                final Composite composite = toolkit.createComposite(subComp, SWT.NULL);
                                composite.setLayout(new GridLayout(2, false));
                                composite.setLayoutData(new GridData(GridData.FILL_BOTH));
                                Analysis analysis = masterPage.getAnalysisHandler().getAnalysis();
                                TableViewer tableviewer = chartTypeState.getTableForm(composite);
                                tableviewer.setInput(chartData);
                                DataExplorer dataExplorer = chartTypeState.getDataExplorer();
                                ChartTableFactory.addMenuAndTip(tableviewer, dataExplorer, analysis);
                                JFreeChart chart = chartTypeState.getChart();
                                ChartDecorator.decorate(chart);
                                if (chart != null) {
                                    ChartComposite cc = new ChartComposite(composite, SWT.NONE, chart, true);
                                    GridData gd = new GridData();
                                    gd.widthHint = 550;
                                    gd.heightHint = 250;
                                    cc.setLayoutData(gd);
                                    addMouseListenerForChart(cc, dataExplorer, analysis);
                                }
                                subComp.setClient(composite);
                                subComp.addExpansionListener(new ExpansionAdapter() {
                                    public void expansionStateChanged(ExpansionEvent e) {
                                        form.reflow(true);
                                    }
                                });
                            }
                        }
                    }
                });
                monitor.done();
            }
        };
        try {
            new ProgressMonitorDialog(null).run(true, false, rwp);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

Output:
     if (columnIndicator.getIndicators().length != 0) {
-        final TdColumn column = columnIndicator.getTdColumn();
-        IRunnableWithProgress rwp = new IRunnableWithProgress() {
+        Map<EIndicatorChartType, List<IndicatorUnit>> indicatorComposite = CompositeIndicator.getInstance().getIndicatorComposite(columnIndicator);
+        for (EIndicatorChartType chartType : indicatorComposite.keySet()) {
+            List<IndicatorUnit> units = indicatorComposite.get(chartType);
+            if (!units.isEmpty()) {
+                IChartTypeStates chartTypeState = ChartTypeStatesOperator.getChartState(chartType, units);
+                ChartWithData chartData = new ChartWithData(chartType, chartTypeState.getChart(), chartTypeState.getDataEntity());
+                ExpandableComposite subComp = toolkit.createExpandableComposite(comp, ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT | ExpandableComposite.EXPANDED);
+                subComp.setText(chartData.getChartType().getLiteral());
+                subComp.setLayoutData(new GridData(GridData.FILL_BOTH));
+                final Composite composite = toolkit.createComposite(subComp, SWT.NULL);
+                composite.setLayout(new GridLayout(2, false));
+                composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+                Analysis analysis = masterPage.getAnalysisHandler().getAnalysis();
+                TableViewer tableviewer = chartTypeState.getTableForm(composite);
+                tableviewer.setInput(chartData);
+                DataExplorer dataExplorer = chartTypeState.getDataExplorer();
+                ChartTableFactory.addMenuAndTip(tableviewer, dataExplorer, analysis);
+                JFreeChart chart = chartTypeState.getChart();
+                ChartDecorator.decorate(chart);
+                if (chart != null) {
+                    ChartComposite cc = new ChartComposite(composite, SWT.NONE, chart, true);
+                    GridData gd = new GridData();
+                    gd.widthHint = 550;
+                    gd.heightHint = 250;
+                    cc.setLayoutData(gd);
+                    addMouseListenerForChart(cc, dataExplorer, analysis);
+                }
+                subComp.setClient(composite);
+                subComp.addExpansionListener(new ExpansionAdapter() {


Input:
private void parses(boolean importFromArchieve, String zipFilePath, IProgressMonitor monitor) {
    int total = 500, zipCount = 200, readCount = 100;
    int step = 1, interval = 1;
    monitor.beginTask("String_Node_Str", total);
    if (importFromArchieve) {
        checkUpExchangeImport(true);
        try {
            ZipToFile.unZipFile(zipFilePath, importFolder, zipCount, monitor);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
    monitor.worked(zipCount);
    monitor.setTaskName("String_Node_Str");
    InputStreamReader reader = null;
    try {
        reader = new InputStreamReader(new FileInputStream(importFolder + "String_Node_Str"), "String_Node_Str");
        final Exports exports = (Exports) Unmarshaller.unmarshal(Exports.class, reader);
        String[] orgSchemas = exports.getSchemas();
        int idx = 0;
        if (orgSchemas != null) {
            for (String orgSchema : orgSchemas) {
                String orgSchemaCpy = new String(orgSchema);
                for (Map.Entry<String, String> pair : ICoreConstants.rolesConvert.oldRoleToNewRoleMap.entrySet()) {
                    orgSchemaCpy = orgSchemaCpy.replaceAll(pair.getKey().toString(), pair.getValue().toString());
                }
                if (!orgSchemaCpy.equals(orgSchema)) {
                    orgSchemas[idx] = orgSchemaCpy;
                }
                idx++;
            }
        }
        try {
            LocalTreeObjectRepository.getInstance().makeUpDocWithImportCategory(orgSchemas, serverRoot);
        } catch (Exception e) {
        }
        if (exports.getAutoIncrement() != null) {
            try {
                port.getAutoIncrement(new WSAutoIncrement(exports.getAutoIncrement()));
            } catch (Exception e) {
            }
        }
        final TreeParent reserverRoot = new TreeParent(serverRoot.getDisplayName(), null, TreeObject._SERVER_, serverRoot.getWsKey(), serverRoot.getWsObject());
        reserverRoot.setUser(serverRoot.getUser());
        TreeParent clusters = new TreeParent(EXtentisObjects.DataCluster.getDisplayName(), reserverRoot, TreeObject.DATA_CLUSTER, null, null);
        TreeParent models = new TreeParent(EXtentisObjects.DataMODEL.getDisplayName(), reserverRoot, TreeObject.DATA_MODEL, null, null);
        TreeParent menus = new TreeParent(EXtentisObjects.Menu.getDisplayName(), reserverRoot, TreeObject.MENU, null, null);
        TreeParent roles = new TreeParent(EXtentisObjects.Role.getDisplayName(), reserverRoot, TreeObject.ROLE, null, null);
        TreeParent eventManager = new TreeParent(EXtentisObjects.EventManagement.getDisplayName(), reserverRoot, TreeObject.EVENT_MANAGEMENT, null, null);
        TreeParent routingrules = new TreeParent(EXtentisObjects.RoutingRule.getDisplayName(), reserverRoot, TreeObject.ROUTING_RULE, null, null);
        TreeParent storeprocedures = new TreeParent(EXtentisObjects.StoredProcedure.getDisplayName(), reserverRoot, TreeObject.STORED_PROCEDURE, null, null);
        TreeParent syncplans = new TreeParent(EXtentisObjects.SynchronizationPlan.getDisplayName(), reserverRoot, TreeObject.SYNCHRONIZATIONPLAN, null, null);
        TreeParent transformers = new TreeParent(EXtentisObjects.Transformer.getDisplayName(), reserverRoot, TreeObject.TRANSFORMER, null, null);
        TreeParent pictures = new TreeParent(EXtentisObjects.PICTURESRESOURCE.getDisplayName(), reserverRoot, TreeObject.PICTURES_RESOURCE, null, null);
        TreeParent workflow = new TreeParent(EXtentisObjects.Workflow.getDisplayName(), reserverRoot, TreeObject.WORKFLOW, null, null);
        TreeParent universes = new TreeParent(EXtentisObjects.Universe.getDisplayName(), reserverRoot, TreeObject.UNIVERSE, null, null);
        TreeParent views = new TreeParent(EXtentisObjects.View.getDisplayName(), reserverRoot, TreeObject.VIEW, null, null);
        reserverRoot.addChild(clusters);
        reserverRoot.addChild(models);
        reserverRoot.addChild(menus);
        reserverRoot.addChild(roles);
        reserverRoot.addChild(storeprocedures);
        reserverRoot.addChild(syncplans);
        eventManager.addChild(transformers);
        eventManager.addChild(routingrules);
        reserverRoot.addChild(eventManager);
        reserverRoot.addChild(pictures);
        reserverRoot.addChild(workflow);
        reserverRoot.addChild(universes);
        reserverRoot.addChild(views);
        monitor.worked(readCount);
        float val = (total - zipCount - readCount) / exports.getItems().length;
        if (val > 0) {
            interval = 1;
            step = Math.round(val);
        } else {
            step = 1;
            interval = Math.round(exports.getItems().length / (total - zipCount - readCount) + 0.5f);
        }
        monitor.setTaskName("String_Node_Str");
        int tmp = 1;
        for (TreeObject obj : exports.getItems()) {
            obj.setServerRoot(reserverRoot);
            switch(obj.getType()) {
                case TreeObject.DATA_CLUSTER:
                    clusters.addChild(obj);
                    break;
                case TreeObject.DATA_MODEL:
                    models.addChild(obj);
                    break;
                case TreeObject.MENU:
                    menus.addChild(obj);
                    break;
                case TreeObject.ROLE:
                    roles.addChild(obj);
                    break;
                case TreeObject.ROUTING_RULE:
                    routingrules.addChild(obj);
                    break;
                case TreeObject.STORED_PROCEDURE:
                    storeprocedures.addChild(obj);
                    break;
                case TreeObject.SYNCHRONIZATIONPLAN:
                    syncplans.addChild(obj);
                    break;
                case TreeObject.TRANSFORMER:
                    transformers.addChild(obj);
                    break;
                case TreeObject.PICTURES_RESOURCE:
                    pictures.addChild(obj);
                    break;
                case TreeObject.WORKFLOW_PROCESS:
                    workflow.addChild(obj);
                    break;
                case TreeObject.UNIVERSE:
                    universes.addChild(obj);
                    break;
                case TreeObject.VIEW:
                    views.addChild(obj);
                    break;
                default:
                    if (obj.getItems() != null && obj.getItems().length > 0) {
                        for (int i = 0; i < obj.getItems().length; i++) {
                            if (obj.getItems()[i].split("String_Node_Str")[1] != null)
                                dataClusterContent.put(obj.getItems()[i].split("String_Node_Str")[1], obj.getItems());
                        }
                    }
            }
            if (interval == 1) {
                monitor.worked(step);
            } else {
                if (tmp >= interval) {
                    monitor.worked(step);
                    tmp = 1;
                } else {
                    tmp++;
                }
            }
        }
        Display.getDefault().syncExec(new Runnable() {
            public void run() {
                treeViewer.setRoot(reserverRoot);
                treeViewer.getViewer().setInput(view.getSite());
                treeViewer.setCheckItems(Arrays.asList(exports.getItems()));
                GridData gd = (GridData) treeViewer.getViewer().getControl().getLayoutData();
                gd.heightHint = 300;
                treeViewer.getViewer().getControl().getParent().layout(true);
                treeViewer.getViewer().getControl().getShell().layout(true);
            }
        });
        try {
            LocalTreeObjectRepository.getInstance().setOriginalXobjectsToImport(treeViewer.getCheckNodes());
        } catch (Exception e) {
        }
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    } finally {
        try {
            if (reader != null)
                reader.close();
        } catch (Exception e) {
        }
        monitor.done();
    }
}

Output:
         try {
-            ZipToFile.unZipFile(zipFilePath, importFolder, zipCount, monitor);
+            Util.unZipFile(zipFilePath, importFolder, zipCount, monitor);
         } catch (Exception e) {


Input:
public View getViewForTab(int position, View convertView, ViewGroup container) {
    if (convertView == null) {
        convertView = (TextView) inflater.inflate(R.layout.tab_main, container, false);
    }
    TextView textView = (TextView) convertView;
    textView.setText(tabNames[position]);
    textView.setCompoundDrawablesWithIntrinsicBounds(0, tabIcons[position], 0, 0);
    return textView;
}

Output:
     if (convertView == null) {
-        convertView = (TextView) inflater.inflate(R.layout.tab_main, container, false);
+        convertView = inflater.inflate(R.layout.tab_main, container, false);
     }


Input:
public void execute(int pid, int rid, BimDatabaseSession bimDatabaseSession) throws UserException, BimDeadlockException, BimDatabaseException {
    IdEObject idEObject = bimDatabaseSession.get(bimDatabaseSession.getEClassForName(className), oid, false, null);
    if (idEObject == null) {
        throw new UserException("String_Node_Str" + className + "String_Node_Str" + pid);
    }
    EAttribute eAttribute = bimDatabaseSession.getMetaDataManager().getEAttribute(className, attributeName);
    if (eAttribute == null) {
        throw new UserException("String_Node_Str" + attributeName + "String_Node_Str" + className);
    }
    if (!eAttribute.isMany()) {
        throw new UserException("String_Node_Str");
    }
    List list = (List) idEObject.eGet(eAttribute);
    list.add(value);
    bimDatabaseSession.store(idEObject);
}

Output:
     if (idEObject == null) {
-        throw new UserException("String_Node_Str" + className + "String_Node_Str" + pid);
+        idEObject = created.get(oid);
+    }
+    if (idEObject == null) {
+        throw new UserException("String_Node_Str" + className + "String_Node_Str" + oid + "String_Node_Str" + pid);
     }


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object objectValue, CoreAbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    XPathFragment rootFragment = null;
    Marshaller marshaller = marshalRecord.getMarshaller();
    objectValue = xmlAnyObjectMapping.convertObjectValueToDataValue(objectValue, session, marshalRecord.getMarshaller());
    if (null == objectValue) {
        return false;
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    marshalRecord.closeStartGroupingElements(groupingFragment);
    boolean wasXMLRoot = false;
    XPathFragment xmlRootFragment = null;
    Object originalValue = objectValue;
    if (xmlAnyObjectMapping.usesXMLRoot() && (objectValue instanceof Root)) {
        xmlRootFragment = new XPathFragment();
        xmlRootFragment.setNamespaceAware(marshalRecord.isNamespaceAware());
        wasXMLRoot = true;
        objectValue = ((Root) objectValue).getObject();
        if (objectValue == null) {
            setupFragment(((Root) originalValue), xmlRootFragment, marshalRecord);
            marshalRecord.nilComplex(xmlRootFragment, namespaceResolver);
            return true;
        }
    }
    if (objectValue instanceof String) {
        marshalSimpleValue(xmlRootFragment, marshalRecord, originalValue, object, objectValue, session, namespaceResolver);
    } else {
        CoreSession childSession = null;
        try {
            childSession = marshaller.getContext().getSession(objectValue);
        } catch (XMLMarshalException e) {
            marshalSimpleValue(xmlRootFragment, marshalRecord, originalValue, object, objectValue, session, namespaceResolver);
            return true;
        }
        Descriptor descriptor = (Descriptor) childSession.getDescriptor(objectValue);
        ObjectBuilder objectBuilder = (ObjectBuilder) descriptor.getObjectBuilder();
        List extraNamespaces = objectBuilder.addExtraNamespacesToNamespaceResolver(descriptor, marshalRecord, session, true, true);
        if (wasXMLRoot) {
            setupFragment(((Root) originalValue), xmlRootFragment, marshalRecord);
        }
        String defaultRootElementString = descriptor.getDefaultRootElement();
        if (!wasXMLRoot && (defaultRootElementString == null)) {
            AbstractSessionLog.getLog().log(SessionLog.WARNING, "String_Node_Str", new Object[] { Helper.getShortClassName(this.getClass()), descriptor });
        } else {
            marshalRecord.beforeContainmentMarshal(objectValue);
            if (xmlRootFragment != null) {
                rootFragment = xmlRootFragment;
            } else {
                rootFragment = new XPathFragment(defaultRootElementString);
                if (rootFragment.getNamespaceURI() == null) {
                    if (rootFragment.getPrefix() != null) {
                        String uri = descriptor.getNonNullNamespaceResolver().resolveNamespacePrefix(rootFragment.getPrefix());
                        rootFragment.setNamespaceURI(uri);
                    } else {
                        rootFragment.setNamespaceURI(descriptor.getNonNullNamespaceResolver().getDefaultNamespaceURI());
                    }
                }
            }
            if (!wasXMLRoot) {
                marshalRecord.setLeafElementType(descriptor.getDefaultRootElementType());
            }
            getXPathNode().startElement(marshalRecord, rootFragment, object, session, descriptor.getNonNullNamespaceResolver(), objectBuilder, objectValue);
            writeExtraNamespaces(extraNamespaces, marshalRecord, session);
            marshalRecord.addXsiTypeAndClassIndicatorIfRequired(descriptor, descriptor, (Field) xmlAnyObjectMapping.getField(), originalValue, objectValue, wasXMLRoot, false);
            objectBuilder.buildRow(marshalRecord, objectValue, (org.eclipse.persistence.internal.sessions.AbstractSession) childSession, marshaller, null);
            marshalRecord.afterContainmentMarshal(object, objectValue);
            marshalRecord.endElement(rootFragment, namespaceResolver);
            marshalRecord.removeExtraNamespacesFromNamespaceResolver(extraNamespaces, session);
        }
    }
    return true;
}

Output:
         if (!wasXMLRoot && (defaultRootElementString == null)) {
-            AbstractSessionLog.getLog().log(SessionLog.WARNING, "String_Node_Str", new Object[] { Helper.getShortClassName(this.getClass()), descriptor });
+            throw XMLMarshalException.defaultRootElementNotSpecified((XMLDescriptor) descriptor);
         } else {


Input:
public void redirectAndBasicAuthTest() throws Exception, ExecutionException, TimeoutException, InterruptedException {
    try {
        setUpSecondServer();
        AsyncHttpClient client = new AsyncHttpClient(new AsyncHttpClientConfig.Builder().setFollowRedirects(true).build());
        AsyncHttpClient.BoundRequestBuilder r = client.prepareGet(getTargetUrl2()).setHeader("String_Node_Str", getTargetUrl()).setRealm((new Realm.RealmBuilder()).setPrincipal(user).setPassword(admin).build());
        Future<Response> f = r.execute();
        Response resp = f.get(30, TimeUnit.SECONDS);
        assertNotNull(resp);
        assertNotNull(resp.getHeader("String_Node_Str"));
        assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
    } finally {
        stopSecondServer();
    }
}

Output:
         AsyncHttpClient client = new AsyncHttpClient(new AsyncHttpClientConfig.Builder().setFollowRedirects(true).build());
-        AsyncHttpClient.BoundRequestBuilder r = client.prepareGet(getTargetUrl2()).setHeader("String_Node_Str", getTargetUrl()).setRealm((new Realm.RealmBuilder()).setPrincipal(user).setPassword(admin).build());
+        AsyncHttpClient.BoundRequestBuilder r = client.prepareGet(getTargetUrl2()).setHeader("String_Node_Str", "String_Node_Str").setRealm((new Realm.RealmBuilder()).setPrincipal(user).setPassword(admin).build());
         Future<Response> f = r.execute();


Input:
public void setParameterHandler(final ParameterHandler parameterHandler) {
    super.setParameterHandler(parameterHandler);
    typeName = detail;
    idCategory = IDCategory.getIDCategory(attrib1);
    dimensionType = EDimensionType.valueOf(attrib2);
}

Output:
     idCategory = IDCategory.getIDCategory(attrib1);
-    dimensionType = EDimensionType.valueOf(attrib2);
+    dimensionType = EColumnType.valueOf(attrib2);
 }


Input:
public void testForStyle_shortTime() throws Exception {
    DateTimeFormatter f = DateTimeFormat.shortTime();
    DateTimeFormatter g = DateTimeFormat.forStyle("String_Node_Str");
    assertSame(g, f);
    DateTime dt = new DateTime(2004, 6, 9, 10, 20, 30, 0);
    String expect = DateFormat.getTimeInstance(DateFormat.SHORT, UK).format(dt.toDate());
    assertEquals(expect, f.print(dt));
    expect = DateFormat.getTimeInstance(DateFormat.SHORT, US).format(dt.toDate());
    assertEquals(expect, f.withLocale(US).print(dt));
    expect = DateFormat.getTimeInstance(DateFormat.SHORT, FRANCE).format(dt.toDate());
    assertEquals(expect, f.withLocale(FRANCE).print(dt));
    DateTime date = new DateTime(DateFormat.getTimeInstance(DateFormat.SHORT, FRANCE).parse(expect));
    assertEquals(date, f.withLocale(FRANCE).parseDateTime(expect));
}

Output:
     assertEquals(expect, f.withLocale(FRANCE).print(dt));
-    DateTime date = new DateTime(DateFormat.getTimeInstance(DateFormat.SHORT, FRANCE).parse(expect));
-    assertEquals(date, f.withLocale(FRANCE).parseDateTime(expect));
+    if (TimeZone.getDefault() instanceof SimpleTimeZone) {
+    } else {
+        DateTime date = new DateTime(DateFormat.getTimeInstance(DateFormat.SHORT, FRANCE).parse(expect));
+        assertEquals(date, f.withLocale(FRANCE).parseDateTime(expect));
+    }
 }


Input:
public boolean isMatchFeasible(Match match) {
    if (map.containsKey(match.getQueryNode()) || map.containsValue(match.getTargetAtom())) {
        return false;
    }
    if (!matchAtoms(match)) {
        return false;
    }
    return matchBonds(match);
}

Output:
 public boolean isMatchFeasible(Match match) {
-    if (map.containsKey(match.getQueryNode()) || map.containsValue(match.getTargetAtom())) {
+    if (map.containsKey(match.getQueryNode())) {
+        return false;
+    }
+    if (map.containsValue(match.getTargetAtom())) {
         return false;


Input:
protected void initSelectionElements() {
    boolean createValues = (values == null) || (values.length == 0);
    if (createValues) {
        values = new String[keys.length];
        for (int i = 0; i < keys.length; i++) {
            values[i] = translator.translate(keys[i]);
        }
    }
    String[] items = new String[keys.length];
    for (int i = 0; i < keys.length; i++) {
        CheckboxElementComponent ssec = new CheckboxElementComponent(getName() + "String_Node_Str" + keys[i], translator, this, i, (cssClasses == null ? null : cssClasses[i]));
        formLayoutContainer.put(getName() + "String_Node_Str" + keys[i], ssec);
        items[i] = getName() + "String_Node_Str" + keys[i];
        if (GUIInterna.isLoadPerformanceMode()) {
            if (getRootForm() != null) {
                getRootForm().getReplayableDispatchID(ssec);
            }
        }
    }
    SelectboxComponent sssc = new SelectboxComponent(getFormItemId() + "String_Node_Str", getName() + "String_Node_Str", translator, this, keys, values, cssClasses);
    formLayoutContainer.put(getName() + "String_Node_Str", sssc);
    formLayoutContainer.contextPut("String_Node_Str", getName() + "String_Node_Str");
    formLayoutContainer.contextPut("String_Node_Str", items);
    formLayoutContainer.contextPut("String_Node_Str", items.length);
    formLayoutContainer.setDirty(true);
}

Output:
     }
-    SelectboxComponent sssc = new SelectboxComponent(getFormItemId() + "String_Node_Str", getName() + "String_Node_Str", translator, this, keys, values, cssClasses);
+    String ssscId = getFormItemId() == null ? null : getFormItemId() + "String_Node_Str";
+    SelectboxComponent sssc = new SelectboxComponent(ssscId, getName() + "String_Node_Str", translator, this, keys, values, cssClasses);
     formLayoutContainer.put(getName() + "String_Node_Str", sssc);


Input:
protected String getCanonicalHost() {
    if (canonicalHostCache == null) {
        try {
            InetAddress address = InetAddress.getByName(host);
            canonicalHostCache = address.getCanonicalHostName();
        } catch (UnknownHostException ex) {
            canonicalHostCache = host;
            if (canonicalHostCache != null) {
                canonicalHostCache = canonicalHostCache.trim().toLowerCase();
            }
        }
    }
    return canonicalHostCache;
}

Output:
             if (canonicalHostCache != null) {
-                canonicalHostCache = canonicalHostCache.trim().toLowerCase();
+                canonicalHostCache = canonicalHostCache.trim().toLowerCase(Locale.US);
             }


Input:
private boolean freqHasChanged(int freq1, int freq2) {
    return Math.abs(freq1 - freq2) > freq1 * 2.0 / 100;
}

Output:
 private boolean freqHasChanged(int freq1, int freq2) {
-    return Math.abs(freq1 - freq2) > freq1 * 2.0 / 100;
+    return Math.abs(freq1 - freq2) > freq1 * 5.0 / 100;
 }


Input:
public SessionInfo getSessionInfo(String conferenceJid) {
    return sessions.get(conferenceJid).getSessionInfo();
}

Output:
 public SessionInfo getSessionInfo(String conferenceJid) {
-    return sessions.get(conferenceJid).getSessionInfo();
+    final JireconSession session = sessions.get(conferenceJid);
+    if (null != session) {
+        return session.getSessionInfo();
+    } else {
+        return null;
+    }
 }


Input:
private byte[] getSignPubs(byte[] messageHash, ECKey.ECDSASignature sig, List<byte[]> pubs) {
    for (int i = 0; i < 4; i++) {
        ECPoint point = ECKey.recoverECPointFromSignature(i, sig, messageHash);
        ECKey ecKeyCompress = new ECKey(null, point.getEncoded(true));
        ECKey ecKeyUnCompress = new ECKey(null, point.getEncoded(false));
        for (int j = 0; j < pubs.size(); i++) {
            if (Arrays.equals(ecKeyCompress.getPubKey(), pubs.get(j))) {
                return ecKeyCompress.getPubKey();
            }
            if (Arrays.equals(ecKeyUnCompress.getPubKey(), pubs.get(j))) {
                return ecKeyUnCompress.getPubKey();
            }
        }
    }
    return null;
}

Output:
         ECKey ecKeyUnCompress = new ECKey(null, point.getEncoded(false));
-        for (int j = 0; j < pubs.size(); i++) {
+        for (int j = 0; j < pubs.size(); j++) {
             if (Arrays.equals(ecKeyCompress.getPubKey(), pubs.get(j))) {


Input:
public static int[] getParents(EdgeScores scores) {
    int n = scores.root.length;
    int[] parents = new int[n];
    Arrays.fill(parents, DepTree.EMPTY_POSITION);
    ProjectiveDependencyParser.parseSingleRoot(scores.root, scores.child, parents);
    return parents;
}

Output:
     Arrays.fill(parents, DepTree.EMPTY_POSITION);
-    ProjectiveDependencyParser.parseSingleRoot(scores.root, scores.child, parents);
+    if (InsideOutsideDepParse.singleRoot) {
+        ProjectiveDependencyParser.parseSingleRoot(scores.root, scores.child, parents);
+    } else {
+        ProjectiveDependencyParser.parseMultiRoot(scores.root, scores.child, parents);
+    }
     return parents;


Input:
public void execute() throws IllegalActionException {
    super.execute();
    if (_destinations != null) {
        Iterator destinations = _destinations.iterator();
        Iterator channels = _numbers.iterator();
        Iterator parseTrees = _parseTrees.iterator();
        while (destinations.hasNext()) {
            NamedObj nextDestination = (NamedObj) destinations.next();
            if (!(nextDestination instanceof IOPort)) {
                throw new IllegalActionException(this, "String_Node_Str" + nextDestination.getFullName());
            }
            IOPort destination = (IOPort) nextDestination;
            boolean isInput = destination.isInput();
            Integer channel = (Integer) channels.next();
            ASTPtRootNode parseTree = (ASTPtRootNode) parseTrees.next();
            Token token;
            try {
                token = _parseTreeEvaluator.evaluateParseTree(parseTree, _scope);
            } catch (IllegalActionException ex) {
                throw new IllegalActionException(this, ex, "String_Node_Str");
            }
            try {
                if (token != null) {
                    Receiver[][] localReceivers = destination.getReceivers();
                    if (channel != null) {
                        destination.send(channel.intValue(), token);
                        if (_debugging) {
                            _debug(getFullName() + "String_Node_Str" + destination.getName() + "String_Node_Str" + channel.intValue() + "String_Node_Str" + token);
                        }
                    } else {
                        destination.broadcast(token);
                        if (_debugging) {
                            _debug(getFullName() + "String_Node_Str" + destination.getName() + "String_Node_Str" + token);
                        }
                    }
                }
            } catch (NoRoomException ex) {
                throw new IllegalActionException(this, "String_Node_Str" + ex.getMessage());
            } catch (UnknownResultException ex) {
            }
        }
    }
}

Output:
                     if (channel != null) {
-                        destination.send(channel.intValue(), token);
+                        int chanelValue = channel.intValue();
+                        destination.send(chanelValue, token);
+                        if (isInput) {
+                            localReceivers[chanelValue][0].put(token);
+                        }
                         if (_debugging) {


Input:
public void finish() {
    Intent data = new Intent();
    data.putExtra("String_Node_Str", viewPager.getCurrentItem());
    setResult(RESULT_OK, data);
    sharedAdapterHelper.removeAdapter(viewPager.getAdapter(), articlesHelperListener);
    super.finish();
}

Output:
     Intent data = new Intent();
-    data.putExtra("String_Node_Str", viewPager.getCurrentItem());
+    if (viewPager != null) {
+        data.putExtra("String_Node_Str", viewPager.getCurrentItem());
+        sharedAdapterHelper.removeAdapter(viewPager.getAdapter(), articlesHelperListener);
+    }
     setResult(RESULT_OK, data);


Input:
public void remove(final EmergencyStopTask task) {
    checkNotNull(task, "String_Node_Str");
    synchronized (this.tasks) {
        this.tasks.remove(task);
    }
}

Output:
     checkNotNull(task, "String_Node_Str");
-    synchronized (this.tasks) {
-        this.tasks.remove(task);
-    }
+    this.tasks.remove(task);
 }


Input:
public GlobalAction getGlobalAction() {
    return this.question.getGlobalAction();
}

Output:
 public GlobalAction getGlobalAction() {
-    return this.question.getGlobalAction();
+    return getWrapped().getGlobalAction();
 }


Input:
private Object[] filterOutDuplicatedElems(List<XSDElementDeclaration> xsdElementDeclarations) {
    List<XSDElementDeclaration> list = new ArrayList<XSDElementDeclaration>();
    for (XSDElementDeclaration el : (XSDElementDeclaration[]) xsdElementDeclarations.toArray(new XSDElementDeclaration[xsdElementDeclarations.size()])) {
        boolean exist = false;
        for (XSDElementDeclaration xsdEl : list) {
            if (xsdEl.getName().equals(el.getName()) && xsdEl.getTargetNamespace() != null && el.getTargetNamespace() != null && xsdEl.getTargetNamespace().equals(el.getTargetNamespace())) {
                exist = true;
                break;
            }
        }
        if (!exist) {
            if ((conceptName != null && el.getName().equals(conceptName)) || conceptName == null)
                list.add(el);
        }
    }
    return list.toArray(new Object[] {});
}

Output:
         if (!exist) {
-            if ((conceptName != null && el.getName().equals(conceptName)) || conceptName == null)
+            if ((conceptName != null && el.getName().equals(conceptName)) || (conceptName == null && (el.getTargetNamespace() != null && !el.getTargetNamespace().equals(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001)) || el.getTargetNamespace() == null))
                 list.add(el);


Input:
public void onResponseReceived(Request request, Response response) {
    if (response.getStatusCode() != Response.SC_OK) {
        callback.onFailure(getErrorAsThrowable(response));
    } else if (response.getHeader(ERROR_HEADER) != null) {
        callback.onFailure(getErrorAsThrowable(response));
    } else {
        String responseText = response.getText();
        GWT.log("String_Node_Str" + responseText);
        MetricsDataResponse metricsResponse = MetricsDataResponse.fromJSON(response.getText());
        if (metricsResponse == null) {
            GWT.log("String_Node_Str" + response.getText());
            callback.onFailure(new Throwable(ConsoleUtil.messages.badOrMissingResponseData()));
        } else {
            JsArray<MetricGroupDataJS> rows = metricsResponse.getReturnData();
            List<MetricGroupData> results = new ArrayList<MetricGroupData>();
            if (rows != null) {
                for (int i = 0; i < rows.length(); i++) {
                    MetricGroupDataJS js = rows.get(i);
                    results.add(js);
                }
            }
            data.setReturnData(results);
            callback.onSuccess(data);
        }
    }
}

Output:
         callback.onFailure(getErrorAsThrowable(response));
-    } else if (response.getHeader(ERROR_HEADER) != null) {
+    } else if (response.getHeader(ERROR_HEADER) != null && response.getHeader(ERROR_HEADER).length() > 0) {
         callback.onFailure(getErrorAsThrowable(response));


Input:
private void init() {
    Matcher matcher = scopPattern.matcher(name);
    if (matcher.matches()) {
        mySource = Source.SCOP;
        pdbId = matcher.group(1);
        chainId = matcher.group(2);
        return;
    }
    if (name.startsWith(AtomCache.PDP_DOMAIN_IDENTIFIER)) {
        mySource = Source.PDP;
        matcher = PDPDomain.PDP_NAME_PATTERN.matcher(name);
        if (!matcher.matches()) {
            throw new IllegalArgumentException("String_Node_Str");
        }
        pdbId = matcher.group(1);
        chainId = matcher.group(2);
        return;
    }
    matcher = cathPattern.matcher(name);
    if (matcher.matches()) {
        mySource = Source.CATH;
        pdbId = matcher.group(1);
        chainId = matcher.group(2);
        return;
    }
    try {
        new URL(name);
        mySource = Source.URL;
        pdbId = null;
        chainId = null;
        return;
    } catch (MalformedURLException e) {
    }
    File file = new File(FileDownloadUtils.expandUserHome(name));
    if (file.exists()) {
        mySource = Source.FILE;
        pdbId = null;
        chainId = null;
        return;
    }
    mySource = Source.PDB;
    SubstructureIdentifier si = new SubstructureIdentifier(getIdentifier());
    realized = si;
    pdbId = si.getPdbId();
    Set<String> chains = getChainIds(si);
    if (chains.size() == 1) {
        this.chainId = chains.iterator().next();
    } else if (chains.size() > 1) {
        this.chainId = "String_Node_Str";
    } else {
        this.chainId = null;
    }
}

Output:
     File file = new File(FileDownloadUtils.expandUserHome(name));
-    if (file.exists()) {
+    if (file.exists() || (file.getParentFile() != null && file.getParentFile().exists())) {
         mySource = Source.FILE;


Input:
public void txItem(Map<String, ElementDefinitionBindingComponent> txmap, StringBuilder b, String path) {
    ElementDefinitionBindingComponent tx = txmap.get(path);
    String vss = "String_Node_Str";
    String vsn = "String_Node_Str";
    if (tx.hasValueSet()) {
        String uri = tx.getValueSet().primitiveValue();
        ValueSet vs = context.fetchResource(ValueSet.class, canonicalise(uri));
        if (vs == null) {
            BindingResolution br = igp.resolveActualUrl(uri);
            if (br.url == null)
                vss = "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
            else if (Utilities.isAbsoluteUrl(br.url))
                vss = "String_Node_Str" + br.url + "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
            else
                vss = "String_Node_Str" + prefix + br.url + "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
        } else {
            String p = vs.getUserString("String_Node_Str");
            if (p == null)
                vss = "String_Node_Str" + Utilities.escapeXml(gt(vs.getNameElement())) + "String_Node_Str" + translate("String_Node_Str", "String_Node_Str") + "String_Node_Str";
            else if (p.startsWith("String_Node_Str"))
                vss = "String_Node_Str" + p + "String_Node_Str" + Utilities.escapeXml(gt(vs.getNameElement())) + "String_Node_Str";
            else
                vss = "String_Node_Str" + p + "String_Node_Str" + Utilities.escapeXml(gt(vs.getNameElement())) + "String_Node_Str";
            vsn = gt(vs.getNameElement());
        }
    }
    if (vsn.equals("String_Node_Str"))
        if (tx.getValueSet() != null)
            System.out.println("String_Node_Str" + path + "String_Node_Str" + tx.getValueSet().primitiveValue() + "String_Node_Str");
        else
            System.out.println("String_Node_Str" + path + "String_Node_Str");
    b.append("String_Node_Str").append(path).append("String_Node_Str").append(Utilities.escapeXml(vsn)).append("String_Node_Str").append(prefix).append("String_Node_Str").append(tx.getStrength() == null ? "String_Node_Str" : egt(tx.getStrengthElement())).append("String_Node_Str").append(tx.getStrength() == null ? "String_Node_Str" : egt(tx.getStrengthElement())).append("String_Node_Str").append(vss).append("String_Node_Str");
}

Output:
         String uri = tx.getValueSet().primitiveValue();
-        ValueSet vs = context.fetchResource(ValueSet.class, canonicalise(uri));
-        if (vs == null) {
-            BindingResolution br = igp.resolveActualUrl(uri);
-            if (br.url == null)
-                vss = "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
-            else if (Utilities.isAbsoluteUrl(br.url))
-                vss = "String_Node_Str" + br.url + "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
-            else
-                vss = "String_Node_Str" + prefix + br.url + "String_Node_Str" + Utilities.escapeXml(br.display) + "String_Node_Str";
+        String name = getSpecialValueSetName(uri);
+        if (name != null) {
+            vss = "String_Node_Str" + uri + "String_Node_Str" + Utilities.escapeXml(name) + "String_Node_Str";
+            vsn = name;
         } else {


Input:
public void writeEdgeData(XMLStreamWriter writer, EdgeDataImpl edgeData) throws XMLStreamException {
    writer.writeStartElement(ELEMENT_EDGEDATA);
    AbstractEdge edge = edgeData.getEdge();
    writer.writeAttribute("String_Node_Str", String.valueOf(edge.getSource().getPre()));
    writer.writeAttribute("String_Node_Str", String.valueOf(edge.getTarget().getPre()));
    if (edgeData.getId() != null && !edgeData.getId().equals("String_Node_Str" + edge.getId())) {
        writer.writeAttribute("String_Node_Str", edgeData.getId());
    }
    writer.writeStartElement(ELEMENT_EDGEDATA_COLOR);
    writer.writeAttribute("String_Node_Str", String.valueOf(edgeData.r()));
    writer.writeAttribute("String_Node_Str", String.valueOf(edgeData.g()));
    writer.writeAttribute("String_Node_Str", String.valueOf(edgeData.b()));
    writer.writeAttribute("String_Node_Str", String.valueOf(edgeData.alpha()));
    writer.writeEndElement();
    writer.writeEndElement();
}

Output:
     writer.writeAttribute("String_Node_Str", String.valueOf(edge.getTarget().getPre()));
-    if (edgeData.getId() != null && !edgeData.getId().equals("String_Node_Str" + edge.getId())) {
+    if (edgeData.getId() != null && !edgeData.getId().equals(String.valueOf(edge.getId()))) {
         writer.writeAttribute("String_Node_Str", edgeData.getId());


Input:
protected void onEvent(Event event) {
    log.info("String_Node_Str" + event.getClass() + "String_Node_Str");
    MemberTerminatedEvent memberTerminatedEvent = (MemberTerminatedEvent) event;
    String clusterDomain = memberTerminatedEvent.getClusterId();
    Set<CartridgeSubscription> cartridgeSubscriptions = getCartridgeSubscription(clusterDomain);
    if (cartridgeSubscriptions != null) {
        Cluster cluster;
        TopologyManager.acquireReadLock();
        try {
            for (CartridgeSubscription cartridgeSubscription : cartridgeSubscriptions) {
                cluster = TopologyManager.getTopology().getService(cartridgeSubscription.getType()).getCluster(cartridgeSubscription.getClusterDomain());
                Member terminatedMember = cluster.getMember(memberTerminatedEvent.getMemberId());
                cluster.removeMember(terminatedMember);
                if (log.isDebugEnabled()) {
                    log.debug("String_Node_Str" + memberTerminatedEvent.getMemberId() + "String_Node_Str");
                }
                TopologyClusterInformationModel.getInstance().addCluster(cartridgeSubscription.getSubscriber().getTenantId(), cartridgeSubscription.getType(), cartridgeSubscription.getAlias(), cluster);
            }
        } finally {
            TopologyManager.releaseReadLock();
        }
    }
}

Output:
                 cluster = TopologyManager.getTopology().getService(cartridgeSubscription.getType()).getCluster(cartridgeSubscription.getClusterDomain());
-                Member terminatedMember = cluster.getMember(memberTerminatedEvent.getMemberId());
-                cluster.removeMember(terminatedMember);
-                if (log.isDebugEnabled()) {
-                    log.debug("String_Node_Str" + memberTerminatedEvent.getMemberId() + "String_Node_Str");
+                if (cluster.memberExists(memberTerminatedEvent.getMemberId())) {
+                    Member terminatedMember = cluster.getMember(memberTerminatedEvent.getMemberId());
+                    cluster.removeMember(terminatedMember);
+                    if (log.isDebugEnabled()) {
+                        log.debug("String_Node_Str" + memberTerminatedEvent.getMemberId() + "String_Node_Str");
+                    }
                 }


Input:
public Database getTargetDatabase() {
    return targetDb;
}

Output:
 public Database getTargetDatabase() {
-    return targetDb;
+    return cdmDb;
 }


Input:
private List buildMeasures() {
    List retValue = new ArrayList();
    CrosstabReportItemHandle crosstab = getCrosstabReportItemHandle();
    int count = crosstab.getMeasureCount();
    for (int i = 0; i < count; i++) {
        MeasureViewHandle measureHandle = crosstab.getMeasure(i);
        CrosstabCellHandle handle = measureHandle.getCell();
        CrosstabCellAdapter adapter = factory.createCrosstabCellAdapter(ICrosstabCellAdapterFactory.CELL_MEASURE, handle, 1, -1, i + 1, -1, isVertical());
        retValue.add(adapter);
        int addregationCellCount = measureHandle.getAggregationCount();
        for (int j = 0; j < addregationCellCount; j++) {
            AggregationCellHandle cell = measureHandle.getAggregationCell(j);
            LevelViewHandle levelViewHandle = cell.getLevelView(getWorkArea(ICrosstabConstants.COLUMN_AXIS_TYPE));
            int measureCount = count;
            Integer temp;
            List measuresHandles;
            int position;
            if (levelViewHandle == null) {
                temp = (Integer) map.get(getWorkArea(COLUMNAREA_COLUMN));
                measuresHandles = crosstab.getAggregationMeasures(getWorkArea(ICrosstabConstants.COLUMN_AXIS_TYPE));
            } else {
                temp = (Integer) map.get(levelViewHandle);
                measuresHandles = levelViewHandle.getAggregationMeasures();
            }
            if (temp == null) {
                throw new RuntimeException("String_Node_Str");
            }
            measureCount = measuresHandles.size();
            position = measuresHandles.indexOf(measureHandle);
            if (temp.intValue() <= count) {
                measureCount = count;
                position = i;
            }
            int column = temp.intValue() - (measureCount - position) + 1;
            levelViewHandle = cell.getLevelView(getWorkArea(ICrosstabConstants.ROW_AXIS_TYPE));
            if (levelViewHandle == null) {
                temp = (Integer) map.get(getWorkArea(ROWAREA_ROW));
            } else {
                temp = (Integer) map.get(levelViewHandle);
            }
            if (temp == null) {
                throw new RuntimeException("String_Node_Str");
            }
            int row = temp.intValue();
            CrosstabCellAdapter aggregationCell = factory.createCrosstabCellAdapter(ICrosstabCellAdapterFactory.CELL_MEASURE_AGGREGATION, cell, row, 1, column, 1, isVertical());
            retValue.add(aggregationCell);
        }
    }
    if (retValue.isEmpty()) {
        CrosstabCellAdapter first = factory.createCrosstabCellAdapter(ICrosstabCellAdapterFactory.CELL_MEASURE_VIRTUAL, null, 1, -1, 1, -1, false);
        retValue.add(first);
    }
    return retValue;
}

Output:
             }
-            int column = temp.intValue() - (measureCount - position) + 1;
+            int tempPosition = temp.intValue() >= measureCount ? temp.intValue() : measureCount;
+            int column = tempPosition - (measureCount - position) + 1;
             levelViewHandle = cell.getLevelView(getWorkArea(ICrosstabConstants.ROW_AXIS_TYPE));


Input:
private static void fuseNonRecursive(Block block) {
    Iterator<Continuation> it = block.continuationIterator();
    assert (block.getContinuations().size() > 1);
    LinkedList<Continuation> mergeCands = new LinkedList<Continuation>(block.getContinuations());
    mergeCands.removeFirst();
    while (it.hasNext()) {
        if (mergeCands.isEmpty()) {
            break;
        }
        Continuation c = it.next();
        switch(c.getType()) {
            case IF_STATEMENT:
                fuseIfStatement(it, mergeCands, (IfStatement) c);
                break;
            case FOREACH_LOOP:
                fuseForeachLoop(it, mergeCands, (ForeachLoop) c);
                break;
            case RANGE_LOOP:
                fuseRangeLoop(it, mergeCands, (RangeLoop) c);
                break;
            default:
                break;
        }
        mergeCands.removeFirst();
    }
}

Output:
             case FOREACH_LOOP:
-                fuseForeachLoop(it, mergeCands, (ForeachLoop) c);
+                fuseForeachLoop(function, it, mergeCands, (ForeachLoop) c);
                 break;


Input:
void initialize() throws SkypeException {
    try {
        String response = Connector.getInstance().execute("String_Node_Str" + name);
        Utils.checkError(response);
        Connector.getInstance().addConnectorListener(dataListener);
        shutdownHookForFinish = new Thread() {
            public void run() {
                try {
                    Connector.getInstance().execute("String_Node_Str" + Application.this.getName());
                } catch (ConnectorException e) {
                }
            }
        };
        Runtime.getRuntime().addShutdownHook(shutdownHookForFinish);
    } catch (ConnectorException e) {
        Utils.convertToSkypeException(e);
    }
}

Output:
         Utils.checkError(response);
-        Connector.getInstance().addConnectorListener(dataListener);
+        Connector.getInstance().addConnectorListener(dataListener, true, true);
         shutdownHookForFinish = new Thread() {


Input:
private boolean processIdFieldWorks(MetaAbstractClass metaClass, DboTableMeta metaDbo, Field field) {
    if (!field.isAnnotationPresent(NoSqlId.class))
        return false;
    if (metaClass.getIdField() != null) {
        Field existingField = metaClass.getIdField().getField();
        if (field.equals(existingField)) {
            log.warn("String_Node_Str" + metaClass.getClass() + "String_Node_Str", new RuntimeException().fillInStackTrace());
            log.warn("String_Node_Str", metaClass.getFirstTrace());
            return true;
        } else {
            throw new IllegalArgumentException("String_Node_Str" + metaClass.getClass() + "String_Node_Str" + field + "String_Node_Str" + existingField);
        }
    } else if (log.isDebugEnabled()) {
        metaClass.setFirstTrace(new RuntimeException("String_Node_Str" + field + "String_Node_Str" + metaClass).fillInStackTrace());
    }
    MetaIdField idField = inspectorField.processId(metaDbo, field, metaClass);
    metaClass.setIdField(idField);
    return true;
}

Output:
             return true;
-        } else {
+        } else if (!metaClass.getMetaDbo().isEmbeddable()) {
             throw new IllegalArgumentException("String_Node_Str" + metaClass.getClass() + "String_Node_Str" + field + "String_Node_Str" + existingField);


Input:
public Class loadClass(String className) throws ClassNotFoundException {
    try {
        return super.loadClass(className);
    } catch (ClassNotFoundException ex) {
        return loader.loadClass(className);
    }
}

Output:
     try {
-        return super.loadClass(className);
+        return Class.forName(className);
     } catch (ClassNotFoundException ex) {


Input:
private void handleAreaTag() {
    String sName = "String_Node_Str";
    String sCoords = "String_Node_Str";
    String sShape = "String_Node_Str";
    String sExternalLink = "String_Node_Str";
    for (int iAttributeIndex = 0; iAttributeIndex < attributes.getLength(); iAttributeIndex++) {
        sAttributeName = attributes.getLocalName(iAttributeIndex);
        if ("String_Node_Str".equals(sAttributeName)) {
            sAttributeName = attributes.getQName(iAttributeIndex);
        }
        if (sAttributeName.equals("String_Node_Str")) {
            sShape = attributes.getValue(iAttributeIndex);
        } else if (sAttributeName.equals("String_Node_Str")) {
            sCoords = attributes.getValue(iAttributeIndex);
        } else if (sAttributeName.equals("String_Node_Str")) {
            sExternalLink = attributes.getValue(iAttributeIndex);
            if (sExternalLink.contains("String_Node_Str")) {
                sName = sExternalLink.substring(sExternalLink.lastIndexOf("String_Node_Str") + 5, sExternalLink.length());
            }
        }
    }
    IIDMappingManager genomeIdManager = generalManager.getIDMappingManager();
    Set<Integer> iSetDavidID = (Set<Integer>) genomeIdManager.<String, Integer>getMultiID(EMappingType.BIOCARTA_GENE_ID_2_DAVID, sName);
    if (iSetDavidID == null)
        return;
    for (Integer iDavidId : iSetDavidID) {
        if (iDavidId == null || iDavidId == -1 || iDavidId == 0) {
            generalManager.getLogger().log(Level.FINE, "String_Node_Str" + sName + "String_Node_Str");
            return;
        }
        IGraphItem vertex = pathwayItemManager.createVertexGene(sName, "String_Node_Str", BIOCARTA_EXTERNAL_URL_VERTEX + sExternalLink, "String_Node_Str", iDavidId);
        generalManager.getPathwayItemManager().createVertexRep(currentPathway, vertex, sName, sShape, sCoords);
    }
}

Output:
         return;
-    for (Integer iDavidId : iSetDavidID) {
-        if (iDavidId == null || iDavidId == -1 || iDavidId == 0) {
-            generalManager.getLogger().log(Level.FINE, "String_Node_Str" + sName + "String_Node_Str");
-            return;
-        }
-        IGraphItem vertex = pathwayItemManager.createVertexGene(sName, "String_Node_Str", BIOCARTA_EXTERNAL_URL_VERTEX + sExternalLink, "String_Node_Str", iDavidId);
-        generalManager.getPathwayItemManager().createVertexRep(currentPathway, vertex, sName, sShape, sCoords);
-    }
+    ArrayList<IGraphItem> alVertex = pathwayItemManager.createVertexGene(sName, "String_Node_Str", BIOCARTA_EXTERNAL_URL_VERTEX + sExternalLink, "String_Node_Str", iSetDavidID);
+    generalManager.getPathwayItemManager().createVertexRep(currentPathway, alVertex, sName, sShape, sCoords);
 }


Input:
private void loadStaticCategories() {
    String[] fileNames = { "String_Node_Str", "String_Node_Str" };
    LinkedList<CategoryEntry> staticCategoryList;
    for (String fileName : fileNames) {
        staticCategoryList = new LinkedList<CategoryEntry>();
        InputStream is = getClass().getResourceAsStream("String_Node_Str" + fileName + "String_Node_Str");
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                String regex = line;
                CategoryEntry categoryEntry = new CategoryEntry(fileName, Pattern.quote(regex));
                staticCategoryList.add(categoryEntry);
            }
        } catch (IOException ex) {
            BurpCallbacks.getInstance().print(ex.toString());
        }
        staticCategories.add(staticCategoryList);
    }
}

Output:
                 String regex = line;
-                CategoryEntry categoryEntry = new CategoryEntry(fileName, Pattern.quote(regex));
+                CategoryEntry categoryEntry = new CategoryEntry(fileName, "String_Node_Str" + Pattern.quote(regex) + "String_Node_Str");
                 staticCategoryList.add(categoryEntry);


Input:
public boolean onCommand(CommandSender sender, Command command, String commandLabel, String[] args) {
    if (!(sender instanceof Player)) {
        sender.sendMessage(MessageUtils.mustBeIngameMessage);
        return true;
    }
    Player player = (Player) sender;
    HumanNPC npc = null;
    boolean returnval = false;
    if (NPCManager.validateSelected((Player) sender))
        npc = NPCManager.getNPC(NPCManager.NPCSelected.get(player.getName()));
    else {
        player.sendMessage(ChatColor.RED + MessageUtils.mustHaveNPCSelectedMessage);
        return true;
    }
    if (!NPCManager.validateOwnership(npc.getUID(), player)) {
        player.sendMessage(MessageUtils.notOwnerMessage);
        return true;
    }
    if (!npc.isTrader()) {
        player.sendMessage(ChatColor.RED + "String_Node_Str");
        return true;
    } else {
        if (args.length == 3 && args[0].equals("String_Node_Str")) {
            if (BasicExecutor.hasPermission("String_Node_Str", sender)) {
                try {
                    if (!EconomyHandler.useIconomy())
                        player.sendMessage(ChatColor.GRAY + "String_Node_Str");
                    else
                        changeBalance(player, npc, args);
                } catch (NumberFormatException e) {
                    player.sendMessage(ChatColor.RED + "String_Node_Str");
                }
            } else
                player.sendMessage(MessageUtils.noPermissionsMessage);
            returnval = true;
        } else if (args.length == 3 && (args[0].contains("String_Node_Str") || args[0].contains("String_Node_Str"))) {
            if (BasicExecutor.hasPermission("String_Node_Str", sender)) {
                changeTraderBuySell(npc, player, args[1], args[2], args[0].contains("String_Node_Str"));
            } else
                player.sendMessage(MessageUtils.noPermissionsMessage);
            returnval = true;
        } else if (args.length == 2 && (args[0].contains("String_Node_Str"))) {
            if (BasicExecutor.hasPermission("String_Node_Str", sender)) {
                changeUnlimited(npc, sender, args[1]);
            } else
                player.sendMessage(MessageUtils.noPermissionsMessage);
            returnval = true;
        } else if (args.length == 3 && args[0].contains("String_Node_Str") && (args[1].contains("String_Node_Str") || args[1].contains("String_Node_Str"))) {
            if (BasicExecutor.hasPermission("String_Node_Str", sender)) {
                changeTraderBuySell(npc, player, args[1], args[2], args[0].contains("String_Node_Str"));
            } else
                player.sendMessage(MessageUtils.noPermissionsMessage);
            returnval = true;
        }
        TraderPropertyPool.saveTraderState(npc);
    }
    return returnval;
}

Output:
             if (BasicExecutor.hasPermission("String_Node_Str", sender)) {
-                changeTraderBuySell(npc, player, args[1], args[2], args[0].contains("String_Node_Str"));
+                changeTraderBuySell(player, npc, args[1], args[2], args[0].contains("String_Node_Str"));
             } else


Input:
public void onClick(View view) {
    Log.d(getClass().getName(), "String_Node_Str");
    AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
    alert.setTitle(R.string.switch_listener_show_logs_title);
    WebView wv = new WebView(getActivity());
    final StringBuilder dataBuilder = new StringBuilder();
    dataBuilder.append("String_Node_Str");
    for (final String logLine : logs) {
        dataBuilder.append("String_Node_Str").append(logLine).append("String_Node_Str");
    }
    dataBuilder.append("String_Node_Str");
    wv.loadDataWithBaseURL("String_Node_Str", dataBuilder.toString(), "String_Node_Str", "String_Node_Str", "String_Node_Str");
    alert.setView(wv);
    alert.setNegativeButton(R.string.switch_listener_show_logs_close, new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            dialog.dismiss();
        }
    });
    alert.show();
}

Output:
     Log.d(getClass().getName(), "String_Node_Str");
-    AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
+    final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
     alert.setTitle(R.string.switch_listener_show_logs_title);


Input:
private void doNewMaster(Pair<Master, Machine> master, StoreId storeId, Exception e) {
    waitForStartupLatch();
    try {
        msgLog.logMessage("String_Node_Str" + master + "String_Node_Str", e, true);
        reevaluateMyself(master, storeId);
    } catch (ZooKeeperException ee) {
        msgLog.logMessage("String_Node_Str", ee);
    } catch (HaCommunicationException ee) {
        msgLog.logMessage("String_Node_Str", ee);
    } catch (Throwable t) {
        t.printStackTrace();
        msgLog.logMessage("String_Node_Str" + t + "String_Node_Str", true);
        shutdown(t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        }
        throw new RuntimeException(t);
    }
}

Output:
         msgLog.logMessage("String_Node_Str" + t + "String_Node_Str", true);
-        shutdown(t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
+        shutdown(t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t), false);
         if (t instanceof RuntimeException) {


Input:
public static boolean cancellingBlockBreak(Block block, Player player) {
    if (player != null && (Permission.has(player, Permission.ADMIN) || Permission.has(player, Permission.MOD)))
        return false;
    if (uSign.isSign(block))
        block.getState().update();
    Sign sign = uBlock.findRestrictedSign(block);
    if (sign != null && isCorrectSign(sign, block))
        return true;
    sign = uBlock.findSign(block);
    return sign != null && (isCorrectSign(sign, block) && playerIsNotOwner(player, sign));
}

Output:
     Sign sign = uBlock.findRestrictedSign(block);
-    if (sign != null && isCorrectSign(sign, block))
+    if (isCorrectSign(sign, block))
         return true;