Input:
private void drawPath(DrawContext dc) {
    if (frameCount <= 0 || dc.isPickingMode()) {
        return;
    }
    GL2 gl = dc.getGL().getGL2();
    OGLStackHandler stack = new OGLStackHandler();
    stack.pushAttrib(gl, GL2.GL_CURRENT_BIT | GL2.GL_POINT_BIT | GL2.GL_LINE_BIT | GL2.GL_HINT_BIT | GL2.GL_LIGHTING_BIT | GL2.GL_DEPTH_BUFFER_BIT);
    stack.pushClientAttrib(gl, GL2.GL_CLIENT_VERTEX_ARRAY_BIT);
    boolean popRefCenter = false;
    try {
        synchronized (pathBufferLock) {
            if (pathReferenceCenter != null) {
                dc.getView().pushReferenceCenter(dc, pathReferenceCenter);
                popRefCenter = true;
            }
            gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
            gl.glEnableClientState(GL2.GL_COLOR_ARRAY);
            gl.glShadeModel(GL2.GL_SMOOTH);
            gl.glEnable(GL2.GL_LINE_SMOOTH);
            gl.glEnable(GL2.GL_POINT_SMOOTH);
            gl.glEnable(GL2.GL_BLEND);
            gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
            gl.glHint(GL2.GL_LINE_SMOOTH_HINT, GL2.GL_NICEST);
            gl.glHint(GL2.GL_POINT_SMOOTH_HINT, GL2.GL_NICEST);
            gl.glLineWidth(2.0f);
            gl.glPointSize(2.0f);
            int numberOfPointsInPath = animation.getFrameOfLastKeyFrame() - animation.getFrameOfFirstKeyFrame() + 1;
            if (numberOfPointsInPath <= 1) {
                return;
            }
            if (enableDepthTesting) {
                gl.glEnable(GL2.GL_DEPTH_TEST);
            } else {
                gl.glDisable(GL2.GL_DEPTH_TEST);
            }
            gl.glShadeModel(GL2.GL_FLAT);
            gl.glColorPointer(3, GL2.GL_DOUBLE, 0, pathColourFrontBuffer);
            gl.glVertexPointer(3, GL2.GL_DOUBLE, 0, pathVertexFrontBuffer);
            gl.glDepthMask(false);
            gl.glDrawArrays(GL2.GL_LINE_STRIP, 0, numberOfPointsInPath);
            gl.glDrawArrays(GL2.GL_POINTS, 0, numberOfPointsInPath);
            gl.glDepthMask(true);
            gl.glDrawArrays(GL2.GL_LINE_STRIP, 0, numberOfPointsInPath);
        }
    } finally {
        if (popRefCenter) {
            dc.getView().popReferenceCenter(dc);
        }
        stack.pop(gl);
    }
}

Output:
         synchronized (pathBufferLock) {
-            if (pathReferenceCenter != null) {
-                dc.getView().pushReferenceCenter(dc, pathReferenceCenter);
+            if (pathReferenceCenterFront != null) {
+                dc.getView().pushReferenceCenter(dc, pathReferenceCenterFront);
                 popRefCenter = true;


Input:
public boolean isPartitionMigrating(int partitionId) {
    final MigratingPartition currentMigratingPartition = migratingPartition;
    return currentMigratingPartition != null && currentMigratingPartition.getPartitionId() == partitionId;
}

Output:
     final MigratingPartition currentMigratingPartition = migratingPartition;
-    return currentMigratingPartition != null && currentMigratingPartition.getPartitionId() == partitionId;
+    return currentMigratingPartition != null && currentMigratingPartition.getPartitionId() == partitionId && currentMigratingPartition.getReplicaIndex() == replicaIndex;
 }


Input:
private void onCatchFirePreCheck(World world, BlockPos pos, int chance, Random random, int age, EnumFacing facing, CallbackInfo callbackInfo) {
    if (!world.isRemote) {
        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos, NamedCause.of(NamedCause.FIRE_SPREAD, world)).isCancelled()) {
            callbackInfo.cancel();
        }
    }
}

Output:
     if (!world.isRemote) {
-        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos, NamedCause.of(NamedCause.FIRE_SPREAD, world)).isCancelled()) {
+        Sponge.getCauseStackManager().addContext(EventContextKeys.FIRE_SPREAD, (org.spongepowered.api.world.World) world);
+        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos).isCancelled()) {
             callbackInfo.cancel();


Input:
public Void call() throws Exception {
    Locations.getCompatibleLocation(locationFactory, oldMeta.locationPath, oldMeta.locationURI).delete();
    return null;
}

Output:
 public Void call() throws Exception {
-    Locations.getCompatibleLocation(locationFactory, oldMeta.locationPath, oldMeta.locationURI).delete();
+    Locations.getLocationFromAbsolutePath(locationFactory, oldMeta.getLocationPath()).delete();
     return null;


Input:
public void propertyChange(PropertyChangeEvent event) {
    if (note == null || note.isDisposed()) {
        ViewerPlugin.getDefault().getPluginPreferences().removePropertyChangeListener(this);
        return;
    }
    if (WebViewer.PREVIEW_MAXROW.equals(event.getProperty())) {
        note.setText(getDisplayInfoText(ViewerPlugin.getDefault().getPluginPreferences().getString(WebViewer.PREVIEW_MAXROW)), true, true);
        buttonTray.layout();
    }
}

Output:
 public void propertyChange(PropertyChangeEvent event) {
-    if (note == null || note.isDisposed()) {
-        ViewerPlugin.getDefault().getPluginPreferences().removePropertyChangeListener(this);
-        return;
-    }
-    if (WebViewer.PREVIEW_MAXROW.equals(event.getProperty())) {
+    if (note != null && !note.isDisposed() && WebViewer.PREVIEW_MAXROW.equals(event.getProperty())) {
         note.setText(getDisplayInfoText(ViewerPlugin.getDefault().getPluginPreferences().getString(WebViewer.PREVIEW_MAXROW)), true, true);


Input:
public void selectForInput(boolean selected) {
    selectedForInput = selected;
    enableInputListeners(selected);
}

Output:
     selectedForInput = selected;
-    enableInputListeners(selected);
+    if (avatarCharacter != null) {
+        WorldManager wm = ClientContextJME.getWorldManager();
+        ((WlAvatarContext) avatarCharacter.getContext()).getBehaviorManager().setEnable(false);
+        if (controlScheme == null && selectedForInput) {
+            controlScheme = new DefaultCharacterControls(ClientContextJME.getWorldManager());
+            ((AvatarControls) wm.getUserData(AvatarControls.class)).setDefault(controlScheme);
+            avatarCharacter.selectForInput();
+            controlScheme.addCharacterToTeam(avatarCharacter);
+            controlScheme.setCharacter(avatarCharacter);
+        }
+        if (selectedForInput) {
+            avatarCharacter.getContext().getController().addCharacterMotionListener(characterMotionListener);
+            avatarCharacter.getContext().addGameContextListener(gameContextListener);
+            avatarCharacter.selectForInput();
+            controlScheme.addCharacterToTeam(avatarCharacter);
+            controlScheme.setCharacter(avatarCharacter);
+            ProcessorCollectionComponent pcc = avatarCharacter.getComponent(ProcessorCollectionComponent.class);
+            ProcessorComponent characterProcessor = null;
+            ProcessorComponent characterAnimationProcessor = null;
+            for (ProcessorComponent pc : pcc.getProcessors()) {
+                if (pc instanceof CharacterProcessor)
+                    characterProcessor = pc;
+                else if (pc instanceof CharacterAnimationProcessor) {
+                    characterAnimationProcessor = pc;
+                    break;
+                }
+            }
+            cameraChainedProcessor = null;
+            if (characterAnimationProcessor != null) {
+                cameraChainedProcessor = characterAnimationProcessor;
+            } else if (characterProcessor != null)
+                cameraChainedProcessor = characterProcessor;
+            if (cameraChainedProcessor != null) {
+                cameraChainedProcessor.addToChain(ViewManager.getViewManager().getCameraProcessor());
+                cameraChainedProcessor.setRunInRenderer(true);
+            }
+        } else {
+            avatarCharacter.getContext().getController().removeCharacterMotionListener(characterMotionListener);
+            avatarCharacter.getContext().removeGameContextListener(gameContextListener);
+            if (controlScheme != null) {
+                controlScheme.clearCharacterTeam();
+            }
+            if (cameraChainedProcessor != null) {
+                cameraChainedProcessor.removeFromChain(ViewManager.getViewManager().getCameraProcessor());
+                cameraChainedProcessor = null;
+            }
+        }
+    } else {
+    }
 }


Input:
public NetworkGroup apply(final String arg0) {
    EntityTransaction db = Entities.get(NetworkGroup.class);
    try {
        SimpleExpression naturalId = Restrictions.like("String_Node_Str", arg0.replace(userFullName.getAccountNumber() + "String_Node_Str", "String_Node_Str") + "String_Node_Str");
        final NetworkGroup result = (NetworkGroup) Entities.createCriteria(NetworkGroup.class).add(naturalId).uniqueResult();
        db.commit();
        return result;
    } catch (Exception ex) {
        Logs.exhaust().error(ex, ex);
        db.rollback();
        throw Exceptions.toUndeclared(ex);
    }
}

Output:
     } catch (Exception ex) {
-        Logs.exhaust().error(ex, ex);
+        Logs.extreme().error(ex, ex);
         db.rollback();


Input:
public void setImage(byte[] data) {
    imageData = data;
    if (ImageTag.getImageFormat(data).equals("String_Node_Str")) {
        BufferedImage image = getImage(new ArrayList<Tag>());
        bitmapAlphaData = new byte[image.getWidth() * image.getHeight()];
        for (int i = 0; i < bitmapAlphaData.length; i++) {
            bitmapAlphaData[i] = (byte) 255;
        }
    } else {
        bitmapAlphaData = new byte[0];
    }
}

Output:
         BufferedImage image = getImage(new ArrayList<Tag>());
-        bitmapAlphaData = new byte[image.getWidth() * image.getHeight()];
-        for (int i = 0; i < bitmapAlphaData.length; i++) {
-            bitmapAlphaData[i] = (byte) 255;
+        byte[] ba = new byte[image.getWidth() * image.getHeight()];
+        for (int i = 0; i < ba.length; i++) {
+            ba[i] = (byte) 255;
         }


Input:
protected String asString() {
    StringBuilder sb = new StringBuilder();
    if (null != args && args.length > 0) {
        sb.append(args[0].toString());
        for (int i = 1; i < args.length; i++) sb.append("String_Node_Str").append(args[i].toString());
    }
    return String.format("String_Node_Str", method.getDeclaringClass().getName(), method.getName(), sb);
}

Output:
     }
-    return String.format("String_Node_Str", method.getDeclaringClass().getName(), method.getName(), sb);
+    if (method != null)
+        return String.format("String_Node_Str", method.getDeclaringClass().getName(), method.getName(), sb);
+    else
+        return String.format("String_Node_Str", field.getDeclaringClass().getName(), field.getName(), sb);
 }


Input:
private QueryResultSet find(Date startDate, Date endDate, String[] keywords, String field, boolean caseSensitive) {
    TreeSet result = new TreeSet(new HistoryRecordComparator());
    Vector filelist = filterFilesByDate(this.historyImpl.getFileList(), startDate, endDate);
    double currentProgress = HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE;
    double fileProgressStep = HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE;
    if (filelist.size() != 0)
        fileProgressStep = HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE / filelist.size();
    fireProgressStateChanged(startDate, endDate, keywords, HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE);
    Iterator fileIterator = filelist.iterator();
    while (fileIterator.hasNext()) {
        String filename = (String) fileIterator.next();
        Document doc = this.historyImpl.getDocumentForFile(filename);
        NodeList nodes = doc.getElementsByTagName("String_Node_Str");
        double nodesProgressStep = fileProgressStep;
        if (nodes.getLength() != 0)
            nodesProgressStep = fileProgressStep / nodes.getLength();
        Node node;
        for (int i = 0; i < nodes.getLength(); i++) {
            node = nodes.item(i);
            String ts = node.getAttributes().getNamedItem("String_Node_Str").getNodeValue();
            Date timestamp = new Date(Long.parseLong(ts));
            if (isInPeriod(timestamp, startDate, endDate)) {
                NodeList propertyNodes = node.getChildNodes();
                HistoryRecord record = filterByKeyword(propertyNodes, timestamp, keywords, field, caseSensitive);
                if (record != null) {
                    result.add(record);
                }
            }
            currentProgress += nodesProgressStep;
            fireProgressStateChanged(startDate, endDate, keywords, (int) currentProgress);
        }
    }
    fireProgressStateChanged(startDate, endDate, keywords, HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE);
    return new OrderedQueryResultSet(result);
}

Output:
     }
-    fireProgressStateChanged(startDate, endDate, keywords, HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE);
+    if ((int) currentProgress < HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE) {
+        fireProgressStateChanged(startDate, endDate, keywords, HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE);
+    }
     return new OrderedQueryResultSet(result);


Input:
public void listChanged(ListEvent<E> listChanges) {
    if (listChanges.isReordering()) {
        int[] sourceReorder = listChanges.getReorderMap();
        int[] previousIndexToSortedIndex = new int[sorted.size()];
        int index = 0;
        for (SimpleTreeIterator<Element> i = new SimpleTreeIterator<Element>(sorted); i.hasNext(); index++) {
            i.next();
            Element<Element> unsortedNode = i.value();
            int unsortedIndex = unsorted.indexOfNode(unsortedNode, ALL_COLORS);
            previousIndexToSortedIndex[unsortedIndex] = index;
        }
        int[] newIndexToSortedIndex = new int[sorted.size()];
        for (int i = 0; i < previousIndexToSortedIndex.length; i++) {
            newIndexToSortedIndex[i] = previousIndexToSortedIndex[sourceReorder[i]];
        }
        Element<Element>[] unsortedNodes = new Element[unsorted.size()];
        index = 0;
        for (SimpleTreeIterator<Element> i = new SimpleTreeIterator<Element>(unsorted); i.hasNext(); index++) {
            i.next();
            Element<Element> unsortedNode = i.node();
            unsortedNodes[index] = unsortedNode;
        }
        Arrays.sort(unsortedNodes, sorted.getComparator());
        int[] reorderMap = new int[sorted.size()];
        boolean indexChanged = false;
        index = 0;
        for (SimpleTreeIterator<Element> i = new SimpleTreeIterator<Element>(sorted); i.hasNext(); index++) {
            i.next();
            Element<Element> sortedNode = i.node();
            Element<Element> unsortedNode = unsortedNodes[index];
            sortedNode.set(unsortedNode);
            unsortedNode.set(sortedNode);
            int unsortedIndex = unsorted.indexOfNode(unsortedNode, ALL_COLORS);
            reorderMap[index] = newIndexToSortedIndex[unsortedIndex];
            indexChanged = indexChanged || (index != reorderMap[index]);
        }
        if (indexChanged) {
            updates.beginEvent();
            updates.reorder(reorderMap);
            updates.commitEvent();
        }
        return;
    }
    updates.beginEvent();
    LinkedList<Element> insertNodes = new LinkedList<Element>();
    List<Element<Element>> updateNodes = new ArrayList<Element<Element>>();
    while (listChanges.next()) {
        int unsortedIndex = listChanges.getIndex();
        int changeType = listChanges.getType();
        if (changeType == ListEvent.INSERT) {
            Element<Element> unsortedNode = unsorted.add(unsortedIndex, EMPTY_ELEMENT, 1);
            insertNodes.addLast(unsortedNode);
        } else if (changeType == ListEvent.UPDATE) {
            Element<Element> unsortedNode = unsorted.get(unsortedIndex);
            Element sortedNode = unsortedNode.get();
            sortedNode.setSorted(false);
            updateNodes.add(sortedNode);
        } else if (changeType == ListEvent.DELETE) {
            Element<Element> unsortedNode = unsorted.get(unsortedIndex);
            unsorted.remove(unsortedNode);
            int deleteSortedIndex = deleteByUnsortedNode(unsortedNode);
            updates.addDelete(deleteSortedIndex);
        }
    }
    for (Iterator<Element<Element>> i = updateNodes.iterator(); i.hasNext(); ) {
        Element<Element> sortedNode = i.next();
        int originalIndex = sorted.indexOfNode(sortedNode, ALL_COLORS);
        if (isNodeInSortedOrder(sortedNode)) {
            sortedNode.setSorted(true);
            updates.addUpdate(originalIndex);
        } else if (mode == AVOID_MOVING_ELEMENTS) {
            updates.addUpdate(originalIndex);
        } else {
            sorted.remove(sortedNode);
            updates.addDelete(originalIndex);
            int insertedIndex = insertByUnsortedNode(sortedNode.get());
            updates.addInsert(insertedIndex);
        }
    }
    while (!insertNodes.isEmpty()) {
        Element insertNode = insertNodes.removeFirst();
        int insertedIndex = insertByUnsortedNode(insertNode);
        updates.addInsert(insertedIndex);
    }
    updates.commitEvent();
}

Output:
             Element sortedNode = unsortedNode.get();
-            sortedNode.setSorted(false);
+            sortedNode.setSorted(Element.PENDING);
             updateNodes.add(sortedNode);


Input:
public void element(XPathFragment frag) {
    try {
        isLastEventText = false;
        if (isStartElementOpen) {
            writer.write('>');
            isStartElementOpen = false;
        }
        writer.write(Helper.cr());
        for (int x = 0; x < numberOfTabs; x++) {
            writer.write(tab());
        }
        super.element(frag);
    } catch (IOException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
         }
-        writer.write(Helper.cr());
+        writer.write(CR);
         for (int x = 0; x < numberOfTabs; x++) {


Input:
protected final String getType(CardView card) {
    StringBuilder sbType = new StringBuilder();
    for (String superType : card.getSuperTypes()) {
        sbType.append(superType).append("String_Node_Str");
    }
    for (CardType cardType : card.getCardTypes()) {
        sbType.append(cardType.toString()).append("String_Node_Str");
    }
    if (card.getSubTypes().size() > 0) {
        sbType.append("String_Node_Str");
        for (String subType : card.getSubTypes()) {
            sbType.append(subType).append("String_Node_Str");
        }
    }
    return sbType.toString();
}

Output:
     }
-    return sbType.toString();
+    return sbType.toString().trim();
 }


Input:
public void composeJobs() throws IOException {
    if (this.jobs.size() == 0) {
        return;
    }
    final String hadoopFileJar;
    if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists())
        hadoopFileJar = "String_Node_Str" + Tokens.FAUNUS_JOB_JAR;
    else if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists())
        hadoopFileJar = "String_Node_Str" + Tokens.FAUNUS_JOB_JAR;
    else if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists())
        hadoopFileJar = "String_Node_Str" + Tokens.FAUNUS_JOB_JAR;
    else if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists())
        hadoopFileJar = "String_Node_Str" + Tokens.FAUNUS_JOB_JAR;
    else
        throw new IllegalStateException("String_Node_Str" + Tokens.FAUNUS_JOB_JAR);
    if (this.pathEnabled)
        logger.warn("String_Node_Str");
    for (final Job job : this.jobs) {
        job.getConfiguration().setBoolean(PATH_ENABLED, this.pathEnabled);
        job.getConfiguration().set("String_Node_Str", hadoopFileJar);
    }
    final FileSystem hdfs = FileSystem.get(this.graph.getConfiguration());
    final String outputJobPrefix = this.graph.getOutputLocation().toString() + "String_Node_Str" + Tokens.JOB;
    hdfs.mkdirs(this.graph.getOutputLocation());
    if (FileInputFormat.class.isAssignableFrom(this.graph.getGraphInputFormat())) {
        FileInputFormat.setInputPaths(this.jobs.get(0), this.graph.getInputLocation());
        FileInputFormat.setInputPathFilter(this.jobs.get(0), NoSideEffectFilter.class);
    }
    for (int i = 0; i < this.jobs.size(); i++) {
        final Job job = this.jobs.get(i);
        final Path path = new Path(outputJobPrefix + "String_Node_Str" + i);
        FileOutputFormat.setOutputPath(job, path);
        if (i == 0) {
            job.setInputFormatClass(this.graph.getGraphInputFormat());
        } else {
            job.setInputFormatClass(INTERMEDIATE_INPUT_FORMAT);
            FileInputFormat.setInputPathFilter(job, GraphFilter.class);
            FileInputFormat.addInputPath(job, new Path(outputJobPrefix + "String_Node_Str" + (i - 1)));
        }
        if (i == this.jobs.size() - 1) {
            LazyOutputFormat.setOutputFormatClass(job, this.graph.getGraphOutputFormat());
            MultipleOutputs.addNamedOutput(job, Tokens.SIDEEFFECT, this.graph.getSideEffectOutputFormat(), job.getOutputKeyClass(), job.getOutputKeyClass());
            MultipleOutputs.addNamedOutput(job, Tokens.GRAPH, this.graph.getGraphOutputFormat(), NullWritable.class, FaunusVertex.class);
        } else {
            LazyOutputFormat.setOutputFormatClass(job, INTERMEDIATE_OUTPUT_FORMAT);
            MultipleOutputs.addNamedOutput(job, Tokens.SIDEEFFECT, this.graph.getSideEffectOutputFormat(), job.getOutputKeyClass(), job.getOutputKeyClass());
            MultipleOutputs.addNamedOutput(job, Tokens.GRAPH, INTERMEDIATE_OUTPUT_FORMAT, NullWritable.class, FaunusVertex.class);
        }
    }
}

Output:
     }
-    final String hadoopFileJar;
-    if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists())
+    String hadoopFileJar = null;
+    if (new File("String_Node_Str" + Tokens.FAUNUS_JOB_JAR).exists()) {
+        logger.warn("String_Node_Str" + Tokens.FAUNUS_JOB_JAR);
         hadoopFileJar = "String_Node_Str" + Tokens.FAUNUS_JOB_JAR;


Input:
private void initialize() {
    toolbar = new HeatMapInputToolbar();
    colorbar = new HeatMapColorToolBar();
    heatTrellis = new HeatTrellis(heatMapModel);
    add(toolbar, BorderLayout.NORTH);
    add(heatTrellis, BorderLayout.CENTER);
    add(colorbar, BorderLayout.SOUTH);
    menus = new HeatMapMenu(this);
    setTitle("String_Node_Str");
    setJMenuBar(menus);
}

Output:
     colorbar = new HeatMapColorToolBar();
-    heatTrellis = new HeatTrellis(heatMapModel);
+    heatTrellis = new HeatTrellis();
     add(toolbar, BorderLayout.NORTH);


Input:
synchronized void unparcel() {
    if (mParcelledData == null) {
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str");
        return;
    }
    if (LOG_DEFUSABLE && sShouldDefuse && (mFlags & FLAG_DEFUSABLE) == 0) {
        Slog.wtf(TAG, "String_Node_Str" + "String_Node_Str", new Throwable());
    }
    if (isEmptyParcel()) {
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str");
        if (mMap == null) {
            mMap = new ArrayMap<String, Object>(1);
        } else {
            mMap.erase();
        }
        mParcelledData = null;
        return;
    }
    int N = mParcelledData.readInt();
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str" + N + "String_Node_Str");
    if (N < 0) {
        return;
    }
    if (mMap == null) {
        mMap = new ArrayMap<String, Object>(N);
    } else {
        mMap.erase();
        mMap.ensureCapacity(N);
    }
    try {
        mParcelledData.readArrayMapInternal(mMap, N, mClassLoader);
    } catch (BadParcelableException e) {
        if (sShouldDefuse) {
            Log.w(TAG, "String_Node_Str", e);
            mMap.erase();
        } else {
            throw e;
        }
    } finally {
        mParcelledData.recycle();
        mParcelledData = null;
    }
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str" + mMap);
}

Output:
 synchronized void unparcel() {
-    if (mParcelledData == null) {
-        if (DEBUG)
-            Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str");
-        return;
-    }
-    if (LOG_DEFUSABLE && sShouldDefuse && (mFlags & FLAG_DEFUSABLE) == 0) {
-        Slog.wtf(TAG, "String_Node_Str" + "String_Node_Str", new Throwable());
-    }
-    if (isEmptyParcel()) {
+    synchronized (this) {
+        final Parcel parcelledData = mParcelledData;
+        if (parcelledData == null) {
+            if (DEBUG)
+                Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str");
+            return;
+        }
+        if (LOG_DEFUSABLE && sShouldDefuse && (mFlags & FLAG_DEFUSABLE) == 0) {
+            Slog.wtf(TAG, "String_Node_Str" + "String_Node_Str", new Throwable());
+        }
+        if (isEmptyParcel()) {
+            if (DEBUG)
+                Log.d(TAG, "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str");
+            if (mMap == null) {
+                mMap = new ArrayMap<>(1);
+            } else {
+                mMap.erase();
+            }
+            mParcelledData = null;
+            return;
+        }
+        int N = parcelledData.readInt();
         if (DEBUG)


Input:
private CellEditor[] getCellEditors(Table table) {
    CellEditor[] editors = new CellEditor[COLUMNS.length];
    editors[0] = new TextCellEditor(table);
    editors[1] = new TextCellEditor(table);
    return editors;
}

Output:
     CellEditor[] editors = new CellEditor[COLUMNS.length];
-    editors[0] = new TextCellEditor(table);
+    editors[0] = new TextCellEditor(table) {
+        protected void keyReleaseOccured(KeyEvent keyEvent) {
+            super.keyReleaseOccured(keyEvent);
+            if (keyEvent.character == '\r') {
+                fTableViewer.editElement(fTableViewer.getElementAt(fTable.getSelectionIndex()), 1);
+            }
+        }
+    };
     editors[1] = new TextCellEditor(table);


Input:
public void testGetPageCount() throws EngineException {
    String design = "String_Node_Str";
    IReportDocument document = engine.openReportDocument("String_Node_Str");
    test(document, "String_Node_Str");
    test(document, "String_Node_Str");
}

Output:
     String design = "String_Node_Str";
-    IReportDocument document = engine.openReportDocument("String_Node_Str");
+    IReportDocument document = createReportDocument(design);
     test(document, "String_Node_Str");


Input:
public LineCollectorExpression<?> getImplementation(ReferenceInfo info) {
    LineCollectorExpression<?> expression = implementations.get(info.ident().columnIdent().name());
    if (expression != null) {
        return expression;
    }
    return new ColumnExtractingLineExpression(info.ident().columnIdent());
}

Output:
 public LineCollectorExpression<?> getImplementation(ReferenceInfo info) {
-    LineCollectorExpression<?> expression = implementations.get(info.ident().columnIdent().name());
-    if (expression != null) {
-        return expression;
+    ExpressionBuilder builder = expressionBuilder.get(info.ident().columnIdent().name());
+    if (builder != null) {
+        return builder.create();
     }


Input:
public Double getDoubleAttribute(String key) {
    final Object attribute = getAttribute(key);
    return attribute != null ? Double.valueOf(attribute.toString()) : null;
}

Output:
 public Double getDoubleAttribute(String key) {
-    final Object attribute = getAttribute(key);
+    Object attribute = getAttribute(key);
     return attribute != null ? Double.valueOf(attribute.toString()) : null;


Input:
protected IRemoteServiceReference[] getRemoteServiceReferences(IRemoteServiceContainerAdapter adapter, String clazz) {
    return adapter.getRemoteServiceReferences(null, clazz, null);
}

Output:
 protected IRemoteServiceReference[] getRemoteServiceReferences(IRemoteServiceContainerAdapter adapter, String clazz) {
-    return adapter.getRemoteServiceReferences(null, clazz, null);
+    try {
+        return adapter.getRemoteServiceReferences(null, clazz, null);
+    } catch (final InvalidSyntaxException e) {
+        fail("String_Node_Str");
+    }
+    return null;
 }


Input:
public boolean validateRequiredFields() {
    disPanel.setOpen(false);
    errorMessage.setText(messages.labelFieldsRequired());
    for (int j = 0; j < matrix.getRowCount(); j++) {
        Widget w = matrix.getWidget(j, 1);
        String textValue = "String_Node_Str";
        if (w instanceof TextBox) {
            TextBox field = (TextBox) w;
            textValue = field.getText().trim();
            setValidationStyle(field, textValue);
        } else if (w instanceof TextArea) {
            TextArea field = (TextArea) w;
            textValue = field.getText().trim();
            setValidationStyle(field, textValue);
        } else if (w instanceof ListBox) {
            ListBox field = (ListBox) w;
            textValue = field.getItemText(field.getSelectedIndex()).trim();
            setValidationStyle(field, textValue);
        }
        if (textValue.trim().length() == 0) {
            disPanel.setOpen(true);
            return false;
        }
    }
    if (listOfSubGoalsMappedToRequirement.size() == 0) {
        disPanel.setOpen(true);
        subGoalEmptyLabel.setStyleName("String_Node_Str");
        return false;
    }
    for (GwtRequirement requirement : lisOfRequirements) {
        if (requirement.getTitle().equals(requirementTitleTextBox.getText().trim())) {
            errorMessage.setText(messages.duplicateTitleError());
            disPanel.setOpen(true);
            return false;
        }
    }
    disPanel.setOpen(false);
    return true;
}

Output:
     for (GwtRequirement requirement : lisOfRequirements) {
-        if (requirement.getTitle().equals(requirementTitleTextBox.getText().trim())) {
+        if (requirement.getTitle().equals(requirementTitleTextBox.getText().trim()) && (requirement.getId() != currentRequirementId)) {
             errorMessage.setText(messages.duplicateTitleError());


Input:
private String printPDBConnections() {
    StringBuilder str = new StringBuilder();
    for (Chain c : structure.getChains()) {
        for (Group g : c.getAtomGroups()) {
            for (Atom a : g.getAtoms()) {
                for (Bond b : a.getBonds()) {
                    str.append(String.format("String_Node_Str" + newline, b.getAtomA().getPDBserial(), b.getAtomB().getPDBserial()));
                }
            }
        }
    }
    return str.toString();
}

Output:
             for (Atom a : g.getAtoms()) {
-                for (Bond b : a.getBonds()) {
-                    str.append(String.format("String_Node_Str" + newline, b.getAtomA().getPDBserial(), b.getAtomB().getPDBserial()));
+                if (a.getBonds() != null) {
+                    for (Bond b : a.getBonds()) {
+                        str.append(String.format("String_Node_Str" + newline, b.getAtomA().getPDBserial(), b.getAtomB().getPDBserial()));
+                    }
                 }


Input:
public InternalScanner createCompactionScanner(RegionCoprocessorEnvironment env, Store store, InternalScanner s) throws IOException {
    if (logger.isDebugEnabled()) {
        logger.debug("String_Node_Str");
    }
    ImmutableBytesPtr cfKey = new ImmutableBytesPtr(store.getFamily().getName());
    init();
    StatisticsScanner scanner = new StatisticsScanner(this, statsWriter, env, s, cfKey);
    return scanner;
}

Output:
     }
-    ImmutableBytesPtr cfKey = new ImmutableBytesPtr(store.getFamily().getName());
+    ImmutableBytesPtr cfKey = new ImmutableBytesPtr(store.getColumnFamilyDescriptor().getName());
     init();


Input:
static public PipedStream[] getPipes(int n) throws IOException {
    if (n == 0)
        return null;
    PipedStream[] streams = new PipedStream[n];
    for (int i = 0; i < n; i++) streams[i] = new PipedStream("String_Node_Str");
    return streams;
}

Output:
     PipedStream[] streams = new PipedStream[n];
-    for (int i = 0; i < n; i++) streams[i] = new PipedStream("String_Node_Str");
+    for (int i = 0; i < n; i++) streams[i] = new PipedStream();
     return streams;


Input:
protected Object openDialogBox(Control cellEditorWindow) {
    SelectXPathDialog dialog = new SelectXPathDialog(cellEditorWindow.getShell(), allDataModelHolder, allDataModelHolder.getDefaultDataModel(), allDataModelHolder.getDefaultEntity());
    if (dialog.open() != Window.OK)
        return null;
    return dialog.getSelectedXPath();
}

Output:
         return null;
-    return dialog.getSelectedXPath();
+    String xpath = dialog.getSelectedXPath();
+    if (xpathUpdate != null) {
+        return xpathUpdate.updateXPath(xpath);
+    }
+    return xpath;
 }


Input:
public IType resolveType(MarkerList markers, IContext context) {
    for (int i = 0; i < this.parameterCount; i++) {
        this.parameterTypes[i] = this.parameterTypes[i].resolveType(markers, context).getParameterType();
    }
    if (this.returnType == null) {
        this.returnType = Types.UNKNOWN;
        markers.add(MarkerMessages.createError(this.getPosition(), "String_Node_Str"));
    }
    this.returnType = this.returnType.resolveType(markers, context).getReturnType();
    return this;
}

Output:
         this.returnType = Types.UNKNOWN;
-        markers.add(MarkerMessages.createError(this.getPosition(), "String_Node_Str"));
+        markers.add(MarkerMessages.createError(this.position, "String_Node_Str"));
+    } else {
+        this.returnType = this.returnType.resolveType(markers, context).getReturnType();
     }


Input:
public void run() {
    pushEnum.push(el);
}

Output:
 public void run() {
-    pushEnum.push(el);
+    Option<T> opt = p.callback.apply(Unit.unit());
+    for (T elem : opt) {
+        p.push(elem);
+    }
 }


Input:
public boolean isLog(ItemStack item) {
    if (item == null)
        return false;
    return (item.getUnlocalizedName().contains("String_Node_Str"));
}

Output:
         return false;
-    return (item.getUnlocalizedName().contains("String_Node_Str"));
+    if (item.getItem() == null)
+        return false;
+    return (item.getItem().getUnlocalizedName().contains("String_Node_Str"));
 }


Input:
private void showGroupNotificationForBuilder(Context context, NotificationCompat.Builder builder, String wpcomNoteID, String message, boolean notifyUser) {
    if (builder == null || context == null) {
        return;
    }
    Bundle authPNBundle = sActiveNotificationsMap.remove(AUTH_PUSH_NOTIFICATION_ID);
    if (sActiveNotificationsMap.size() > 1) {
        NotificationCompat.InboxStyle inboxStyle = new NotificationCompat.InboxStyle();
        int noteCtr = 1;
        for (Bundle pushBundle : sActiveNotificationsMap.values()) {
            if (noteCtr > MAX_INBOX_ITEMS) {
                break;
            }
            if (pushBundle == null || pushBundle.getString(PUSH_ARG_MSG) == null) {
                continue;
            }
            if (pushBundle.getString(PUSH_ARG_TYPE, "String_Node_Str").equals(PUSH_TYPE_COMMENT)) {
                String pnTitle = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_TITLE)));
                String pnMessage = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_MSG)));
                inboxStyle.addLine(pnTitle + "String_Node_Str" + pnMessage);
            } else {
                String pnMessage = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_MSG)));
                inboxStyle.addLine(pnMessage);
            }
            noteCtr++;
        }
        if (sActiveNotificationsMap.size() > MAX_INBOX_ITEMS) {
            inboxStyle.setSummaryText(String.format(context.getString(R.string.more_notifications), sActiveNotificationsMap.size() - MAX_INBOX_ITEMS));
        }
        String subject = String.format(context.getString(R.string.new_notifications), sActiveNotificationsMap.size());
        NotificationCompat.Builder groupBuilder = new NotificationCompat.Builder(context).setSmallIcon(R.drawable.ic_my_sites_white_24dp).setColor(context.getResources().getColor(R.color.blue_wordpress)).setGroup(NOTIFICATION_GROUP_KEY).setGroupSummary(true).setAutoCancel(true).setTicker(message).setContentTitle(context.getString(R.string.app_name)).setContentText(subject).setStyle(inboxStyle);
        showNotificationForBuilder(groupBuilder, context, wpcomNoteID, GROUP_NOTIFICATION_ID, notifyUser);
    } else {
        builder.setGroupSummary(true);
        showNotificationForBuilder(builder, context, wpcomNoteID, GROUP_NOTIFICATION_ID, notifyUser);
    }
    if (authPNBundle != null) {
        sActiveNotificationsMap.put(AUTH_PUSH_NOTIFICATION_ID, authPNBundle);
    }
}

Output:
             if (pushBundle.getString(PUSH_ARG_TYPE, "String_Node_Str").equals(PUSH_TYPE_COMMENT)) {
-                String pnTitle = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_TITLE)));
-                String pnMessage = StringEscapeUtils.unescapeHtml((pushBundle.getString(PUSH_ARG_MSG)));
+                String pnTitle = StringEscapeUtils.unescapeHtml4((pushBundle.getString(PUSH_ARG_TITLE)));
+                String pnMessage = StringEscapeUtils.unescapeHtml4((pushBundle.getString(PUSH_ARG_MSG)));
                 inboxStyle.addLine(pnTitle + "String_Node_Str" + pnMessage);


Input:
public Result execute(Source source) {
    if (null == source) {
        throw new JMetalException("String_Node_Str");
    } else if (source.size() != 2) {
        throw new JMetalException("String_Node_Str" + source.size());
    }
    return (Result) source;
}

Output:
     }
-    return (Result) source;
+    List<Solution> list = new ArrayList<>();
+    list.add(source.get(0).copy());
+    list.add(source.get(1).copy());
+    return (Result) list;
 }


Input:
public void run() {
    try {
        TreeNode docRoot = null;
        Object s = getSelectedObjects().get(0);
        if (s instanceof List && !((List) s).isEmpty()) {
            List selectedarts = new ArrayList((List) s);
            Iterator iter = selectedarts.iterator();
            while (iter.hasNext()) {
                Object obj = iter.next();
                if (obj instanceof TreeNodeEditPart) {
                    TreeNodeEditPart nodePart = (TreeNodeEditPart) obj;
                    TreeNode treeNode = (TreeNode) nodePart.getModel();
                    if (treeNode.eContainer() instanceof TreeNode) {
                        TreeNode parent = (TreeNode) treeNode.eContainer();
                        if (docRoot == null) {
                            docRoot = XmlMapUtil.getTreeNodeRoot(parent);
                        }
                        XmlMapUtil.detachNodeConnections(treeNode, mapperManager.getCopyOfMapData(), true);
                        if (treeNode.isLoop()) {
                            if (treeNode instanceof OutputTreeNode && XmlMapUtil.findUpGroupNode((OutputTreeNode) treeNode) != null) {
                                XmlMapUtil.cleanSubGroup(docRoot);
                            }
                            XmlMapUtil.clearMainNode(docRoot);
                        }
                        parent.getChildren().remove(treeNode);
                    }
                }
            }
        }
        if (mapperManager != null) {
            if (input) {
                if (docRoot != null && docRoot.eContainer() instanceof InputXmlTree) {
                    mapperManager.refreshInputTreeSchemaEditor((InputXmlTree) docRoot.eContainer());
                }
            } else {
                if (docRoot != null && docRoot.eContainer() instanceof OutputXmlTree) {
                    mapperManager.refreshOutputTreeSchemaEditor((OutputXmlTree) docRoot.eContainer());
                }
            }
            if (docRoot != null && docRoot.eContainer() instanceof AbstractInOutTree) {
                mapperManager.getProblemsAnalyser().checkLoopProblems((AbstractInOutTree) docRoot.eContainer());
                mapperManager.getMapperUI().updateStatusBar();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
             if (docRoot != null && docRoot.eContainer() instanceof AbstractInOutTree) {
-                mapperManager.getProblemsAnalyser().checkLoopProblems((AbstractInOutTree) docRoot.eContainer());
+                mapperManager.getProblemsAnalyser().checkProblems((AbstractInOutTree) docRoot.eContainer());
                 mapperManager.getMapperUI().updateStatusBar();


Input:
public boolean isFinal() {
    return finalState != currentState;
}

Output:
 public boolean isFinal() {
-    return finalState != currentState;
+    return finalState == currentState;
 }


Input:
public void setRenderParameter(String key, String[] values) {
    if (redirected) {
        throw new IllegalStateException("String_Node_Str");
    }
    if (key == null || values == null || values.length == 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    renderParameters.put(key, values);
    redirectAllowed = false;
}

Output:
     }
-    renderParameters.put(key, values);
+    renderParameters.put(key, StringUtils.copy(values));
     redirectAllowed = false;


Input:
public <M> M getFeatureMap(final Feature<M, O, ?> feature) {
    M fmap = (M) featureMaps.get(feature);
    if (fmap == null) {
        fmap = feature.createFeatureMap(collection);
        featureMaps.put(feature, fmap);
        featureCleanups.add(feature.createFeatureCleanup(fmap));
        for (final CreateFeatureMapListener<O> l : createFeatureMapListeners) l.createFeatureMap(feature, fmap);
    }
    return fmap;
}

Output:
     if (fmap == null) {
-        fmap = feature.createFeatureMap(collection);
+        fmap = feature.createFeatureMap(pool);
         featureMaps.put(feature, fmap);


Input:
public void parseLine(String tapLine) {
    TapElement tapElement = TapElementFactory.createTapElement(tapLine);
    if (tapElement == null || state.isInYaml()) {
        String trimmedLine = tapLine.trim();
        Text text = TapElementFactory.createTextElement(tapLine);
        if (state.isInYaml()) {
            boolean yamlEndMarkReached = trimmedLine.equals("String_Node_Str") && (tapLine.equals(state.getYamlIndentation() + "String_Node_Str") || text.getIndentation() < state.getYamlIndentation().length());
            if (yamlEndMarkReached) {
                state.setInYaml(false);
                parseDiagnostics();
            } else {
                state.getDiagnosticBuffer().append(tapLine);
                state.getDiagnosticBuffer().append('\n');
            }
        } else {
            if (trimmedLine.equals("String_Node_Str")) {
                if (text.getIndentation() < baseIndentation) {
                    throw new ParserException("String_Node_Str" + "String_Node_Str" + tapLine);
                }
                state.setInYaml(true);
                state.setYamlIndentation(text.getIndentationString());
            } else {
                state.getTestSet().getTapLines().add(text);
                state.setLastParsedElement(text);
            }
        }
        return;
    }
    int indentation = tapElement.getIndentation();
    if (indentation < baseIndentation) {
        baseIndentation = indentation;
    }
    if (indentation != state.getIndentationLevel()) {
        if (indentation > state.getIndentationLevel()) {
            StreamStatus parentState = state;
            pushState(indentation);
            TapElement lastParentElement = parentState.getLastParsedElement();
            if (lastParentElement instanceof TestResult) {
                final TestResult lastTestResult = (TestResult) lastParentElement;
                if (lastTestResult.getSubtest() == null) {
                    lastTestResult.setSubtest(state.getTestSet());
                    state.attachedToParent = true;
                }
            }
        } else {
            do {
                StreamStatus prevState = state;
                state = states.pop();
                if (!prevState.attachedToParent) {
                    state.looseSubtests = prevState.getTestSet();
                }
            } while (indentation < state.getIndentationLevel());
        }
    }
    if (tapElement instanceof Header) {
        if (state.getTestSet().getHeader() != null) {
            throw new ParserException("String_Node_Str");
        }
        if (!state.isFirstLine()) {
            throw new ParserException("String_Node_Str" + "String_Node_Str");
        }
        state.getTestSet().setHeader((Header) tapElement);
    } else if (tapElement instanceof Plan) {
        if (state.getTestSet().getPlan() != null) {
            throw new ParserException("String_Node_Str");
        }
        if (state.getTestSet().getTestResults().size() <= 0 && state.getTestSet().getBailOuts().size() <= 0) {
            state.setPlanBeforeTestResult(true);
        }
        state.getTestSet().setPlan((Plan) tapElement);
    } else if (tapElement instanceof TestResult) {
        parseDiagnostics();
        final TestResult testResult = (TestResult) tapElement;
        if (testResult.getTestNumber() == 0) {
            if (state.getTestSet().getPlan() != null && state.isPlanBeforeTestResult() == false) {
                return;
            }
            if (state.getTestSet().getPlan() != null && state.getTestSet().getPlan().getLastTestNumber() == state.getTestSet().getTestResults().size()) {
                return;
            }
            testResult.setTestNumber(state.getTestSet().getNextTestNumber());
        }
        state.getTestSet().addTestResult(testResult);
        if (state.looseSubtests != null) {
            testResult.setSubtest(state.looseSubtests);
            state.looseSubtests = null;
        }
    } else if (tapElement instanceof Footer) {
        state.getTestSet().setFooter((Footer) tapElement);
    } else if (tapElement instanceof BailOut) {
        state.getTestSet().addBailOut((BailOut) tapElement);
    } else if (tapElement instanceof Comment) {
        final Comment comment = (Comment) tapElement;
        state.getTestSet().addComment(comment);
        if (state.getLastParsedElement() instanceof TestResult) {
            ((TestResult) state.getLastParsedElement()).addComment(comment);
        }
    }
    state.setFirstLine(false);
    if (!(tapElement instanceof Comment)) {
        state.setLastParsedElement(tapElement);
    }
}

Output:
         if (state.getTestSet().getPlan() != null) {
-            throw new ParserException("String_Node_Str");
+            if (currentPlan.getInitialTestNumber() != 1 || currentPlan.getLastTestNumber() != 0) {
+                throw new ParserException("String_Node_Str");
+            }
+        } else {
+            state.getTestSet().setPlan(currentPlan);
         }


Input:
private void showConnectCameraView() {
    mViewFlipper.setDisplayedChild(1);
    mProgressBar.setProgress(67);
    setTitle(R.string.title_connect_camera);
    updateMessage(mConnectExplainView, 0, R.string.connect_camera_explain_message);
    populateSelectedModel(mSelectedModelTextView, mSelectedModel);
    autoPopulateExternalIP(mPublicIpEditText);
}

Output:
     populateSelectedModel(mSelectedModelTextView, mSelectedModel);
-    autoPopulateExternalIP(mPublicIpEditText);
+    mHandler.postDelayed(new Runnable() {
+        public void run() {
+            autoPopulateExternalIP(mPublicIpEditText);
+        }
+    }, 100);
 }


Input:
protected List<Pair<Course, Timing>> doInBackground(Void... params) {
    List<Pair<Course, Timing>> finalArray = new ArrayList<>();
    for (Course course : courses) {
        Timing lastTiming = new Timing();
        if (course.getTimings() != null) {
            for (Timing timing : course.getTimings()) {
                if (timing.getDay() == dayOfWeek && !(timing.equals(lastTiming))) {
                    finalArray.add(new Pair<>(course, timing));
                    lastTiming = timing;
                }
            }
        }
    }
    Collections.sort(finalArray, new Comparator<Pair<Course, Timing>>() {
        public int compare(Pair<Course, Timing> lhs, Pair<Course, Timing> rhs) {
            String lhsStartTime = "String_Node_Str";
            String rhsStartTime = "String_Node_Str";
            for (Timing timing : lhs.first.getTimings()) {
                if (timing.getDay() == dayOfWeek) {
                    lhsStartTime = timing.getStartTime();
                }
            }
            for (Timing timing : rhs.first.getTimings()) {
                if (timing.getDay() == dayOfWeek) {
                    rhsStartTime = timing.getStartTime();
                }
            }
            try {
                return DateTimeCalender.compareTimes(lhsStartTime, rhsStartTime);
            } catch (ParseException ex) {
                ex.printStackTrace();
                return 0;
            }
        }
    });
    return finalArray;
}

Output:
     List<Pair<Course, Timing>> finalArray = new ArrayList<>();
-    for (Course course : courses) {
-        Timing lastTiming = new Timing();
-        if (course.getTimings() != null) {
-            for (Timing timing : course.getTimings()) {
-                if (timing.getDay() == dayOfWeek && !(timing.equals(lastTiming))) {
-                    finalArray.add(new Pair<>(course, timing));
-                    lastTiming = timing;
+    if (courses == null || courses.size() == 0) {
+        courses = ((MainApplication) getActivity().getApplication()).getDataHolderInstanceInitialized().getCourses();
+    } else {
+        for (Course course : courses) {
+            Timing lastTiming = new Timing();
+            if (course.getTimings() != null) {
+                for (Timing timing : course.getTimings()) {
+                    if (timing.getDay() == dayOfWeek && !(timing.equals(lastTiming))) {
+                        finalArray.add(new Pair<>(course, timing));
+                        lastTiming = timing;
+                    }
                 }


Input:
public void readPortableData(EntityPlayer player, NBTTagCompound tag) {
    if (!canPlayerAccess(player.getCommandSenderName())) {
        return;
    }
    if (augmentRedstoneControl) {
        RedstoneControlHelper.getControlFromNBT(tag);
    }
    if (augmentReconfigSides) {
        int storedFacing = ReconfigurableHelper.getFacingFromNBT(tag);
        byte[] storedSideCache = ReconfigurableHelper.getSideCacheFromNBT(tag, getDefaultSides());
        sideCache[0] = storedSideCache[0];
        sideCache[1] = storedSideCache[1];
        sideCache[facing] = storedSideCache[storedFacing];
        sideCache[BlockHelper.getLeftSide(facing)] = storedSideCache[BlockHelper.getLeftSide(storedFacing)];
        sideCache[BlockHelper.getRightSide(facing)] = storedSideCache[BlockHelper.getRightSide(storedFacing)];
        sideCache[BlockHelper.getOppositeSide(facing)] = storedSideCache[BlockHelper.getOppositeSide(storedFacing)];
        for (int i = 0; i < 6; i++) {
            if (sideCache[i] >= getNumConfig(i)) {
                sideCache[i] = 0;
            }
        }
    }
    if (augmentRedstoneControl || augmentReconfigSides) {
        sendUpdatePacket(Side.CLIENT);
    }
}

Output:
         }
-    }
-    if (augmentRedstoneControl || augmentReconfigSides) {
+        markDirty();
         sendUpdatePacket(Side.CLIENT);


Input:
public boolean finalizeCommandsOnStart(Commands cmds, VirtualMachineProfile<ConsoleProxyVO> profile) {
    NicProfile controlNic = (NicProfile) profile.getParameter(VirtualMachineProfile.Param.ControlNic);
    CheckSshCommand check = new CheckSshCommand(profile.getInstanceName(), controlNic.getIp4Address(), 3922, 5, 20);
    cmds.addCommand("String_Node_Str", check);
    return true;
}

Output:
 public boolean finalizeCommandsOnStart(Commands cmds, VirtualMachineProfile<ConsoleProxyVO> profile) {
-    NicProfile controlNic = (NicProfile) profile.getParameter(VirtualMachineProfile.Param.ControlNic);
+    NicProfile managementNic = null;
+    NicProfile controlNic = null;
+    for (NicProfile nic : profile.getNics()) {
+        if (nic.getTrafficType() == TrafficType.Management) {
+            managementNic = nic;
+        } else if (nic.getTrafficType() == TrafficType.Control && nic.getIp4Address() != null) {
+            controlNic = nic;
+        }
+    }
+    if (controlNic == null) {
+        assert (managementNic != null);
+        controlNic = managementNic;
+    }
     CheckSshCommand check = new CheckSshCommand(profile.getInstanceName(), controlNic.getIp4Address(), 3922, 5, 20);


Input:
private void writeDocument(String indent, XhtmlNode node) throws IOException {
    indent = "String_Node_Str";
    for (XhtmlNode c : node.getChildNodes()) writeNode(indent, c);
}

Output:
     indent = "String_Node_Str";
-    for (XhtmlNode c : node.getChildNodes()) writeNode(indent, c);
+    for (XhtmlNode c : node.getChildNodes()) writeNode(indent, c, node.getName());
 }


Input:
public final void compute(Bounds bo) throws ChartException, IllegalArgumentException {
    bo = bo.scaledInstance(dPointToPixel);
    dSeriesThickness = (ids.getDpiResolution() / 72d) * cwa.getSeriesThickness();
    dSeriesThickness = cwa.getPlot().getClientArea().isVisible() ? dSeriesThickness : 0;
    double dX = bo.getLeft() + insCA.getLeft();
    double dY = bo.getTop() + insCA.getTop();
    double dW = bo.getWidth() - insCA.getLeft() - insCA.getRight();
    double dH = bo.getHeight() - insCA.getTop() - insCA.getBottom();
    iDimension = getDimension(cwa.getDimension());
    dXAxisPlotSpacing = cwa.getPlot().getHorizontalSpacing() * dPointToPixel;
    dYAxisPlotSpacing = cwa.getPlot().getVerticalSpacing() * dPointToPixel;
    if (iDimension == TWO_5_D) {
        dY += dSeriesThickness;
        dH -= dSeriesThickness;
        dW -= dSeriesThickness;
        bo.setHeight(dH);
        bo.setTop(dY);
        bo.setWidth(dW);
    }
    if (aax.getOverlayCount() > 0) {
        if (aax.areAxesSwapped()) {
            updateOverlayScales(aax, dX, dX + dW, dY, dH);
            dY = aax.getStart();
            dH = aax.getLength();
        } else {
            updateOverlayScales(aax, dY - dH, dY, dX, dW);
            dX = aax.getStart();
            dW = aax.getLength();
        }
    }
    double dStart, dEnd;
    final Axis[] axa = cwa.getPrimaryBaseAxes();
    final Axis axPrimaryBase = axa[0];
    final Axis axPrimaryOrthogonal = cwa.getPrimaryOrthogonalAxis(axPrimaryBase);
    Scale sc = axPrimaryBase.getScale();
    AutoScale scPrimaryBase = null;
    OneAxis oaxPrimaryBase = aax.getPrimaryBase();
    int iAxisType = getAxisType(axPrimaryBase);
    Object oaData = null;
    if (iAxisType == TEXT || oaxPrimaryBase.isCategoryScale()) {
        oaData = getTypedDataSet(axPrimaryBase, iAxisType, 0);
    } else if ((iAxisType & NUMERICAL) == NUMERICAL) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    } else if ((iAxisType & DATE_TIME) == DATE_TIME) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    }
    DataSetIterator dsi = (oaData instanceof DataSetIterator) ? (DataSetIterator) oaData : new DataSetIterator(oaData, iAxisType);
    oaData = null;
    dStart = (aax.areAxesSwapped()) ? dY + dH : dX;
    dEnd = (aax.areAxesSwapped()) ? dY : dStart + dW;
    int iDirection = AUTO;
    scPrimaryBase = AutoScale.computeScale(ids, oaxPrimaryBase, dsi, iAxisType, dStart, dEnd, sc, axPrimaryBase.getFormatSpecifier(), rtc, iDirection, 1, iMarginPercent);
    oaxPrimaryBase.set(scPrimaryBase);
    AutoScale scPrimaryOrthogonal = null;
    OneAxis oaxPrimaryOrthogonal = aax.getPrimaryOrthogonal();
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = null;
    if ((iAxisType & NUMERICAL) == NUMERICAL || (iAxisType & DATE_TIME) == DATE_TIME) {
        if (rtc.getScale() != null && rtc.getState(AutoScale.KEY_SHARED_MINMAX) != null) {
            dsi = new DataSetIterator(rtc.getState(AutoScale.KEY_SHARED_MINMAX), iAxisType);
        } else {
            dsi = new DataSetIterator(getMinMax(axPrimaryOrthogonal, iAxisType), iAxisType);
        }
        dsi.reverse(cwa.isReverseCategory());
    } else {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.DATA_FORMAT, "String_Node_Str", Messages.getResourceBundle(rtc.getULocale()));
    }
    dStart = (aax.areAxesSwapped()) ? dX : dY + dH;
    dEnd = (aax.areAxesSwapped()) ? dX + dW : dY;
    sc = axPrimaryOrthogonal.getScale();
    scPrimaryOrthogonal = AutoScale.computeScale(ids, oaxPrimaryOrthogonal, dsi, iAxisType, dStart, dEnd, sc, oaxPrimaryBase.getModelAxis().getOrigin(), axPrimaryOrthogonal.getFormatSpecifier(), rtc, AUTO, 1, iMarginPercent);
    oaxPrimaryOrthogonal.set(scPrimaryOrthogonal);
    double dYAxisLocation = adjustHorizontal(dX, dW, aax);
    double dXAxisLocation = adjustVerticalDueToHorizontal(dY, dH, aax);
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = getTypedDataSet(axPrimaryOrthogonal, iAxisType, 0);
    scPrimaryOrthogonal.setData(dsi);
    iAxisType = getAxisType(axPrimaryBase);
    if (iAxisType != IConstants.TEXT) {
        scPrimaryBase.setData(getTypedDataSet(axPrimaryBase, iAxisType, 0));
    }
    scPrimaryBase.resetShifts();
    scPrimaryOrthogonal.resetShifts();
    updateOverlayAxes(aax);
    growBaseAxis(aax, BoundsImpl.create(dX, dY, dW, dH));
    final OneAxis axPH = aax.areAxesSwapped() ? aax.getPrimaryOrthogonal() : aax.getPrimaryBase();
    final OneAxis axPV = aax.areAxesSwapped() ? aax.getPrimaryBase() : aax.getPrimaryOrthogonal();
    axPH.setAxisCoordinate(dXAxisLocation);
    axPV.setAxisCoordinate(dYAxisLocation);
    double[] daX = axPH.getScale().getEndPoints();
    double[] daY = axPV.getScale().getEndPoints();
    if (axPH.getScale().getDirection() == BACKWARD) {
        boPlotBackground.setLeft(daX[1] - insCA.getLeft());
        boPlotBackground.setWidth(daX[0] - daX[1] + insCA.getLeft() + insCA.getRight() + 1);
    } else {
        boPlotBackground.setLeft(daX[0] - insCA.getLeft());
        boPlotBackground.setWidth(daX[1] - daX[0] + insCA.getLeft() + insCA.getRight() + 1);
    }
    if (axPV.getScale().getDirection() == FORWARD) {
        boPlotBackground.setTop(daY[0] - insCA.getTop());
        boPlotBackground.setHeight(daY[1] - daY[0] + insCA.getTop() + insCA.getBottom() + 1);
    } else {
        boPlotBackground.setTop(daY[1] - insCA.getTop());
        boPlotBackground.setHeight(daY[0] - daY[1] + insCA.getTop() + insCA.getBottom() + 1);
    }
    if (iDimension == TWO_5_D) {
        boPlotBackground.delta(dSeriesThickness, -dSeriesThickness, 0, 0);
    }
    boPlotWithMargin = BoundsImpl.copyInstance(boPlotBackground);
    if (iMarginPercent > 0) {
        AutoScale scale = axPH.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMinWithMargin() != null) {
                    boPlotWithMargin.setLeft(boPlotWithMargin.getLeft() - factor * (asDouble(scale.getMinimum()).doubleValue() - asDouble(scale.getMinWithMargin()).doubleValue()));
                }
                boPlotWithMargin.setWidth(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getLeft() + insCA.getRight() + 1);
            }
        }
        scale = axPV.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMaxWithMargin() != null) {
                    boPlotWithMargin.setTop(boPlotWithMargin.getTop() - factor * (asDouble(scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMaximum()).doubleValue()));
                }
                boPlotWithMargin.setHeight(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getTop() + insCA.getBottom() + 1);
            }
        }
    }
}

Output:
     if ((iAxisType & NUMERICAL) == NUMERICAL || (iAxisType & DATE_TIME) == DATE_TIME) {
-        if (rtc.getScale() != null && rtc.getState(AutoScale.KEY_SHARED_MINMAX) != null) {
-            dsi = new DataSetIterator(rtc.getState(AutoScale.KEY_SHARED_MINMAX), iAxisType);
+        if (rtc.getSharedScale() != null) {
+            dsi = rtc.getSharedScale().createDataSetIterator(iAxisType);
         } else {


Input:
private final String decryptPassword(String encryptedPassword) throws GuacamoleException {
    if (encryptedPassword == null || encryptedPassword.isEmpty())
        return null;
    try {
        File keyFile = new File(new LocalEnvironment().getGuacamoleHome(), confService.getClearpassKey().toString());
        InputStream keyInput = new BufferedInputStream(new FileInputStream(keyFile));
        final byte[] keyBytes = new byte[(int) keyFile.length()];
        keyInput.read(keyBytes);
        keyInput.close();
        KeyFactory keyFactory = KeyFactory.getInstance("String_Node_Str");
        KeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        final PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        final Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
        final byte[] pass64 = DatatypeConverter.parseBase64Binary(encryptedPassword);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        final byte[] cipherData = cipher.doFinal(pass64);
        return new String(cipherData);
    } catch (FileNotFoundException e) {
        logger.error("String_Node_Str");
        logger.debug("String_Node_Str", e.getMessage());
        return null;
    } catch (IOException e) {
        logger.error("String_Node_Str");
        logger.debug("String_Node_Str", e.getMessage());
        return null;
    } catch (NoSuchAlgorithmException e) {
        logger.error("String_Node_Str");
        logger.debug("String_Node_Str", e.getMessage());
        return null;
    } catch (InvalidKeyException e) {
        logger.error("String_Node_Str");
        logger.debug("String_Node_Str", e.getMessage());
        return null;
    } catch (Throwable t) {
        logger.error("String_Node_Str");
        logger.debug("String_Node_Str", t.getMessage());
        return null;
    }
}

Output:
     try {
-        File keyFile = new File(new LocalEnvironment().getGuacamoleHome(), confService.getClearpassKey().toString());
+        File keyFile = new File(environment.getGuacamoleHome(), confService.getClearpassKey().toString());
         InputStream keyInput = new BufferedInputStream(new FileInputStream(keyFile));


Input:
public void reloadData() {
    if (dataSource != null) {
        dataSource.load(0, getPageSize());
    }
}

Output:
     if (dataSource != null) {
-        dataSource.load(0, getPageSize());
+        dataSource.clear();
+        dataSource.load(getSearchText(), getConditionalQueries(), 0, getPageSize());
     }


Input:
private static long getStringsLength(Collection<?> coll) {
    if (coll == null)
        return 0;
    long len = 0;
    for (Object o : coll) len += coll.toString().length();
    return len;
}

Output:
     long len = 0;
-    for (Object o : coll) len += coll.toString().length();
+    for (Object o : coll) len += o.toString().length();
     return len;


Input:
public Map<String, String> getDetails() {
    Map<String, String> customparameterMap = new HashMap<String, String>();
    if (details != null && details.size() != 0) {
        Collection parameterCollection = details.values();
        Iterator iter = parameterCollection.iterator();
        while (iter.hasNext()) {
            HashMap<String, String> value = (HashMap<String, String>) iter.next();
            for (Map.Entry<String, String> entry : value.entrySet()) {
                customparameterMap.put(entry.getKey(), entry.getValue());
            }
        }
    }
    return customparameterMap;
}

Output:
 public Map<String, String> getDetails() {
-    Map<String, String> customparameterMap = new HashMap<String, String>();
-    if (details != null && details.size() != 0) {
-        Collection parameterCollection = details.values();
-        Iterator iter = parameterCollection.iterator();
-        while (iter.hasNext()) {
-            HashMap<String, String> value = (HashMap<String, String>) iter.next();
-            for (Map.Entry<String, String> entry : value.entrySet()) {
-                customparameterMap.put(entry.getKey(), entry.getValue());
-            }
-        }
-    }
-    return customparameterMap;
+    return details;
 }


Input:
public static void moveWater(Player player) {
    BendingPlayer bPlayer = BendingPlayer.getBendingPlayer(player);
    if (bPlayer == null) {
        return;
    }
    if (bPlayer.isOnCooldown("String_Node_Str")) {
        redirectTargettedBlasts(player);
        return;
    }
    boolean handledPrepare = false;
    double range = 25;
    for (WaterManipulation waterManip : getAbilities(player, WaterManipulation.class)) {
        range = waterManip.range;
        if (waterManip.prepared) {
            waterManip.prepared = false;
            handledPrepare = true;
            waterManip.moveWater();
        }
    }
    if (!handledPrepare && WaterReturn.hasWaterBottle(player)) {
        Location eyeLoc = player.getEyeLocation();
        Block block = eyeLoc.add(eyeLoc.getDirection().normalize()).getBlock();
        if (!AFFECTED_BLOCKS.containsKey(block)) {
            AFFECTED_BLOCKS.put(block, block);
        }
        if (isTransparent(player, block) && isTransparent(player, eyeLoc.getBlock())) {
            if (getTargetLocation(player, range).distanceSquared(block.getLocation()) > 1) {
                block.setType(Material.WATER);
                block.setData((byte) 0);
                WaterManipulation waterManip = new WaterManipulation(player);
                waterManip.moveWater();
                if (!waterManip.progressing) {
                    block.setType(Material.AIR);
                } else {
                    WaterReturn.emptyWaterBottle(player);
                }
            }
        }
    }
    redirectTargettedBlasts(player);
}

Output:
             if (getTargetLocation(player, range).distanceSquared(block.getLocation()) > 1) {
-                block.setType(Material.WATER);
-                block.setData((byte) 0);
+                TempBlock tb = new TempBlock(block, Material.WATER, (byte) 0);
                 WaterManipulation waterManip = new WaterManipulation(player);


Input:
public void widgetSelected(final SelectionEvent e) {
    XmlFileConnection connection2 = getConnection();
    if (connection2.getXmlFilePath() == null || connection2.getXmlFilePath().equals("String_Node_Str")) {
        informationLabel.setText("String_Node_Str" + Messages.getString("String_Node_Str") + "String_Node_Str");
        return;
    }
    if (!new File(connection2.getXmlFilePath()).exists()) {
        String msg = Messages.getString("String_Node_Str");
        informationLabel.setText(MessageFormat.format(msg, connection2.getXmlFilePath()));
        return;
    }
    if (tableEditorView.getMetadataEditor().getBeanCount() > 0) {
        MessageBox box = new MessageBox(getShell(), SWT.ICON_INFORMATION | SWT.YES | SWT.NO | SWT.CANCEL);
        box.setMessage(Messages.getString("String_Node_Str"));
        int open7 = box.open();
        if (open7 == SWT.YES) {
            runShadowProcess(true);
        } else if (open7 == SWT.NO) {
            runShadowProcess(false);
        }
        return;
    }
    runShadowProcess(true);
}

Output:
     }
-    if (!new File(connection2.getXmlFilePath()).exists()) {
+    if (tempXmlFilePath == null ? (!new File(connection2.getXmlFilePath()).exists()) : (!new File(connection2.getXmlFilePath()).exists() && !new File(tempXmlFilePath).exists())) {
         String msg = Messages.getString("String_Node_Str");


Input:
private static final CapabilityReport getCapabilityReport(String name) {
    Map<String, CapabilityReport> map = RMMethodSecurityInterceptor.capabilities.get();
    CapabilityReport capability = map.get(name);
    if (capability == null) {
        capability = new CapabilityReport();
        capability.name = name;
        map.put(name, capability);
    }
    return capability;
}

Output:
 private static final CapabilityReport getCapabilityReport(String name) {
-    Map<String, CapabilityReport> map = RMMethodSecurityInterceptor.capabilities.get();
+    Map<String, CapabilityReport> map = RMMethodSecurityInterceptor.CAPABILITIES.get();
     CapabilityReport capability = map.get(name);


Input:
private boolean pushMin() {
    if (min.getSelectionIndex() >= 0 && min.getItemCount() > 1) {
        if (min.getSelectionIndex() > (max.getSelectionIndex() + 1)) {
            min.select(max.getSelectionIndex() + 1);
        } else {
            if (model != null) {
                String val = min.getItem(min.getSelectionIndex());
                if (val.equals(ITEM_ALL)) {
                    model.getInputConfig().setMinimumGeneralization(attribute, null);
                } else {
                    model.getInputConfig().setMinimumGeneralization(attribute, Integer.valueOf(val) - 1);
                }
                return true;
            }
        }
    }
    return false;
}

Output:
             min.select(max.getSelectionIndex() + 1);
-        } else {
-            if (model != null) {
-                String val = min.getItem(min.getSelectionIndex());
-                if (val.equals(ITEM_ALL)) {
-                    model.getInputConfig().setMinimumGeneralization(attribute, null);
-                } else {
-                    model.getInputConfig().setMinimumGeneralization(attribute, Integer.valueOf(val) - 1);
-                }
-                return true;
+        }
+        if (model != null) {
+            String val = min.getItem(min.getSelectionIndex());
+            if (val.equals(ITEM_ALL)) {
+                model.getInputConfig().setMinimumGeneralization(attribute, null);
+            } else {
+                model.getInputConfig().setMinimumGeneralization(attribute, Integer.valueOf(val) - 1);
             }


Input:
public VolumeVO allocVolume(long accountId, long userId, String userSpecifiedName, DataCenterVO dc, DiskOfferingVO diskOffering, long startEventId, long size) {
    String volumeName = "String_Node_Str";
    VolumeVO createdVolume = null;
    try {
        volumeName = getRandomVolumeName();
        Account account = _accountDao.findById(accountId);
        VolumeVO volume = new VolumeVO(userSpecifiedName, -1, -1, -1, -1, new Long(-1), null, null, 0, Volume.VolumeType.DATADISK);
        volume.setPoolId(null);
        volume.setDataCenterId(dc.getId());
        volume.setPodId(null);
        volume.setAccountId(accountId);
        volume.setDomainId(account.getDomainId());
        volume.setMirrorState(MirrorState.NOT_MIRRORED);
        volume.setDiskOfferingId(diskOffering.getId());
        volume.setStorageResourceType(Storage.StorageResourceType.STORAGE_POOL);
        volume.setInstanceId(null);
        volume.setUpdated(new Date());
        volume.setStatus(AsyncInstanceCreateStatus.Created);
        volume.setDomainId(account.getDomainId());
        volume.setSourceId(diskOffering.getId());
        volume.setSourceType(SourceType.DiskOffering);
        volume.setState(Volume.State.Allocated);
        volume = _volsDao.persist(volume);
        AsyncJobExecutor asyncExecutor = BaseAsyncJobExecutor.getCurrentExecutor();
        if (asyncExecutor != null) {
            AsyncJobVO job = asyncExecutor.getJob();
            if (s_logger.isInfoEnabled())
                s_logger.info("String_Node_Str" + volume.getId() + "String_Node_Str" + job.getId() + "String_Node_Str");
            _asyncMgr.updateAsyncJobAttachment(job.getId(), "String_Node_Str", volume.getId());
            _asyncMgr.updateAsyncJobStatus(job.getId(), BaseCmd.PROGRESS_INSTANCE_CREATED, volume.getId());
        }
        createdVolume = volume;
    } catch (Exception e) {
        s_logger.error("String_Node_Str" + volumeName, e);
    }
    return createdVolume;
}

Output:
     String volumeName = "String_Node_Str";
-    VolumeVO createdVolume = null;
+    VolumeVO allocatedVolume = null;
     try {


Input:
public void testUtilDate() {
    final long now = System.currentTimeMillis();
    final Date date1 = new Date(now);
    final Date date2 = DateHelper.parseDate(date1.toString());
    Calendar cal1 = Calendar.getInstance(Locale.US);
    cal1.setTimeInMillis(date1.getTime());
    Calendar cal2 = Calendar.getInstance(Locale.US);
    cal2.setTimeInMillis(date2.getTime());
    Assert.assertEquals(cal1.get(Calendar.YEAR), cal2.get(Calendar.YEAR));
    Assert.assertEquals(cal1.get(Calendar.MONTH), cal2.get(Calendar.MONTH));
    Assert.assertEquals(cal1.get(Calendar.DAY_OF_MONTH), cal2.get(Calendar.DAY_OF_MONTH));
    Assert.assertEquals(cal1.get(Calendar.HOUR_OF_DAY), cal2.get(Calendar.HOUR_OF_DAY));
    Assert.assertEquals(cal1.get(Calendar.MINUTE), cal2.get(Calendar.MINUTE));
    Assert.assertEquals(cal1.get(Calendar.SECOND), cal2.get(Calendar.SECOND));
}

Output:
     final Date date1 = new Date(now);
-    final Date date2 = DateHelper.parseDate(date1.toString());
+    final Date date2 = DateHelper.parseDate(new SimpleDateFormat(DateHelperTest.DATE_FORMAT, Locale.US).format(date1));
     Calendar cal1 = Calendar.getInstance(Locale.US);


Input:
void commit() throws TransactionException, IllegalStateException {
    if (state != ACTIVE) {
        throw new IllegalStateException("String_Node_Str");
    }
    checkTimeout();
    try {
        state = PREPARING;
        final List<Future> futures = new ArrayList<Future>(partitions.size());
        final OperationService operationService = nodeEngine.getOperationService();
        for (Integer partitionId : partitions) {
            PrepareOperation op = new PrepareOperation(txnId);
            futures.add(operationService.createInvocationBuilder(SERVICE_NAME, op, partitionId).build().invoke());
        }
        for (Future future : futures) {
            future.get(timeoutMillis, TimeUnit.MILLISECONDS);
        }
        state = PREPARED;
        futures.clear();
        state = COMMITTING;
        for (Integer partitionId : partitions) {
            CommitOperation op = new CommitOperation(txnId);
            futures.add(operationService.createInvocationBuilder(SERVICE_NAME, op, partitionId).build().invoke());
        }
        for (Future future : futures) {
            future.get(timeoutMillis, TimeUnit.MILLISECONDS);
        }
        state = COMMITTED;
    } catch (Throwable e) {
        state = COMMIT_FAILED;
        if (e instanceof ExecutionException && e.getCause() instanceof TransactionException) {
            throw (TransactionException) e.getCause();
        }
        throw ExceptionUtil.rethrow(e);
    }
}

Output:
         for (Future future : futures) {
-            future.get(timeoutMillis, TimeUnit.MILLISECONDS);
+            future.get(5, TimeUnit.MINUTES);
         }


Input:
protected void buildQueryForProcedureType(ProcedureType procType, Project orProject, Project oxProject, ProcedureOperationModel opModel, boolean hasPLSQLArgs) {
    StoredProcedureCall call;
    ArgumentType returnArg = procType.isFunctionType() ? ((FunctionType) procType).getReturnArgument() : null;
    boolean hasCursor = hasPLSQLCursorArg(getArgumentListForProcedureType(procType));
    hasPLSQLArgs = hasPLSQLArgs || hasCursor || opModel.isPLSQLProcedureOperation();
    if (hasPLSQLArgs) {
        if (procType.isFunctionType()) {
            org.eclipse.persistence.internal.helper.DatabaseType dType = buildDatabaseTypeFromMetadataType(returnArg, procType.getCatalogName());
            if (hasCursor) {
                call = new PLSQLStoredFunctionCall();
                ((PLSQLStoredFunctionCall) call).getArguments().remove(0);
                ((PLSQLStoredFunctionCall) call).useNamedCursorOutputAsResultSet(CURSOR_STR, dType);
            } else {
                Class wrapperClass = getWrapperClass(dType);
                if (wrapperClass != null) {
                    ((ComplexDatabaseType) dType).setJavaType(wrapperClass);
                }
                call = new PLSQLStoredFunctionCall(dType);
                if (returnArg.getEnclosedType().isPLSQLCollectionType() && !((PLSQLCollectionType) returnArg.getEnclosedType()).isIndexed()) {
                    PLSQLargument plsqlArg = ((PLSQLStoredFunctionCall) call).getArguments().get(0);
                    ((PLSQLCollection) plsqlArg.databaseType).setIsNestedTable(true);
                }
            }
        } else {
            call = new PLSQLStoredProcedureCall();
        }
    } else {
        if (procType.isFunctionType()) {
            String javaTypeName = returnArg.getTypeName();
            ClassDescriptor desc = oxProject.getDescriptorForAlias(getGeneratedAlias(javaTypeName));
            if (desc != null) {
                javaTypeName = desc.getJavaClassName();
            }
            if (returnArg.isComposite()) {
                DatabaseType dataType = returnArg.getEnclosedType();
                if (dataType.isVArrayType() || dataType.isObjectTableType()) {
                    call = new StoredFunctionCall(Types.ARRAY, returnArg.getTypeName(), javaTypeName, buildFieldForNestedType(dataType));
                } else {
                    call = new StoredFunctionCall(Types.STRUCT, returnArg.getTypeName(), javaTypeName);
                }
            } else {
                call = new StoredFunctionCall();
                if (returnArg.getEnclosedType().isBlobType()) {
                    ((StoredFunctionCall) call).setResult(null, ClassConstants.BLOB);
                } else {
                    int resultType = Util.getJDBCTypeFromTypeName(javaTypeName);
                    if (resultType == Types.DATE || resultType == Types.TIME || resultType == Types.TIMESTAMP) {
                        ((StoredFunctionCall) call).setResult(null, ClassConstants.TIMESTAMP);
                    } else if (returnArg.getEnclosedType() == ScalarDatabaseTypeEnum.XMLTYPE_TYPE) {
                        ((StoredFunctionCall) call).setResult(null, Types.SQLXML);
                    } else if (resultType == Types.OTHER || resultType == Types.CLOB) {
                        ((StoredFunctionCall) call).setResult(null, ClassConstants.OBJECT);
                    } else {
                        ((StoredFunctionCall) call).setResult(null, resultType);
                    }
                }
            }
        } else {
            call = new StoredProcedureCall();
        }
    }
    String cat = procType.getCatalogName();
    String catalogPrefix = (cat == null || cat.length() == 0) ? EMPTY_STRING : cat + DOT;
    call.setProcedureName(catalogPrefix + procType.getProcedureName());
    String returnType = opModel.getReturnType();
    boolean hasResponse = returnType != null;
    DatabaseQuery dq = null;
    if (hasCursor || (hasResponse && opModel.isCollection())) {
        dq = new DataReadQuery();
    } else {
        dq = new ValueReadQuery();
    }
    dq.bindAllParameters();
    dq.setName(getNameForQueryOperation(opModel, procType));
    dq.setCall(call);
    for (ArgumentType arg : procType.getArguments()) {
        if (arg.optional()) {
            call.addOptionalArgument(arg.getArgumentName());
        }
        DatabaseType argType = arg.getEnclosedType();
        ArgumentTypeDirection direction = arg.getDirection();
        org.eclipse.persistence.internal.helper.DatabaseType databaseType = null;
        String javaTypeName = null;
        if (hasPLSQLArgs) {
            databaseType = buildDatabaseTypeFromMetadataType(argType, cat);
        } else {
            javaTypeName = argType.getTypeName();
            ClassDescriptor desc = oxProject.getDescriptorForAlias(getGeneratedAlias(javaTypeName));
            if (desc != null) {
                javaTypeName = desc.getJavaClassName();
            }
        }
        if (direction == IN) {
            if (hasPLSQLArgs) {
                Class wrapperClass = getWrapperClass(databaseType);
                if (wrapperClass != null) {
                    ((ComplexDatabaseType) databaseType).setJavaType(wrapperClass);
                }
                ((PLSQLStoredProcedureCall) call).addNamedArgument(arg.getArgumentName(), databaseType);
                if (argType.isPLSQLCollectionType() && !((PLSQLCollectionType) argType).isIndexed()) {
                    PLSQLargument plsqlArg = ((PLSQLStoredProcedureCall) call).getArguments().get(((PLSQLStoredProcedureCall) call).getArguments().size() - 1);
                    ((PLSQLCollection) plsqlArg.databaseType).setIsNestedTable(true);
                }
            } else {
                if (argType.isVArrayType()) {
                    dq.addArgument(arg.getArgumentName());
                    call.addNamedArgument(arg.getArgumentName(), arg.getArgumentName(), Types.ARRAY, argType.getTypeName(), javaTypeName);
                } else if (argType.isObjectType()) {
                    dq.addArgument(arg.getArgumentName());
                    call.addNamedArgument(arg.getArgumentName(), arg.getArgumentName(), Types.STRUCT, argType.getTypeName(), javaTypeName);
                } else if (argType.isObjectTableType()) {
                    dq.addArgument(arg.getArgumentName(), java.sql.Array.class);
                    call.addNamedArgument(arg.getArgumentName(), arg.getArgumentName(), Types.ARRAY, argType.getTypeName(), getWrapperClass(javaTypeName), buildFieldForNestedType(argType));
                } else {
                    dq.addArgument(arg.getArgumentName());
                    call.addNamedArgument(arg.getArgumentName(), arg.getArgumentName(), Util.getJDBCTypeFromTypeName(argType.getTypeName()));
                }
            }
        } else if (direction == OUT) {
            if (hasPLSQLArgs) {
                if (arg.isPLSQLCursorType()) {
                    ((PLSQLStoredProcedureCall) call).useNamedCursorOutputAsResultSet(arg.getArgumentName(), databaseType);
                } else {
                    Class wrapperClass = getWrapperClass(databaseType);
                    if (wrapperClass != null) {
                        ((ComplexDatabaseType) databaseType).setJavaType(wrapperClass);
                    }
                    ((PLSQLStoredProcedureCall) call).addNamedOutputArgument(arg.getArgumentName(), databaseType);
                }
            } else {
                if (argType.isComposite()) {
                    Class wrapperClass = getWrapperClass(javaTypeName);
                    if (argType.isVArrayType() || argType.isObjectTableType()) {
                        call.addNamedOutputArgument(arg.getArgumentName(), arg.getArgumentName(), Types.ARRAY, argType.getTypeName(), wrapperClass, buildFieldForNestedType(argType));
                    } else {
                        call.addNamedOutputArgument(arg.getArgumentName(), arg.getArgumentName(), Types.STRUCT, argType.getTypeName(), wrapperClass);
                    }
                } else {
                    if (argType == ScalarDatabaseTypeEnum.XMLTYPE_TYPE) {
                        call.addNamedOutputArgument(arg.getArgumentName(), arg.getArgumentName(), Types.SQLXML);
                    } else if (argType == ScalarDatabaseTypeEnum.SYS_REFCURSOR_TYPE) {
                        call.addNamedCursorOutputArgument(arg.getArgumentName());
                    } else {
                        call.addNamedOutputArgument(arg.getArgumentName(), arg.getArgumentName(), Util.getJDBCTypeFromTypeName(argType.getTypeName()));
                    }
                }
            }
        } else {
            if (hasPLSQLArgs) {
                Class wrapperClass = getWrapperClass(databaseType);
                if (wrapperClass != null) {
                    ((ComplexDatabaseType) databaseType).setJavaType(wrapperClass);
                }
                ((PLSQLStoredProcedureCall) call).addNamedInOutputArgument(arg.getArgumentName(), databaseType);
                if (argType.isPLSQLCollectionType() && !((PLSQLCollectionType) argType).isIndexed()) {
                    PLSQLargument plsqlArg = ((PLSQLStoredProcedureCall) call).getArguments().get(((PLSQLStoredProcedureCall) call).getArguments().size() - 1);
                    ((PLSQLCollection) plsqlArg.databaseType).setIsNestedTable(true);
                }
            } else {
                dq.addArgument(arg.getArgumentName());
                if (argType.isComposite()) {
                    Class wrapperClass = getWrapperClass(javaTypeName);
                    if (argType.isVArrayType() || argType.isObjectTableType()) {
                        call.addNamedInOutputArgument(arg.getArgumentName(), arg.getArgumentName(), arg.getArgumentName(), Types.ARRAY, argType.getTypeName(), wrapperClass, buildFieldForNestedType(argType));
                    } else {
                        call.addNamedInOutputArgument(arg.getArgumentName(), arg.getArgumentName(), arg.getArgumentName(), Types.STRUCT, argType.getTypeName());
                    }
                } else {
                    Class javaType = getClassFromJDBCType(argType.getTypeName(), dbwsBuilder.getDatabasePlatform());
                    if (shouldSetJavaType(javaType.getName())) {
                        call.addNamedInOutputArgument(arg.getArgumentName(), arg.getArgumentName(), arg.getArgumentName(), Util.getJDBCTypeFromTypeName(argType.getTypeName()), argType.getTypeName(), javaType);
                    } else {
                        call.addNamedInOutputArgument(arg.getArgumentName());
                    }
                }
            }
        }
        if (hasPLSQLArgs && (direction == IN || direction == INOUT)) {
            ClassDescriptor xdesc = null;
            if (hasResponse) {
                int idx = returnType.indexOf(COLON);
                if (idx == -1) {
                    idx = returnType.indexOf(CLOSE_PAREN);
                }
                if (idx > 0) {
                    String typ = returnType.substring(idx + 1);
                    for (XMLDescriptor xd : (List<XMLDescriptor>) (List) oxProject.getOrderedDescriptors()) {
                        if (xd.getSchemaReference() != null) {
                            String context = xd.getSchemaReference().getSchemaContext();
                            if (context.substring(1).equals(typ)) {
                                xdesc = xd;
                                break;
                            }
                        }
                    }
                }
            }
            if (xdesc != null) {
                dq.addArgumentByTypeName(arg.getArgumentName(), xdesc.getJavaClassName());
            } else {
                if (databaseType instanceof PLSQLCollection || databaseType instanceof VArrayType) {
                    dq.addArgument(arg.getArgumentName(), Array.class);
                } else if (databaseType instanceof PLSQLrecord || databaseType instanceof OracleObjectType) {
                    dq.addArgument(arg.getArgumentName(), Struct.class);
                } else {
                    dq.addArgument(arg.getArgumentName(), JDBCTypes.getClassForCode(databaseType.getConversionCode()));
                }
            }
        }
    }
    orProject.getQueries().add(dq);
}

Output:
                     } else if (returnArg.getEnclosedType() == ScalarDatabaseTypeEnum.XMLTYPE_TYPE) {
-                        ((StoredFunctionCall) call).setResult(null, Types.SQLXML);
+                        ((StoredFunctionCall) call).setResult(getJDBCTypeForTypeName(XMLTYPE_STR), XMLTYPE_STR, ClassConstants.OBJECT);
                     } else if (resultType == Types.OTHER || resultType == Types.CLOB) {


Input:
private void readDataFromFile(String path, Vector<Vector<Double>> data, int algorithmIndex) {
    String string = "String_Node_Str";
    try {
        FileInputStream fis = new FileInputStream(path);
        byte[] bytes = new byte[4096];
        int readBytes = 0;
        while (readBytes != -1) {
            readBytes = fis.read(bytes);
            if (readBytes != -1) {
                string += new String(bytes, 0, readBytes);
            }
        }
        fis.close();
    } catch (IOException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    StringTokenizer lines = new StringTokenizer(string, "String_Node_Str");
    double valor = 0.0;
    int n = 0;
    while (lines.hasMoreTokens()) {
        valor = valor + Double.parseDouble(lines.nextToken());
        n++;
    }
    if (n != 0) {
        (data.elementAt(algorithmIndex)).add(valor / n);
    } else {
        (data.elementAt(algorithmIndex)).add(valor);
    }
}

Output:
     } catch (IOException e) {
-        e.printStackTrace();
-        System.exit(-1);
+        throw new JMetalException("String_Node_Str", e);
     }


Input:
public void deleteAllFrom(final long internalID, final String table) {
    plugin.getServerBridge().runTaskAsynchronously(new Runnable() {
        public void run() {
            try (Statement statement = getConnection().createStatement()) {
                statement.execute("String_Node_Str" + table + "String_Node_Str" + internalID);
                getConnection().commit();
            } catch (SQLException e) {
                plugin.getLogger().severe("String_Node_Str" + internalID + "String_Node_Str" + table);
                plugin.getLogger().severe("String_Node_Str" + e.getMessage());
                plugin.getLogger().severe("String_Node_Str" + e.getErrorCode());
                plugin.getLogger().severe("String_Node_Str" + e.getSQLState());
            }
        }
    });
}

Output:
 public void deleteAllFrom(final long internalID, final String table) {
-    plugin.getServerBridge().runTaskAsynchronously(new Runnable() {
-        public void run() {
-            try (Statement statement = getConnection().createStatement()) {
-                statement.execute("String_Node_Str" + table + "String_Node_Str" + internalID);
-                getConnection().commit();
-            } catch (SQLException e) {
-                plugin.getLogger().severe("String_Node_Str" + internalID + "String_Node_Str" + table);
-                plugin.getLogger().severe("String_Node_Str" + e.getMessage());
-                plugin.getLogger().severe("String_Node_Str" + e.getErrorCode());
-                plugin.getLogger().severe("String_Node_Str" + e.getSQLState());
-            }
-        }
-    });
+    try (Statement statement = getConnection().createStatement()) {
+        statement.execute("String_Node_Str" + table + "String_Node_Str" + internalID);
+        getConnection().commit();
+    } catch (SQLException e) {
+        plugin.getLogger().severe("String_Node_Str" + internalID + "String_Node_Str" + table);
+        plugin.getLogger().severe("String_Node_Str" + e.getMessage());
+        plugin.getLogger().severe("String_Node_Str" + e.getErrorCode());
+        plugin.getLogger().severe("String_Node_Str" + e.getSQLState());
+    }
 }


Input:
private void createFeedbackResponsesFromSubmission(String feedbackSessionName, String courseId, boolean peerFeedback, List<String> fqIds, SubmissionAttributes sub) {
    String giver = sub.reviewer;
    String recipient = sub.reviewee;
    String giverSection = "String_Node_Str";
    String recipientSection = "String_Node_Str";
    StudentAttributes studentGiver = logic.getStudentForEmail(courseId, giver);
    recipientSection = (studentGiver == null) ? Const.DEFAULT_SECTION : studentGiver.section;
    StudentAttributes studentRecipient = logic.getStudentForEmail(courseId, recipient);
    recipientSection = (studentRecipient == null) ? Const.DEFAULT_SECTION : studentRecipient.section;
    FeedbackResponseAttributes q1Response = null;
    FeedbackResponseAttributes q2Response = null;
    FeedbackResponseAttributes q3Response = null;
    FeedbackResponseAttributes q4Response = null;
    FeedbackResponseAttributes q5Response = null;
    if (sub.points != Const.POINTS_NOT_SUBMITTED) {
        q1Response = new FeedbackResponseAttributes();
        q1Response.setId(null);
        q1Response.feedbackSessionName = feedbackSessionName;
        q1Response.courseId = courseId;
        q1Response.giverEmail = giver;
        q1Response.giverSection = giverSection;
        q1Response.recipientEmail = recipient;
        q1Response.recipientSection = recipientSection;
        q1Response.feedbackQuestionType = FeedbackQuestionType.CONTRIB;
        q1Response.feedbackQuestionId = fqIds.get(0);
        FeedbackAbstractResponseDetails responseDetails1 = new FeedbackContributionResponseDetails(sub.points);
        q1Response.setResponseDetails(responseDetails1);
    }
    if (giver.equals(recipient)) {
        q2Response = new FeedbackResponseAttributes();
        q2Response.setId(null);
        q2Response.feedbackSessionName = feedbackSessionName;
        q2Response.courseId = courseId;
        q2Response.giverEmail = giver;
        q2Response.giverSection = giverSection;
        q2Response.recipientEmail = recipient;
        q2Response.recipientSection = recipientSection;
        q2Response.feedbackQuestionType = FeedbackQuestionType.TEXT;
        q2Response.feedbackQuestionId = fqIds.get(1);
        FeedbackAbstractResponseDetails responseDetails2 = new FeedbackTextResponseDetails(sub.justification.getValue());
        q2Response.setResponseDetails(responseDetails2);
    } else {
        q3Response = new FeedbackResponseAttributes();
        q3Response.setId(null);
        q3Response.feedbackSessionName = feedbackSessionName;
        q3Response.courseId = courseId;
        q3Response.giverEmail = giver;
        q3Response.giverSection = giverSection;
        q3Response.recipientEmail = recipient;
        q3Response.recipientSection = recipientSection;
        q3Response.feedbackQuestionType = FeedbackQuestionType.TEXT;
        q3Response.feedbackQuestionId = fqIds.get(2);
        FeedbackAbstractResponseDetails responseDetails3 = new FeedbackTextResponseDetails(sub.justification.getValue());
        q3Response.setResponseDetails(responseDetails3);
    }
    if (peerFeedback) {
        if (giver.equals(recipient)) {
            q4Response = new FeedbackResponseAttributes();
            q4Response.setId(null);
            q4Response.feedbackSessionName = feedbackSessionName;
            q4Response.courseId = courseId;
            q4Response.giverEmail = giver;
            q4Response.giverSection = giverSection;
            q4Response.recipientEmail = recipient;
            q4Response.recipientSection = recipientSection;
            q4Response.feedbackQuestionType = FeedbackQuestionType.TEXT;
            q4Response.feedbackQuestionId = fqIds.get(3);
            FeedbackAbstractResponseDetails responseDetails4 = new FeedbackTextResponseDetails(sub.p2pFeedback.getValue());
            q4Response.setResponseDetails(responseDetails4);
        } else {
            q5Response = new FeedbackResponseAttributes();
            q5Response.setId(null);
            q5Response.feedbackSessionName = feedbackSessionName;
            q5Response.courseId = courseId;
            q5Response.giverEmail = giver;
            q5Response.giverSection = giverSection;
            q5Response.recipientEmail = recipient;
            q5Response.recipientSection = recipientSection;
            q5Response.feedbackQuestionType = FeedbackQuestionType.TEXT;
            q5Response.feedbackQuestionId = fqIds.get(4);
            FeedbackAbstractResponseDetails responseDetails5 = new FeedbackTextResponseDetails(sub.p2pFeedback.getValue());
            q5Response.setResponseDetails(responseDetails5);
        }
    }
    List<FeedbackResponseAttributes> allResponses = new ArrayList<FeedbackResponseAttributes>();
    allResponses.add(q1Response);
    allResponses.add(q2Response);
    allResponses.add(q3Response);
    allResponses.add(q4Response);
    allResponses.add(q5Response);
    for (FeedbackResponseAttributes response : allResponses) {
        if (response != null) {
            if (!(response.responseMetaData.getValue().isEmpty() || response.recipientEmail.isEmpty())) {
                try {
                    logic.createFeedbackResponse(response);
                } catch (EntityAlreadyExistsException e) {
                    System.out.println("String_Node_Str");
                    e.printStackTrace();
                } catch (InvalidParametersException e) {
                    System.out.println("String_Node_Str");
                    e.printStackTrace();
                }
            }
        }
    }
}

Output:
     StudentAttributes studentGiver = logic.getStudentForEmail(courseId, giver);
-    recipientSection = (studentGiver == null) ? Const.DEFAULT_SECTION : studentGiver.section;
+    giverSection = (studentGiver == null) ? Const.DEFAULT_SECTION : studentGiver.section;
     StudentAttributes studentRecipient = logic.getStudentForEmail(courseId, recipient);


Input:
protected Object parseValue(CommandSource source, CommandArgs args) throws ArgumentParseException {
    String var = args.next();
    switch(var) {
        case "String_Node_Str":
        case "String_Node_Str":
        case "String_Node_Str":
            return true;
        case "String_Node_Str":
        case "String_Node_Str":
        case "String_Node_Str":
            return false;
        default:
            throw args.createError(Messages.getFormatted("String_Node_Str", "String_Node_Str", var));
    }
}

Output:
     String var = args.next();
-    switch(var) {
+    switch(var.toLowerCase()) {
+        case "String_Node_Str":
+        case "String_Node_Str":
+        case "String_Node_Str":
         case "String_Node_Str":


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    Permanent doorOfDestinies = game.getPermanent(getSourceId());
    if (doorOfDestinies != null) {
        String subtype = (String) game.getState().getValue(doorOfDestinies.getId() + "String_Node_Str");
        if (subtype != null) {
            FilterSpell filter = new FilterSpell();
            filter.add(new ControllerPredicate(TargetController.YOU));
            filter.add(new SubtypePredicate(subtype));
            Spell spell = game.getStack().getSpell(event.getTargetId());
            if (spell != null && filter.match(spell, getSourceId(), getControllerId(), game)) {
                return true;
            }
        }
    }
    return false;
}

Output:
             filter.add(new ControllerPredicate(TargetController.YOU));
-            filter.add(new SubtypePredicate(subtype));
+            filter.add(new SubtypePredicate(SubType.byDescription(subtype)));
             Spell spell = game.getStack().getSpell(event.getTargetId());