Input:
public synchronized void shutdown() {
    libgtk.gdk_threads_enter();
    libappindicator.app_indicator_set_status(this.appIndicator, AppIndicator.STATUS_PASSIVE);
    Pointer p = this.appIndicator.getPointer();
    libgobject.g_object_unref(p);
    this.appIndicator = null;
    super.shutdown();
}

Output:
 public synchronized void shutdown() {
-    libgtk.gdk_threads_enter();
-    libappindicator.app_indicator_set_status(this.appIndicator, AppIndicator.STATUS_PASSIVE);
+    gtk.gdk_threads_enter();
+    appindicator.app_indicator_set_status(this.appIndicator, AppIndicator.STATUS_PASSIVE);
     Pointer p = this.appIndicator.getPointer();


Input:
private void testAnimCircleIndicator() {
    mAnimCircleIndicator = (InfiniteIndicator) findViewById(R.id.infinite_anim_circle);
    IndicatorConfiguration configuration = new IndicatorConfiguration.Builder().imageLoader(new UILoader()).isStopWhileTouch(true).onPageChangeListener(this).onPageClickListener(this).direction(LEFT).position(IndicatorConfiguration.IndicatorPosition.Center).build();
    mAnimCircleIndicator.init(configuration);
    mAnimCircleIndicator.notifyDataChange(pageViews);
    mAnimCircleIndicator.setCurrentItem(3);
}

Output:
     mAnimCircleIndicator = (InfiniteIndicator) findViewById(R.id.infinite_anim_circle);
-    IndicatorConfiguration configuration = new IndicatorConfiguration.Builder().imageLoader(new UILoader()).isStopWhileTouch(true).onPageChangeListener(this).onPageClickListener(this).direction(LEFT).position(IndicatorConfiguration.IndicatorPosition.Center).build();
+    IndicatorConfiguration configuration = new IndicatorConfiguration.Builder().imageLoader(new UILoader()).isStopWhileTouch(true).isLoop(false).onPageChangeListener(this).onPageClickListener(this).direction(LEFT).position(IndicatorConfiguration.IndicatorPosition.Center).build();
     mAnimCircleIndicator.init(configuration);


Input:
public boolean next(final LongWritable key, final Text value) throws IOException {
    if (!stillInChunk)
        return false;
    final long startPos = fsin.getPos();
    boolean status = readUntilMatch(endTag, true);
    final String data;
    if (startPos == 0)
        data = new String(buffer.getData(), 1, buffer.getLength());
    else
        data = new String(buffer.getData(), 0, buffer.getLength());
    final String[] lines = PATTERN.split(data);
    for (int i = 0; i < lines.length; i++) {
        final String line = lines[i].trim();
        if ("String_Node_Str".equals(line))
            continue;
        sb.append(line);
        if (i == 0)
            sb.append("String_Node_Str");
    }
    if (sb.charAt(sb.length() - 1) == '>')
        sb.setLength(sb.length() - 1);
    key.set(fsin.getPos());
    value.set(sb.toString());
    sb.setLength(0);
    buffer.reset();
    if (!status) {
        stillInChunk = false;
    }
    return true;
}

Output:
     if (startPos == 0)
-        data = new String(buffer.getData(), 1, buffer.getLength());
+        data = new String(buffer.getData(), 1, buffer.getLength(), CHARSET);
     else


Input:
public static void showAlignmentImage(MultipleAlignment multAln, String result) {
    JFrame frame = new JFrame();
    String title = multAln.getEnsemble().getAlgorithmName() + "String_Node_Str" + multAln.getEnsemble().getVersion();
    frame.setTitle(title);
    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    AlignmentTextPanel txtPanel = new AlignmentTextPanel();
    txtPanel.setText(result);
    JMenuBar menu = MenuCreator.getAlignmentTextMenu(frame, txtPanel, multAln);
    frame.setJMenuBar(menu);
    JScrollPane js = new JScrollPane();
    js.getViewport().add(txtPanel);
    js.getViewport().setBorder(null);
    frame.getContentPane().add(js);
    frame.pack();
    frame.setVisible(true);
}

Output:
     txtPanel.setText(result);
-    JMenuBar menu = MenuCreator.getAlignmentTextMenu(frame, txtPanel, multAln);
+    JMenuBar menu = MenuCreator.getAlignmentTextMenu(frame, txtPanel, null);
     frame.setJMenuBar(menu);


Input:
public void setUpperThreshold(int threshold) {
    int newListIndex = 0;
    if (sourceSize == 0) {
        upperThreshold = threshold;
        upperThresholdIndex = -1;
        return;
    } else if (threshold == upperThreshold) {
        return;
    } else {
        if (threshold == Integer.MAX_VALUE) {
            newListIndex = sourceSize - 1;
        } else {
            newListIndex = ((SortedList) source).indexOfSimulated(new Integer(threshold + 1)) - 1;
        }
    }
    upperThreshold = threshold;
    if (newListIndex == upperThresholdIndex) {
        return;
    }
    if ((newListIndex == -1 && upperThresholdIndex == 0) || (newListIndex == 0 && upperThresholdIndex == -1) || (newListIndex == size() && upperThresholdIndex == size() - 1) || (newListIndex == size() - 1 && upperThresholdIndex == size())) {
        upperThresholdIndex = newListIndex;
        return;
    }
    updates.beginEvent();
    if (newListIndex < upperThresholdIndex) {
        updates.addDelete(newListIndex + 1, upperThresholdIndex - Math.max(lowerThresholdIndex, 0));
    } else if (newListIndex > upperThresholdIndex) {
        updates.addInsert(upperThresholdIndex - Math.max(lowerThresholdIndex, 0) + 1, newListIndex);
    }
    upperThresholdIndex = newListIndex;
    updates.commitEvent();
}

Output:
     }
-    if ((newListIndex == -1 && upperThresholdIndex == 0) || (newListIndex == 0 && upperThresholdIndex == -1) || (newListIndex == size() && upperThresholdIndex == size() - 1) || (newListIndex == size() - 1 && upperThresholdIndex == size())) {
+    if ((newListIndex == size() && upperThresholdIndex == size() - 1) || (newListIndex == size() - 1 && upperThresholdIndex == size())) {
         upperThresholdIndex = newListIndex;


Input:
private Set<InferredPath> computePaths(PathKey key) {
    final InferredEdge currentEdge = key.getState().getInferredEdge();
    final Coordinate toCoord = GeoUtils.reverseCoordinates(key.getEndCoord());
    final Set<InferredPath> paths = Sets.newHashSet(InferredPath.getEmptyPath());
    final Set<Edge> startEdges = Sets.newHashSet();
    final double stateStdDevDistance = 1.98d * Math.sqrt(key.getState().getBelief().getCovariance().normFrobenius());
    if (!currentEdge.isEmptyEdge()) {
        startEdges.add(currentEdge.getEdge());
    } else {
        final Coordinate fromCoord = GeoUtils.reverseCoordinates(key.getStartCoord());
        final Envelope fromEnv = new Envelope(fromCoord);
        fromEnv.expandBy(GeoUtils.getMetersInAngleDegrees(stateStdDevDistance));
        for (final Object obj : this.narratedGraph.getEdgeIndex().query(fromEnv)) {
            final Edge edge = (Edge) obj;
            startEdges.add(edge);
        }
    }
    final Set<Edge> endEdges = Sets.newHashSet();
    final Envelope toEnv = new Envelope(toCoord);
    final double obsStdDevDistance = 1.98d * Math.sqrt(key.getState().getMovementFilter().getObsVariance().normFrobenius());
    toEnv.expandBy(GeoUtils.getMetersInAngleDegrees(obsStdDevDistance));
    for (final Object obj : this.narratedGraph.getEdgeIndex().query(toEnv)) {
        final Edge edge = (Edge) obj;
        endEdges.add(edge);
    }
    final List<Edge> endEdgeList = Lists.newArrayList(endEdges);
    for (final Edge startEdge : startEdges) {
        final MultiDestinationAStar forwardAStar = new MultiDestinationAStar(this.graph, endEdgeList, toCoord, obsStdDevDistance, startEdge);
        final MultiDestinationAStar backwardAStar = new MultiDestinationAStar(this.graph, endEdgeList, toCoord, obsStdDevDistance, startEdge);
        final ShortestPathTree spt1 = forwardAStar.getSPT(false);
        final ShortestPathTree spt2 = backwardAStar.getSPT(true);
        for (final Edge endEdge : endEdgeList) {
            final GraphPath forwardPath = spt1.getPath(endEdge.getToVertex(), false);
            if (forwardPath != null) {
                final InferredPath forwardResult = copyAStarResults(forwardPath, startEdge, false);
                if (forwardResult != null) {
                    paths.add(forwardResult);
                    forwardResult.setStartEdge(this.getInferredEdge(startEdge));
                    forwardResult.setEndEdge(this.getInferredEdge(endEdge));
                }
            }
            final GraphPath backwardPath = spt2.getPath(endEdge.getFromVertex(), false);
            if (backwardPath != null) {
                final InferredPath backwardResult = copyAStarResults(backwardPath, startEdge, true);
                if (backwardResult != null) {
                    paths.add(backwardResult);
                    backwardResult.setStartEdge(this.getInferredEdge(startEdge));
                    backwardResult.setEndEdge(this.getInferredEdge(endEdge));
                }
            }
        }
    }
    return paths;
}

Output:
         final Edge edge = (Edge) obj;
-        endEdges.add(edge);
+        if (((StreetEdge) edge).canTraverse(options)) {
+            endEdges.add(edge);
+        }
     }


Input:
private void branchOptimizer(final Expression node, final Label label, final boolean state) {
    if (!(node instanceof TernaryNode)) {
        if (node instanceof BinaryNode) {
            branchOptimizer((BinaryNode) node, label, state);
            return;
        }
        if (node instanceof UnaryNode) {
            branchOptimizer((UnaryNode) node, label, state);
            return;
        }
    }
    load(node);
    method.convert(Type.BOOLEAN);
    if (state) {
        method.ifne(label);
    } else {
        method.ifeq(label);
    }
}

Output:
     }
-    load(node);
+    codegen.load(node);
     method.convert(Type.BOOLEAN);


Input:
protected Object reduce(Map<Member, Object> map) throws Throwable {
    for (Map.Entry<Member, Object> entry : map.entrySet()) {
        Member member = entry.getKey();
        Object response = entry.getValue();
        if (response instanceof Throwable) {
            if (response instanceof MemberLeftException) {
                cleanedUpMembers.add(member);
                continue;
            }
            logger.warning("String_Node_Str" + member, (Throwable) response);
            return prepareUnauthenticatedClientMessage();
        }
        boolean isClientDisconnectOperationRun = (Boolean) response;
        if (isClientDisconnectOperationRun) {
            cleanedUpMembers.add(member);
        }
    }
    return prepareAuthenticatedClientMessage();
}

Output:
             }
-            logger.warning("String_Node_Str" + member, (Throwable) response);
-            return prepareUnauthenticatedClientMessage();
+            throw (Throwable) response;
         }


Input:
public Long addNewServiceToProject(Long poid, SNewService sService, SAction sAction) throws ServerException, UserException {
    requireRealUserAuthentication();
    DatabaseSession session = getBimServer().getDatabase().createSession();
    try {
        Action action = null;
        if (sAction instanceof SCheckinRevision) {
            action = (Action) session.create(StorePackage.eINSTANCE.getCheckinRevision());
        } else if (sAction instanceof SStoreExtendedData) {
            action = (Action) session.create(StorePackage.eINSTANCE.getStoreExtendedData());
        }
        getBimServer().getSConverter().convertFromSObject(sAction, action, session);
        NewService service = (NewService) session.create(StorePackage.eINSTANCE.getNewService());
        getBimServer().getSConverter().convertFromSObject(sService, service, session);
        AddNewServiceToProjectDatabaseAction dbAction = new AddNewServiceToProjectDatabaseAction(session, getInternalAccessMethod(), poid, service, action, getAuthorization());
        return session.executeAndCommitAction(dbAction);
    } catch (Exception e) {
        return handleException(e);
    } finally {
        session.close();
    }
}

Output:
         getBimServer().getSConverter().convertFromSObject(sService, service, session);
-        AddNewServiceToProjectDatabaseAction dbAction = new AddNewServiceToProjectDatabaseAction(session, getInternalAccessMethod(), poid, service, action, getAuthorization());
+        AddNewServiceToProjectDatabaseAction dbAction = new AddNewServiceToProjectDatabaseAction(session, getInternalAccessMethod(), poid, service, service.getAction(), getAuthorization());
         return session.executeAndCommitAction(dbAction);


Input:
public KeyboardProperties getKeyboardProperties() {
    Object obj = parameters.get(KEY_KEYBOARD_PROPERTIES);
    if (obj instanceof Image) {
        return (KeyboardProperties) obj;
    } else if (obj instanceof Hashtable) {
        try {
            return new KeyboardProperties((Hashtable<String, Object>) obj);
        } catch (Exception e) {
            DebugTool.logError("String_Node_Str" + getClass().getSimpleName() + "String_Node_Str" + KEY_KEYBOARD_PROPERTIES, e);
        }
    }
    return null;
}

Output:
     Object obj = parameters.get(KEY_KEYBOARD_PROPERTIES);
-    if (obj instanceof Image) {
+    if (obj instanceof KeyboardProperties) {
         return (KeyboardProperties) obj;


Input:
public String decryptValue(String toDecrypt, String passphrase) {
    log.info("String_Node_Str");
    if (!toDecrypt.startsWith("String_Node_Str")) {
        log.debug("String_Node_Str");
        return toDecrypt;
    }
    toDecrypt = toDecrypt.substring(3);
    try {
        Cipher cipher = Cipher.getInstance("String_Node_Str");
        String ivString = passphrase + passphrase;
        String iv = DigestUtils.sha256Hex(ivString);
        String passphraseDigest = DigestUtils.sha256Hex(passphrase);
        SecretKeySpec spec = new SecretKeySpec(Arrays.copyOfRange(passphraseDigest.getBytes(), 0, 32), "String_Node_Str");
        cipher.init(Cipher.DECRYPT_MODE, spec, new IvParameterSpec(iv.getBytes(), 0, 16));
        byte[] b64bytes = Base64.decodeBase64(toDecrypt);
        return new String(cipher.doFinal(b64bytes));
    } catch (Exception e) {
        log.warn("String_Node_Str" + toDecrypt, e);
        throw new RuntimeException(e);
    }
}

Output:
     } catch (Exception e) {
-        log.warn("String_Node_Str" + toDecrypt, e);
+        log.error("String_Node_Str" + toDecrypt, e);
         throw new RuntimeException(e);


Input:
public Operation newPrepareOperation() {
    return new TxnPrepareOperation(partitionId, name, key, ttl, threadId);
}

Output:
 public Operation newPrepareOperation() {
-    return new TxnPrepareOperation(partitionId, name, key, ttl, threadId);
+    return new TxnPrepareOperation(partitionId, name, key, threadId);
 }


Input:
public Map<String, String> appendExtendedSql(StringBuilder sqlSb, DbmsStatementType statementType, boolean isSubquery, StringBuilder withClause, String limit, String offset, String[] returningColumns, Map<DbmsModificationState, String> includedModificationStates) {
    if (isSubquery && returningColumns != null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    sqlSb.insert(indexOfIgnoreCase(sqlSb, "String_Node_Str"), withClause);
    if (limit != null) {
        appendLimit(sqlSb, isSubquery, limit, offset);
    }
    return null;
}

Output:
     }
-    sqlSb.insert(indexOfIgnoreCase(sqlSb, "String_Node_Str"), withClause);
+    if (withClause != null) {
+        sqlSb.insert(indexOfIgnoreCase(sqlSb, "String_Node_Str"), withClause);
+    }
     if (limit != null) {


Input:
protected void putTransientInternal(final Data key, final Data value, final long ttl, final TimeUnit timeunit) {
    PutTransientOperation operation = new PutTransientOperation(name, key, value, getTimeInMillis(ttl, timeunit));
    invokeOperation(key, operation);
    invalidateLocalNearCache(key);
}

Output:
     invokeOperation(key, operation);
-    invalidateLocalNearCache(key);
+    invalidateNearCache(key);
 }


Input:
private static void parse(CSharpBuilderWrapper builder, boolean root) {
    PsiBuilder.Marker marker = builder.mark();
    Pair<PsiBuilder.Marker, ModifierSet> modifierListPair = parseWithSoftElements(new NotNullFunction<CSharpBuilderWrapper, Pair<PsiBuilder.Marker, ModifierSet>>() {
        public Pair<PsiBuilder.Marker, ModifierSet> fun(CSharpBuilderWrapper builderWrapper) {
            return parseModifierListWithAttributes(builderWrapper, STUB_SUPPORT);
        }
    }, builder, PARTIAL_KEYWORD, ASYNC_KEYWORD);
    PsiBuilder.Marker modifierListMarker = modifierListPair.getFirst();
    ModifierSet modifierSet = modifierListPair.getSecond();
    IElementType tokenType = builder.getTokenType();
    if (tokenType == null) {
        if (modifierListPair.getSecond().isEmpty()) {
            marker.drop();
        } else {
            marker.error("String_Node_Str");
        }
        return;
    }
    if (tokenType == NAMESPACE_KEYWORD) {
        NamespaceDeclarationParsing.parse(builder, marker);
    } else if (CSharpTokenSets.TYPE_DECLARATION_START.contains(tokenType)) {
        TypeDeclarationParsing.parse(builder, marker);
    } else if (tokenType == EVENT_KEYWORD) {
        builder.advanceLexer();
        EventParsing.parse(builder, marker, modifierSet);
    } else if (tokenType == DELEGATE_KEYWORD) {
        builder.advanceLexer();
        MethodParsing.parseMethodStartAtType(builder, marker, modifierSet);
    } else if (tokenType == USING_KEYWORD) {
        UsingStatementParsing.parseUsingList(builder, marker);
    } else if (tokenType == CONST_KEYWORD) {
        builder.advanceLexer();
        FieldOrPropertyParsing.parseFieldOrLocalVariableAtTypeWithDone(builder, marker, FIELD_DECLARATION, STUB_SUPPORT, true, modifierSet);
    } else {
        if (tokenType == CSharpTokens.IDENTIFIER && builder.lookAhead(1) == LPAR) {
            MethodParsing.parseMethodStartAfterType(builder, marker, null, MethodParsing.Target.CONSTRUCTOR, modifierSet);
        } else if (tokenType == TILDE) {
            builder.advanceLexer();
            MethodParsing.parseMethodStartAfterType(builder, marker, null, MethodParsing.Target.DECONSTRUCTOR, modifierSet);
        } else {
            TypeInfo typeInfo = parseType(builder, STUB_SUPPORT);
            if (typeInfo == null) {
                if (!modifierSet.isEmpty()) {
                    if (root) {
                        marker.done(DUMMY_DECLARATION);
                        return;
                    }
                    builder.error("String_Node_Str");
                    marker.done(FIELD_DECLARATION);
                    return;
                } else {
                    modifierListMarker.drop();
                }
                marker.drop();
                advanceUnexpectedToken(builder);
            } else if (builder.getTokenType() == OPERATOR_KEYWORD) {
                MethodParsing.parseMethodStartAfterType(builder, marker, typeInfo, MethodParsing.Target.METHOD, modifierSet);
            } else {
                TypeInfo implementType = parseImplementType(builder);
                if (implementType == null) {
                    builder.error("String_Node_Str");
                    parseAfterName(builder, marker, builder.getTokenType() == LBRACKET ? THIS_KEYWORD : null, modifierSet);
                    return;
                }
                IElementType prevToken = null;
                if (builder.getTokenType() == DOT) {
                    builder.advanceLexer();
                    prevToken = builder.getTokenType();
                    doneThisOrIdentifier(builder);
                } else {
                    if (implementType.marker != null) {
                        implementType.marker.rollbackTo();
                    }
                    prevToken = builder.getTokenType();
                    doneThisOrIdentifier(builder);
                }
                parseAfterName(builder, marker, prevToken, modifierSet);
            }
        }
    }
}

Output:
         } else {
-            marker.error("String_Node_Str");
+            if (root) {
+                marker.done(DUMMY_DECLARATION);
+            } else {
+                marker.error("String_Node_Str");
+            }
         }


Input:
private static String translateFormat(String formatString, Map<String, String> mapping, String escapeStart, String escapeEnd, String targetEscapeStart, String targetEscapeEnd) {
    int beginIndex = 0;
    int i = 0;
    char lastChar = 0;
    char currentChar = 0;
    String resultString = "String_Node_Str";
    char esc1 = escapeStart.charAt(0);
    char esc2 = escapeEnd.charAt(0);
    for (; i < formatString.length(); i++) {
        currentChar = formatString.charAt(i);
        if (i > 0 && lastChar != currentChar) {
            resultString += mapSubformat(formatString, mapping, beginIndex, i, escapeStart, escapeEnd, targetEscapeStart, targetEscapeEnd);
            beginIndex = i;
        }
        lastChar = currentChar;
        if (currentChar == esc1) {
            i++;
            while (i < formatString.length() && formatString.charAt(i) != esc2) {
                i++;
            }
            resultString += targetEscapeStart;
            resultString += formatString.substring(beginIndex + 1, i);
            resultString += targetEscapeEnd;
            i++;
            if (i < formatString.length()) {
                lastChar = formatString.charAt(i);
            }
            beginIndex = i;
        }
    }
    return resultString + mapSubformat(formatString, mapping, beginIndex, i, escapeStart, escapeEnd, targetEscapeStart, targetEscapeEnd);
}

Output:
     }
-    return resultString + mapSubformat(formatString, mapping, beginIndex, i, escapeStart, escapeEnd, targetEscapeStart, targetEscapeEnd);
+    if (beginIndex < formatString.length() && i <= formatString.length()) {
+        return resultString + mapSubformat(formatString, mapping, beginIndex, i, escapeStart, escapeEnd, targetEscapeStart, targetEscapeEnd);
+    } else {
+        return resultString;
+    }
 }


Input:
public void onClick(View arg0) {
    PluginManager.getInstance().uninstallPlugin(mContext, info.applicationName);
    notifyDataSetChanged();
}

Output:
 public void onClick(View arg0) {
-    PluginManager.getInstance().uninstallPlugin(mContext, info.applicationName);
+    PluginManager.getInstance().uninstallPlugin(mContext, info.packageName);
     notifyDataSetChanged();


Input:
public void inject(final Object target, final String pagename) {
    if (target == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    final Field[] fields = findFieldsWithAnnotation(target, Mapping.class);
    if (fields.length > 0) {
        AssetIdWithSite id = mappingService.resolveMapped(pagename);
        final Map<String, MappingValue> map = mappingService.readMapping(id);
        for (final Field field : fields) {
            injectIntoField(target, map, field, id);
        }
    }
}

Output:
         AssetIdWithSite id = mappingService.resolveMapped(pagename);
-        final Map<String, MappingValue> map = mappingService.readMapping(id);
-        for (final Field field : fields) {
-            injectIntoField(target, map, field, id);
+        if (id != null) {
+            final Map<String, MappingValue> map = mappingService.readMapping(id);
+            for (final Field field : fields) {
+                injectIntoField(target, map, field, id);
+            }
+        } else {
+            LOG.error("String_Node_Str" + pagename + "String_Node_Str");
         }


Input:
private void createFieldOptions(TableMetadata typeMetadata, XContentBuilder xContentBuilder) throws IOException, UnsupportedException {
    xContentBuilder.startObject("String_Node_Str");
    Map<ColumnName, ColumnMetadata> columns = typeMetadata.getColumns();
    for (ColumnName column : columns.keySet()) {
        String columnType = convertType(columns.get(column).getColumnType());
        String name = column.getName();
        xContentBuilder = xContentBuilder.startObject(name).field("String_Node_Str", columnType).endObject();
    }
    xContentBuilder.endObject();
}

Output:
     Map<ColumnName, ColumnMetadata> columns = typeMetadata.getColumns();
-    for (ColumnName column : columns.keySet()) {
-        String columnType = convertType(columns.get(column).getColumnType());
-        String name = column.getName();
-        xContentBuilder = xContentBuilder.startObject(name).field("String_Node_Str", columnType).endObject();
+    if (!columns.isEmpty()) {
+        xContentBuilder.startObject("String_Node_Str");
+        for (ColumnName column : columns.keySet()) {
+            String columnType = convertType(columns.get(column).getColumnType());
+            String name = column.getName();
+            xContentBuilder = xContentBuilder.startObject(name).field("String_Node_Str", columnType).endObject();
+        }
+        xContentBuilder.endObject();
     }


Input:
public T get(ITestEnvironmentAccessor accessor) {
    accessor.getLogger().methodCalled(accessor, new MethodFormatter());
    T v = getValue();
    ReturnFormatter returnFormatter = new ReturnFormatter();
    returnFormatter.add(v);
    accessor.getLogger().methodEnded(accessor, returnFormatter);
    return v;
}

Output:
 public T get(ITestEnvironmentAccessor accessor) {
-    accessor.getLogger().methodCalled(accessor, new MethodFormatter());
+    if (accessor != null) {
+        accessor.getLogger().methodCalledOnObject(accessor, this.getFullName(), new MethodFormatter(), getMessage());
+    }
     T v = getValue();


Input:
protected Actor _getNextActorToFire() throws IllegalActionException {
    if (_eventQueue == null) {
        throw new IllegalActionException("String_Node_Str");
    }
    Actor actorToFire = null;
    DEEvent lastFoundEvent = null;
    DEEvent nextEvent = null;
    while (!_stopRequested) {
        if (_stopWhenQueueIsEmpty) {
            if (_eventQueue.isEmpty()) {
                break;
            }
        }
        if (isEmbedded()) {
            if (_eventQueue.isEmpty()) {
                break;
            }
            nextEvent = _eventQueue.get();
            if (nextEvent.timeStamp().compareTo(getModelTime()) < 0) {
                throw new IllegalActionException("String_Node_Str" + nextEvent.timeStamp() + "String_Node_Str" + nextEvent.microstep() + "String_Node_Str" + getModelTime() + "String_Node_Str" + _microstep + "String_Node_Str");
            }
            boolean microstepMatches = true;
            Nameable container = getContainer();
            if (container instanceof CompositeActor) {
                Director executiveDirector = ((CompositeActor) container).getExecutiveDirector();
                if (executiveDirector instanceof SuperdenseTimeDirector && !_isTopLevel()) {
                    microstepMatches = nextEvent.microstep() <= _microstep;
                }
            }
            int comparison = nextEvent.timeStamp().compareTo(getModelTime());
            if (comparison > 0 || comparison == 0 && !microstepMatches) {
                nextEvent = null;
                break;
            }
        } else {
            if (_eventQueue.isEmpty()) {
                if (actorToFire != null || getModelTime().equals(getModelStopTime())) {
                    break;
                }
            }
            synchronized (_eventQueue) {
                while (_eventQueue.isEmpty() && !_stopRequested && !_stopFireRequested) {
                    if (_debugging) {
                        _debug("String_Node_Str");
                    }
                    try {
                        workspace().wait(_eventQueue);
                    } catch (InterruptedException e) {
                        break;
                    }
                }
                if (_eventQueue.isEmpty()) {
                    return null;
                }
                nextEvent = _eventQueue.get();
            }
        }
        if (actorToFire == null) {
            Time currentTime;
            int depth = 0;
            try {
                synchronized (_eventQueue) {
                    lastFoundEvent = _eventQueue.get();
                    currentTime = _consultTimeRegulators(lastFoundEvent.timeStamp());
                    if (_synchronizeToRealTime) {
                        while (!_stopRequested && !_stopFireRequested) {
                            lastFoundEvent = _eventQueue.get();
                            currentTime = lastFoundEvent.timeStamp();
                            long elapsedTime = System.currentTimeMillis() - _realStartTime;
                            double elapsedTimeInSeconds = elapsedTime / 1000.0;
                            ptolemy.actor.util.Time elapsed = new ptolemy.actor.util.Time(this, elapsedTimeInSeconds);
                            if (currentTime.compareTo(elapsed) <= 0) {
                                break;
                            }
                            long timeToWait = (long) (currentTime.subtract(elapsed).getDoubleValue() * 1000.0);
                            if (timeToWait > 0) {
                                if (_debugging) {
                                    _debug("String_Node_Str" + timeToWait);
                                }
                                try {
                                    depth = _workspace.releaseReadPermission();
                                    _eventQueue.wait(timeToWait);
                                } catch (InterruptedException ex) {
                                    throw new IllegalActionException(this, ex, "String_Node_Str" + "String_Node_Str");
                                }
                            }
                        }
                        if (_stopRequested || _stopFireRequested) {
                            return null;
                        }
                    }
                }
            } finally {
                if (depth > 0) {
                    _workspace.reacquireReadPermission(depth);
                }
            }
            synchronized (_eventQueue) {
                lastFoundEvent = _eventQueue.take();
                currentTime = lastFoundEvent.timeStamp();
                actorToFire = lastFoundEvent.actor();
                if (_disabledActors != null && _disabledActors.contains(actorToFire)) {
                    if (_debugging) {
                        _debug("String_Node_Str", ((Nameable) actorToFire).getFullName());
                    }
                    actorToFire = null;
                    continue;
                }
                setModelTime(currentTime);
                _microstep = lastFoundEvent.microstep();
                if (_debugging) {
                    _debug("String_Node_Str" + currentTime + "String_Node_Str" + _microstep + "String_Node_Str");
                }
            }
            if (currentTime.compareTo(getModelStopTime()) > 0) {
                if (_debugging) {
                    _debug("String_Node_Str");
                }
                _exceedStopTime = true;
                return null;
            }
        } else {
            if (nextEvent.hasTheSameTagAs(lastFoundEvent) && nextEvent.actor() == actorToFire) {
                synchronized (_eventQueue) {
                    _eventQueue.take();
                }
            } else {
                break;
            }
        }
        if (actorToFire != null && _resourceScheduling) {
            if (_actorsFinished.contains(actorToFire)) {
                _actorsFinished.remove(actorToFire);
            } else if (!_schedule(actorToFire, getModelTime())) {
                Time nextScheduleTime = _nextScheduleTime.get(_schedulerForActor.get(actorToFire)).add(getModelTime());
                if (_actorsInExecution == null) {
                    _actorsInExecution = new HashMap();
                }
                _actorsInExecution.put(actorToFire, lastFoundEvent);
                actorToFire = null;
            }
        }
    }
    return actorToFire;
}

Output:
                 }
-                _actorsInExecution.put(actorToFire, lastFoundEvent);
+                List<DEEvent> events = _actorsInExecution.get(actorToFire);
+                if (events == null) {
+                    events = new ArrayList<DEEvent>();
+                }
+                events.add(lastFoundEvent);
+                _actorsInExecution.put(actorToFire, events);
                 actorToFire = null;


Input:
private void advanceTailIndex() {
    ++tailIndex;
    if (tailIndex > numElements) {
        tailIndex = 0;
    }
}

Output:
 private void advanceTailIndex() {
-    ++tailIndex;
-    if (tailIndex > numElements) {
-        tailIndex = 0;
-    }
+    tailIndex = tailIndex % capacity + 1;
 }


Input:
public void savePostContent(boolean isAutoSave) {
    Post post = mActivity.getPost();
    if (post == null || mContentEditText.getText() == null)
        return;
    String title = (mTitleEditText.getText() != null) ? mTitleEditText.getText().toString() : "String_Node_Str";
    String content;
    Editable postContentEditable;
    try {
        postContentEditable = new SpannableStringBuilder(mContentEditText.getText());
    } catch (IndexOutOfBoundsException e) {
        postContentEditable = mContentEditText.getText();
    }
    if (postContentEditable == null)
        return;
    if (post.isLocalDraft()) {
        if (android.os.Build.VERSION.SDK_INT >= 14) {
            CharacterStyle[] characterStyles = postContentEditable.getSpans(0, postContentEditable.length(), CharacterStyle.class);
            for (CharacterStyle characterStyle : characterStyles) {
                if (characterStyle.getClass().getName().equals("String_Node_Str"))
                    postContentEditable.removeSpan(characterStyle);
            }
        }
        content = WPHtml.toHtml(postContentEditable);
        content = content.replace("String_Node_Str", "String_Node_Str");
        content = content.replace("String_Node_Str", "String_Node_Str");
        content = content.replace("String_Node_Str", "String_Node_Str");
        content = content.replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str");
    } else {
        WPImageSpan[] imageSpans = postContentEditable.getSpans(0, postContentEditable.length(), WPImageSpan.class);
        if (imageSpans.length != 0) {
            for (WPImageSpan wpIS : imageSpans) {
                MediaFile mediaFile = wpIS.getMediaFile();
                if (mediaFile == null)
                    continue;
                if (mediaFile.getMediaId() != null) {
                    updateMediaFileOnServer(wpIS);
                } else {
                    mediaFile.setFileName(wpIS.getImageSource().toString());
                    mediaFile.setFilePath(wpIS.getImageSource().toString());
                    mediaFile.save();
                }
                int tagStart = postContentEditable.getSpanStart(wpIS);
                if (!isAutoSave) {
                    postContentEditable.removeSpan(wpIS);
                    if (mediaFile.getMediaId() != null && mediaFile.getMediaId().length() > 0) {
                        postContentEditable.insert(tagStart, WPHtml.getContent(wpIS));
                    } else {
                        postContentEditable.insert(tagStart, "String_Node_Str" + wpIS.getImageSource().toString() + "String_Node_Str");
                    }
                }
            }
        }
        content = postContentEditable.toString();
    }
    if (!isAutoSave) {
        MediaGalleryImageSpan[] gallerySpans = postContentEditable.getSpans(0, postContentEditable.length(), MediaGalleryImageSpan.class);
        for (MediaGalleryImageSpan gallerySpan : gallerySpans) {
            int start = postContentEditable.getSpanStart(gallerySpan);
            postContentEditable.removeSpan(gallerySpan);
            postContentEditable.insert(start, WPHtml.getGalleryShortcode(gallerySpan));
        }
    }
    String moreTag = "String_Node_Str";
    post.setTitle(title);
    if (post.isLocalDraft() && content.contains(moreTag)) {
        post.setDescription(content.substring(0, content.indexOf(moreTag)));
        post.setMt_text_more(content.substring(content.indexOf(moreTag) + moreTag.length(), content.length()));
    } else {
        post.setDescription(content);
        post.setMt_text_more("String_Node_Str");
    }
    if (!post.isLocalDraft())
        post.setLocalChange(true);
    post.update();
}

Output:
         post.setDescription(content.substring(0, content.indexOf(moreTag)));
-        post.setMt_text_more(content.substring(content.indexOf(moreTag) + moreTag.length(), content.length()));
+        post.setMoreText(content.substring(content.indexOf(moreTag) + moreTag.length(), content.length()));
     } else {


Input:
private static void initLiquidItems(Configuration cfg) {
    Map<String, Fluid> fluidMap = FluidRegistry.getRegisteredFluids();
    for (Map.Entry<String, Fluid> me : fluidMap.entrySet()) {
        if (me.getValue().canBePlacedInWorld()) {
            int id = registerDimlet(cfg, new DimletKey(DimletType.DIMLET_LIQUID, me.getKey()));
            String displayName = new FluidStack(me.getValue(), 1).getLocalizedName();
            idToDisplayName.put(id, DimletType.DIMLET_LIQUID.getName() + "String_Node_Str" + displayName + "String_Node_Str");
        }
    }
}

Output:
         if (me.getValue().canBePlacedInWorld()) {
-            int id = registerDimlet(cfg, new DimletKey(DimletType.DIMLET_LIQUID, me.getKey()));
+            int id = registerDimlet(cfg, idsInConfig, new DimletKey(DimletType.DIMLET_LIQUID, me.getKey()));
             String displayName = new FluidStack(me.getValue(), 1).getLocalizedName();


Input:
private TreeSet<ObjectProperty> getFirstObjectProperties(NodeSet<OWLObjectPropertyExpression> nodeSet) {
    TreeSet<ObjectProperty> roles = new TreeSet<ObjectProperty>(roleComparator);
    for (Node<OWLObjectPropertyExpression> node : nodeSet) {
        if (node.isBottomNode() || node.isTopNode()) {
            continue;
        }
        OWLObjectPropertyExpression property = node.getRepresentativeElement();
        roles.add(new ObjectProperty(property.asOWLObjectProperty().toStringID()));
    }
    roles.remove(new ObjectProperty(factory.getOWLTopObjectProperty().toStringID()));
    roles.remove(new ObjectProperty(factory.getOWLBottomObjectProperty().toStringID()));
    return roles;
}

Output:
         OWLObjectPropertyExpression property = node.getRepresentativeElement();
-        roles.add(new ObjectProperty(property.asOWLObjectProperty().toStringID()));
+        if (!property.isAnonymous()) {
+            roles.add(new ObjectProperty(property.asOWLObjectProperty().toStringID()));
+        }
     }


Input:
public Connection fillUIConnParams(IMetadataConnection metadataBean, Connection connection) {
    Connection newConnection = null;
    if (connection == null) {
        newConnection = ConnectionFactory.eINSTANCE.createDatabaseConnection();
    }
    if (super.fillUIConnParams(metadataBean, newConnection == null ? connection : newConnection) == null) {
        return null;
    }
    DatabaseConnection dbconn = null;
    if (newConnection != null) {
        dbconn = (DatabaseConnection) newConnection;
    } else {
        dbconn = (DatabaseConnection) connection;
    }
    if (newConnection != null) {
        dbconn.setDriverJarPath(metadataBean.getDriverJarPath());
        dbconn.setProductId(metadataBean.getProduct());
        dbconn.setDbmsId(metadataBean.getMapping());
        dbconn.setAdditionalParams(metadataBean.getAdditionalParams());
        dbconn.setDriverClass(metadataBean.getDriverClass());
        dbconn.setDatabaseType(metadataBean.getDbType());
        dbconn.setName(metadataBean.getLabel());
        dbconn.setLabel(metadataBean.getLabel());
        dbconn.setVersion(metadataBean.getVersion());
        dbconn.setUiSchema(metadataBean.getUiSchema());
        dbconn.setSQLMode(metadataBean.isSqlMode());
        dbconn.setSID(metadataBean.getDatabase());
        String distro = (String) metadataBean.getParameter(ConnParameterKeys.CONN_PARA_KEY_HIVE_DISTRIBUTION);
        String distroVersion = (String) metadataBean.getParameter(ConnParameterKeys.CONN_PARA_KEY_HIVE_VERSION);
        String hiveModel = (String) metadataBean.getParameter(ConnParameterKeys.CONN_PARA_KEY_HIVE_MODE);
        dbconn.getParameters().put(ConnParameterKeys.CONN_PARA_KEY_HIVE_DISTRIBUTION, distro);
        dbconn.getParameters().put(ConnParameterKeys.CONN_PARA_KEY_HIVE_VERSION, distroVersion);
        dbconn.getParameters().put(ConnParameterKeys.CONN_PARA_KEY_HIVE_MODE, hiveModel);
    }
    try {
        if (sqlConnection == null || sqlConnection.isClosed()) {
            this.checkConnection(metadataBean);
        }
        if (newConnection != null) {
            fillMetadataParams(metadataBean, newConnection);
        }
        DatabaseMetaData dbMetadata = null;
        if (EDatabaseTypeName.HIVE.getXmlName().equalsIgnoreCase(metadataBean.getDbType())) {
            dbMetadata = HiveConnectionManager.getInstance().extractDatabaseMetaData(metadataBean);
        } else {
            dbMetadata = ExtractMetaDataUtils.getInstance().getDatabaseMetaData(sqlConnection, dbconn, false);
        }
        String productName = dbMetadata.getDatabaseProductName() == null ? PluginConstant.EMPTY_STRING : dbMetadata.getDatabaseProductName();
        String productVersion = dbMetadata.getDatabaseProductVersion() == null ? PluginConstant.EMPTY_STRING : dbMetadata.getDatabaseProductVersion();
        TaggedValueHelper.setTaggedValue(dbconn, TaggedValueHelper.DB_PRODUCT_NAME, productName);
        TaggedValueHelper.setTaggedValue(dbconn, TaggedValueHelper.DB_PRODUCT_VERSION, productVersion);
        boolean isHive = dbconn.getDatabaseType().equals(EDatabaseTypeName.HIVE.getDisplayName());
        boolean isHiveJdbc = dbconn.getDatabaseType().equals(EDatabaseTypeName.GENERAL_JDBC.getDisplayName()) && dbconn.getDriverClass() != null && dbconn.getDriverClass().equals(EDatabase4DriverClassName.HIVE.getDriverClass());
        if (!isHive && !isHiveJdbc) {
            String identifierQuote = dbMetadata.getIdentifierQuoteString();
            ConnectionHelper.setIdentifierQuoteString(identifierQuote == null ? "String_Node_Str" : identifierQuote, dbconn);
        }
    } catch (SQLException e) {
        log.error(e, e);
    } catch (ClassNotFoundException e) {
        CommonExceptionHandler.process(e);
    } catch (InstantiationException e) {
        CommonExceptionHandler.process(e);
    } catch (IllegalAccessException e) {
        CommonExceptionHandler.process(e);
    } finally {
        ConnectionUtils.closeConnection(sqlConnection);
        if (driver != null && MetadataConnectionUtils.isDerbyRelatedDb(metadataBean.getDriverClass(), metadataBean.getDbType())) {
            try {
                driver.connect("String_Node_Str", null);
            } catch (SQLException e) {
            }
        }
    }
    if (newConnection != null) {
        return newConnection;
    } else {
        return connection;
    }
}

Output:
     } finally {
-        ConnectionUtils.closeConnection(sqlConnection);
+        if (sqlConnection != null) {
+            ConnectionUtils.closeConnection(sqlConnection);
+        }
         if (driver != null && MetadataConnectionUtils.isDerbyRelatedDb(metadataBean.getDriverClass(), metadataBean.getDbType())) {


Input:
private void setParallelization(INode node) {
    if (node.isActivate()) {
        if (node.getOutgoingConnections().size() > 0) {
            for (IConnection con : node.getOutgoingConnections()) {
                EConnectionType lineStyle = con.getLineStyle();
                if (lineStyle.hasConnectionCategory(IConnectionCategory.DATA)) {
                    boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
                    boolean isStartRow = node.isStart();
                    if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
                        ParallelExecutionUtils.reSetParKeyValuesForCon(con);
                    }
                    if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
                        if (isExistParallel && !isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
                            con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
                            con.setPropertyValue(EParameterName.REPARTITIONER.getName(), Boolean.TRUE);
                            ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) con.getTarget());
                            setParallelization(con.getTarget());
                        } else {
                            if (isExistParallel && (ParallelExecutionUtils.existPreviousPar((Node) con.getSource()) || ParallelExecutionUtils.existPreviousNone((Node) con.getSource()) || ParallelExecutionUtils.existPreviousRepar((Node) con.getSource()))) {
                                con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
                                con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
                                con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
                                con.setPropertyValue(EParameterName.NONE.getName(), Boolean.TRUE);
                                setParallelization(con.getTarget());
                            } else {
                                isExistParallel = true;
                                INode nextPartionerNode = null;
                                IElementParameter deparElem = con.getElementParameter(EParameterName.DEPARTITIONER.getName());
                                deparElem.setValue(Boolean.FALSE);
                                con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
                                con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
                                con.setPropertyValue(EParameterName.PARTITIONER.getName(), Boolean.TRUE);
                                if (isStartRow && lineStyle.equals(EConnectionType.FLOW_MERGE)) {
                                    con.setPropertyValue(EParameterName.PARTITIONER.getName(), Boolean.FALSE);
                                    con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.TRUE);
                                    isExistParallel = false;
                                } else {
                                    nextPartionerNode = ParallelExecutionUtils.getNextPartionerTargetNode(con);
                                    if (nextPartionerNode != null) {
                                        if (ParallelExecutionUtils.isConClumnsContainsPartionKey(con, (Node) nextPartionerNode)) {
                                            if (ParallelExecutionUtils.getColumnListFromTargetNode((Node) nextPartionerNode).size() > 0) {
                                                ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) nextPartionerNode);
                                            } else {
                                                ParallelExecutionUtils.setHashKeysForCon(con);
                                            }
                                        } else {
                                            if (isStartRow) {
                                                con.setPropertyValue(EParameterName.PARTITIONER.getName(), Boolean.FALSE);
                                                isExistParallel = false;
                                            }
                                        }
                                    } else {
                                        ParallelExecutionUtils.setHashKeysForCon(con);
                                    }
                                }
                                if (con.getTarget() != null) {
                                    setParallelization(con.getTarget());
                                }
                            }
                        }
                    } else {
                        if (!con.getSource().isStart()) {
                            if (isExistParallel && !ParallelExecutionUtils.existPreviousDepar((Node) con.getSource())) {
                                setDeparallelization(con.getTarget());
                            }
                        }
                    }
                } else {
                    node = con.getTarget();
                    setParallelization(node);
                }
            }
        } else {
            if (!node.isStart()) {
                setDeparallelization(node);
            }
        }
    }
}

Output:
                 if (lineStyle.hasConnectionCategory(IConnectionCategory.DATA)) {
-                    boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
-                    boolean isStartRow = node.isStart();
-                    if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
-                        ParallelExecutionUtils.reSetParKeyValuesForCon(con);
-                    }
-                    if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
-                        if (isExistParallel && !isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
-                            con.getElementParameter(EParameterName.NONE.getName()).setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
-                            con.setPropertyValue(EParameterName.REPARTITIONER.getName(), Boolean.TRUE);
-                            ParallelExecutionUtils.setHashKeysFromTarget(con, (Node) con.getTarget());
-                            setParallelization(con.getTarget());
-                        } else {
-                            if (isExistParallel && (ParallelExecutionUtils.existPreviousPar((Node) con.getSource()) || ParallelExecutionUtils.existPreviousNone((Node) con.getSource()) || ParallelExecutionUtils.existPreviousRepar((Node) con.getSource()))) {
-                                con.getElementParameter(EParameterName.REPARTITIONER.getName()).setValue(Boolean.FALSE);
-                                con.getElementParameter(EParameterName.PARTITIONER.getName()).setValue(Boolean.FALSE);
-                                con.getElementParameter(EParameterName.DEPARTITIONER.getName()).setValue(Boolean.FALSE);
-                                con.setPropertyValue(EParameterName.NONE.getName(), Boolean.TRUE);
-                                setParallelization(con.getTarget());
+                    if (!lineStyle.equals(EConnectionType.FLOW_MERGE)) {
+                        boolean isEndRow = con.getTarget().getOutgoingConnections().size() == 0;
+                        boolean isStartRow = node.isStart();
+                        if (ParallelExecutionUtils.isPartitionKeysExist(con)) {
+                            ParallelExecutionUtils.reSetParKeyValuesForCon(con);
+                        }
+                        if (!isEndRow && isComponentCanParlization(con, (Node) con.getTarget())) {
+                            if (isExistParalInSubjob(existParallelMap, node) && !isStartRow && isComponentNeedRepartion(con, (Node) con.getTarget())) {
+                                setRepartioner(con);
                             } else {


Input:
public ExecutionResult execute(Item item) {
    if (item instanceof ConnectionItem) {
        try {
            URI itemURI = getItemURI(item);
            if (itemURI != null) {
                URI itemResourceURI = getItemResourceURI(itemURI);
                if (metadata400to410 == null) {
                    metadata400to410 = new TosMetadataMigrationFrom400to410();
                }
                Resource migratedResource = metadata400to410.migrate(itemResourceURI.toString(), new NullProgressMonitor());
                HashMap<String, Object> xmlSaveOtions = XML_SAVE_OTIONS_1_0;
                if (migratedResource != null) {
                    EObject content = migratedResource.getContents().get(0);
                    if (content != null && "String_Node_Str".equals(content.eClass().getName())) {
                        ByteArrayOutputStream tempStream = new ByteArrayOutputStream();
                        try {
                            try {
                                migratedResource.save(tempStream, XML_SAVE_OTIONS_1_0);
                            } catch (Exception e) {
                                tempStream = new ByteArrayOutputStream();
                                xmlSaveOtions = XML_SAVE_OTIONS_1_1;
                                migratedResource.save(tempStream, xmlSaveOtions);
                            } finally {
                                tempStream.close();
                            }
                            migratedResource = resourceSet.createResource(URI.createURI("String_Node_Str"));
                            migratedResource.load(new ByteArrayInputStream(tempStream.toByteArray()), xmlSaveOtions);
                            DatabaseConnection databaseConnection = SwitchHelpers.DATABASECONNECTION_SWITCH.doSwitch(migratedResource.getContents().get(0));
                            String databaseType = databaseConnection.getDatabaseType();
                            databaseConnection.setDriverClass(ExtractMetaDataUtils.getDriverClassByDbType(databaseType));
                            EDatabaseTypeName currentType = EDatabaseTypeName.getTypeFromDbType(databaseType);
                            EDatabaseSchemaOrCatalogMapping curCatalog = currentType.getCatalogMappingField();
                            EDatabaseSchemaOrCatalogMapping curSchema = currentType.getSchemaMappingField();
                            if (!curCatalog.equals(EDatabaseSchemaOrCatalogMapping.None)) {
                                List<Schema> schemas = ConnectionHelper.getSchema(databaseConnection);
                                if (!curSchema.equals(EDatabaseSchemaOrCatalogMapping.None)) {
                                    ConnectionHelper.removeSchemas(schemas, databaseConnection);
                                    for (Schema schema : schemas) {
                                        String schemaName = computeSchemaName(schema, databaseConnection, curSchema);
                                        String catalogName = computeCatalogName(databaseConnection, curCatalog);
                                        schema.setName(schemaName);
                                        Catalog catalog = RelationalFactory.eINSTANCE.createCatalog();
                                        migratedResource.getContents().add(catalog);
                                        catalog.setName(catalogName);
                                        CatalogHelper.addSchemas(Collections.singleton(schema), catalog);
                                        ConnectionHelper.addCatalog(catalog, databaseConnection);
                                    }
                                } else {
                                    for (Schema schema : schemas) {
                                        String catalogName = computeCatalogName(databaseConnection, curCatalog);
                                        Catalog catalog = RelationalFactory.eINSTANCE.createCatalog();
                                        migratedResource.getContents().add(catalog);
                                        catalog.setName(catalogName);
                                        catalog.getOwnedElement().addAll(schema.getOwnedElement());
                                        ConnectionHelper.addCatalog(catalog, databaseConnection);
                                        ConnectionHelper.removeSchemas(Collections.singleton(schema), databaseConnection);
                                    }
                                }
                            } else if (!curSchema.equals(EDatabaseSchemaOrCatalogMapping.None)) {
                                List<Schema> schemas = ConnectionHelper.getSchema(databaseConnection);
                                for (Schema schema : schemas) {
                                    String schemaName = computeSchemaName(schema, databaseConnection, curSchema);
                                    schema.setName(schemaName);
                                }
                            }
                        } catch (Exception e) {
                            log.error("String_Node_Str" + itemResourceURI.toString(), e);
                            ExceptionHandler.process(e);
                        } finally {
                            tempStream.close();
                        }
                    }
                    OutputStream outputStream = item.eResource().getResourceSet().getURIConverter().createOutputStream(itemResourceURI, null);
                    try {
                        migratedResource.save(outputStream, xmlSaveOtions);
                    } finally {
                        outputStream.close();
                    }
                }
                return ExecutionResult.SUCCESS_WITH_ALERT;
            }
        } catch (ATLCoreException e) {
            log.error(e);
            ExceptionHandler.process(e);
            return ExecutionResult.SUCCESS_NO_ALERT;
        } catch (IOException e) {
            log.error(e);
            ExceptionHandler.process(e);
            return ExecutionResult.SUCCESS_NO_ALERT;
        } finally {
            resourceSet.getResources().clear();
        }
    }
    return ExecutionResult.NOTHING_TO_DO;
}

Output:
                             String databaseType = databaseConnection.getDatabaseType();
-                            databaseConnection.setDriverClass(ExtractMetaDataUtils.getDriverClassByDbType(databaseType));
+                            databaseConnection.setDriverClass(ExtractMetaDataUtils.getInstance().getDriverClassByDbType(databaseType));
                             EDatabaseTypeName currentType = EDatabaseTypeName.getTypeFromDbType(databaseType);


Input:
public void initialize() throws BirtException {
    createRoot();
    Color backgroundColor = PropertyUtil.getColor(pageContent.getComputedStyle().getProperty(StyleConstants.STYLE_BACKGROUND_COLOR));
    ReportDesignHandle designHandle = pageContent.getReportContent().getDesign().getReportDesign();
    IStyle style = pageContent.getStyle();
    String imageUrl = EmitterUtil.getBackgroundImageUrl(style, designHandle, pageContent.getReportContent().getReportContext() == null ? null : pageContent.getReportContent().getReportContext().getAppContext());
    if (backgroundColor != null || imageUrl != null) {
        boxStyle = new BoxStyle();
        boxStyle.setBackgroundColor(backgroundColor);
        if (imageUrl != null) {
            boxStyle.setBackgroundImage(createBackgroundImage(imageUrl));
        }
    }
    context.setMaxHeight(root.getHeight());
    context.setMaxWidth(root.getWidth());
    context.setMaxBP(root.getHeight());
    layoutHeader();
    layoutFooter();
    updateBodySize();
    context.setMaxHeight(body.getHeight());
    context.setMaxWidth(body.getWidth());
    context.setMaxBP(body.getHeight());
    maxAvaWidth = context.getMaxWidth();
    context.resetUnresolvedRowHints();
}

Output:
     context.setMaxWidth(body.getWidth());
-    context.setMaxBP(body.getHeight());
+    int overFlowType = context.getPageOverflow();
+    if (overFlowType == IPDFRenderOption.FIT_TO_PAGE_SIZE || overFlowType == IPDFRenderOption.ENLARGE_PAGE_SIZE) {
+        context.setMaxBP(Integer.MAX_VALUE);
+    } else {
+        context.setMaxBP(body.getHeight());
+    }
     maxAvaWidth = context.getMaxWidth();


Input:
public void fillDomainGridBand(Graphics2D g2, XYPlot plot, ValueAxis axis, Rectangle2D dataArea, double start, double end) {
    double x1 = axis.valueToJava2D(start, dataArea, plot.getDomainAxisEdge());
    double x2 = axis.valueToJava2D(end, dataArea, plot.getDomainAxisEdge());
    Rectangle2D band;
    if (plot.getOrientation() == PlotOrientation.VERTICAL) {
        band = new Rectangle2D.Double(Math.min(x1, x2), dataArea.getMinY(), Math.abs(x2 - x1), dataArea.getWidth());
    } else {
        band = new Rectangle2D.Double(dataArea.getMinX(), Math.min(x1, x2), dataArea.getWidth(), Math.abs(x2 - x1));
    }
    Paint paint = plot.getDomainTickBandPaint();
    if (paint != null) {
        g2.setPaint(paint);
        g2.fill(band);
    }
}

Output:
     if (plot.getOrientation() == PlotOrientation.VERTICAL) {
-        band = new Rectangle2D.Double(Math.min(x1, x2), dataArea.getMinY(), Math.abs(x2 - x1), dataArea.getWidth());
+        band = new Rectangle2D.Double(Math.min(x1, x2), dataArea.getMinY(), Math.abs(x2 - x1), dataArea.getHeight());
     } else {


Input:
public void testClassPathEntries_notURLClassLoader_noParent() {
    assertThat(ClassPath.Scanner.getClassPathEntries(new ClassLoader(null) {
    }).keySet()).isEmpty();
}

Output:
     assertThat(ClassPath.Scanner.getClassPathEntries(new ClassLoader(null) {
-    }).keySet()).isEmpty();
+    })).isEmpty();
 }


Input:
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
    try {
        switch(token) {
            case TOKEN_CONTACT_INFO:
                {
                    bindContactInfo(cursor);
                    invalidate();
                    break;
                }
            case TOKEN_SOCIAL:
                {
                    bindSocial(cursor);
                    invalidate();
                    break;
                }
            case TOKEN_PHONE_LOOKUP:
                {
                    if (cursor != null && cursor.moveToFirst()) {
                        long contactId = cursor.getLong(PHONE_LOOKUP_CONTACT_ID_COLUMN_INDEX);
                        String lookupKey = cursor.getString(PHONE_LOOKUP_CONTACT_LOOKUP_KEY_COLUMN_INDEX);
                        bindFromContactUri(Contacts.getLookupUri(contactId, lookupKey));
                    } else {
                        setDisplayName((String) cookie, null);
                    }
                    break;
                }
            case TOKEN_EMAIL_LOOKUP:
                {
                    if (cursor != null && cursor.moveToFirst()) {
                        long contactId = cursor.getLong(EMAIL_LOOKUP_CONTACT_ID_COLUMN_INDEX);
                        String lookupKey = cursor.getString(EMAIL_LOOKUP_CONTACT_LOOKUP_KEY_COLUMN_INDEX);
                        bindFromContactUri(Contacts.getLookupUri(contactId, lookupKey));
                    } else {
                        setDisplayName((String) cookie, null);
                    }
                    break;
                }
            case TOKEN_LOOKUP_CONTACT_FOR_SOCIAL_QUERY:
                {
                    if (cursor != null && cursor.moveToFirst()) {
                        long contactId = cursor.getLong(CONTACT_LOOKUP_ID_COLUMN_INDEX);
                        startSocialQuery(ContentUris.withAppendedId(Activities.CONTENT_CONTACT_STATUS_URI, contactId));
                    }
                }
        }
    } finally {
        if (cursor != null) {
            cursor.close();
        }
    }
}

Output:
                     } else {
-                        setDisplayName((String) cookie, null);
+                        String phoneNumber = (String) cookie;
+                        setDisplayName(phoneNumber, null);
+                        mPhotoView.assignContactFromPhone(phoneNumber, true);
                     }


Input:
public static String getGenericTypeName(Type type) {
    if (type instanceof Class) {
        String name = ((Class) type).getName();
        if (name.charAt(0) == '[') {
            String suffix = "String_Node_Str";
            while (name.charAt(0) == '[') {
                name = name.substring(1);
                suffix = suffix + "String_Node_Str";
            }
            if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.equals("String_Node_Str"))
                return "String_Node_Str" + suffix;
            else if (name.charAt(0) == 'L')
                return name.substring(1, name.length() - 1).replace('$', '.') + suffix;
            else {
                System.err.println("String_Node_Str" + name + "String_Node_Str");
                return "String_Node_Str";
            }
        }
        return name.replace('$', '.');
    } else if (type instanceof ParameterizedType) {
        ParameterizedType ptype = (ParameterizedType) type;
        StringBuilder sb = new StringBuilder();
        sb.append(getGenericTypeName(ptype.getRawType()));
        boolean occured = false;
        for (Type ta : getActualTypeArguments(ptype)) {
            if (occured)
                sb.append("String_Node_Str");
            else {
                sb.append('<');
                occured = true;
            }
            sb.append(getGenericTypeName(ta));
        }
        if (occured)
            sb.append('>');
        return sb.toString();
    } else {
        try {
            return type.toString().replace('$', '.');
        } catch (Error e) {
            System.err.println(e);
            System.err.println("String_Node_Str");
            return "String_Node_Str";
        }
    }
}

Output:
             return type.toString().replace('$', '.');
-        } catch (Error e) {
+        } catch (Throwable e) {
             System.err.println(e);


Input:
public final NBTTagCompound getMaterialTag() {
    NBTTagCompound tag = new NBTTagCompound();
    tag.setString(AgriCraftNBT.MATERIAL, this.material.getRegistryName());
    tag.setInteger(AgriCraftNBT.MATERIAL_META, this.materialMeta);
    return tag;
}

Output:
     NBTTagCompound tag = new NBTTagCompound();
-    tag.setString(AgriCraftNBT.MATERIAL, this.material.getRegistryName());
+    tag.setString(AgriCraftNBT.MATERIAL, this.material.getRegistryName().toString());
     tag.setInteger(AgriCraftNBT.MATERIAL_META, this.materialMeta);


Input:
public void orbitInterpolation(List<S1Metadata.OrbitStatePosVelox> vpList, double zeroDopplerTimeFirstLineSeconds, double zeroDopplerTimeLastLineSeconds, double samplingf, double iSafetyBufferAz) throws MathException {
    this.iSafetyBufferAz = iSafetyBufferAz;
    double deltaT = 1 / samplingf;
    double deltaTinv = 1 / deltaT;
    int nPoints = vpList.size();
    double reftime = 0;
    double firstTime = vpList.get(0).time;
    double lastTime = vpList.get(vpList.size() - 1).time;
    if (firstTime < (lastTime)) {
        reftime = firstTime;
    } else {
        reftime = lastTime;
    }
    int idx = 0;
    secondsDiffFromRefTime = new double[vpList.size()];
    for (S1Metadata.OrbitStatePosVelox vp : vpList) {
        secondsDiffFromRefTime[idx] = (vp.time - reftime);
        idx++;
    }
    zeroDopplerTimeFirstRef = (zeroDopplerTimeFirstLineSeconds - reftime);
    zeroDopplerTimeLastRef = (zeroDopplerTimeLastLineSeconds - reftime);
    double minT = 0;
    double maxT = 0;
    double zeroDopplerTimeFirstLineWSafetyBufSecondsRef = 0;
    double zeroDopplerTimeLastLineWSafetyBufSecondsRef = 0;
    if (zeroDopplerTimeFirstRef < zeroDopplerTimeLastRef) {
        zeroDopplerTimeFirstLineWSafetyBufSecondsRef = zeroDopplerTimeFirstRef - iSafetyBufferAz * deltaT;
        zeroDopplerTimeLastLineWSafetyBufSecondsRef = zeroDopplerTimeLastRef + iSafetyBufferAz * deltaT;
        minT = FastMath.min(0, zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
        maxT = FastMath.max(secondsDiffFromRefTime[secondsDiffFromRefTime.length - 1], zeroDopplerTimeLastLineWSafetyBufSecondsRef);
    } else {
        zeroDopplerTimeFirstLineWSafetyBufSecondsRef = zeroDopplerTimeFirstRef + iSafetyBufferAz * deltaT;
        zeroDopplerTimeLastLineWSafetyBufSecondsRef = zeroDopplerTimeLastRef - iSafetyBufferAz * deltaT;
        if (firstTime < (lastTime)) {
            minT = FastMath.min(secondsDiffFromRefTime[0], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
            maxT = FastMath.max(secondsDiffFromRefTime[secondsDiffFromRefTime.length - 1], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
        } else {
            minT = FastMath.min(secondsDiffFromRefTime[secondsDiffFromRefTime.length - 1], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
            maxT = FastMath.max(secondsDiffFromRefTime[0], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
        }
    }
    int limit = ((Double) ((maxT - minT) / deltaT)).intValue();
    Double[] timeStampInterpSecondsRef = new Double[limit + 1];
    double nextVal = 0;
    for (int j = 0; j <= limit; j++) {
        timeStampInterpSecondsRef[j] = nextVal;
        nextVal = deltaT + nextVal;
    }
    double zeroDopplerTimeInitRef = zeroDopplerTimeFirstRef;
    double zeroDopplerTimeEndRef = zeroDopplerTimeLastRef;
    if (zeroDopplerTimeFirstRef > zeroDopplerTimeLastRef) {
        zeroDopplerTimeInitRef = zeroDopplerTimeLastRef;
        zeroDopplerTimeEndRef = zeroDopplerTimeFirstRef;
    }
    if (zeroDopplerTimeInitRef < timeStampInterpSecondsRef[1]) {
        int size = Math.min(nPoints, N_ORB_POINT_INTERP);
        double[] subTimesDiffRef = Arrays.copyOfRange(secondsDiffFromRefTime, 0, nPoints);
        List<Double> timeStampInitSecondsRefPointsInterp = new ArrayList<Double>();
        for (int i = 0; i < size; i++) {
            double valMax = timeStampInterpSecondsRef[size - 1];
            if (timeStampInterpSecondsRef[i] < valMax) {
                timeStampInitSecondsRefPointsInterp.add(timeStampInterpSecondsRef[i]);
            }
        }
        List<IMetadata.OrbitStatePosVelox> subList = vpList.subList(0, size);
        double initTime = zeroDopplerTimeInitRef;
        int idxInitTime = -1;
        boolean finded = false;
        double endTime = secondsDiffFromRefTime[0];
        int idxEndTime = -1;
        for (int i = 0; i < timeStampInterpSecondsRef.length; i++) {
            if (timeStampInterpSecondsRef[i] >= initTime && !finded) {
                idxInitTime = i;
                finded = true;
            }
            if (timeStampInterpSecondsRef[i] < endTime) {
                idxEndTime = i;
            }
        }
        logger.debug("String_Node_Str" + idxInitTime + "String_Node_Str" + idxEndTime);
        Double[] t0 = (Double[]) timeStampInitSecondsRefPointsInterp.toArray(new Double[0]);
        if (idxInitTime != -1 && idxEndTime != -1 && initTime < endTime) {
            List<double[]> vPoints = new ArrayList<double[]>();
            List<double[]> pPoints = new ArrayList<double[]>();
            List<Double> timeStampOutput = new ArrayList<Double>();
            HermiteInterpolation.interpolation(subTimesDiffRef, subList, t0, idxInitTime, idxEndTime, deltaTinv, vPoints, pPoints, timeStampOutput);
            addPointsToResult(vPoints, pPoints);
            if (timeStampInterp == null)
                timeStampInterp = new ArrayList<>(timeStampOutput);
            else
                timeStampInterp.addAll(timeStampOutput);
        }
    }
    for (int orbPoint = 1; orbPoint < nPoints; orbPoint++) {
        if (secondsDiffFromRefTime[orbPoint - 1] < zeroDopplerTimeEndRef || secondsDiffFromRefTime[orbPoint] > zeroDopplerTimeEndRef) {
            int idxStart = 0;
            int idxEnd = 0;
            if (N_ORB_POINT_INTERP > nPoints) {
                idxEnd = nPoints;
            } else {
                idxStart = orbPoint - new Double(Math.floor(N_ORB_POINT_INTERP / 2)).intValue();
                idxEnd = idxStart + N_ORB_POINT_INTERP - 1;
                if (idxStart < 1) {
                    idxStart = 0;
                    idxEnd = N_ORB_POINT_INTERP - 1;
                }
                if (idxEnd >= nPoints) {
                    idxStart = nPoints - N_ORB_POINT_INTERP;
                    idxEnd = nPoints - 1;
                }
            }
            double[] timeStampInitSecondsRefPoints = Arrays.copyOfRange(secondsDiffFromRefTime, idxStart, idxEnd + 1);
            List<Double> timeStampInitSecondsRefPointsInterp = new ArrayList<Double>();
            for (int i = 0; i < timeStampInterpSecondsRef.length; i++) {
                if (timeStampInterpSecondsRef[i] >= secondsDiffFromRefTime[idxStart] && timeStampInterpSecondsRef[i] < secondsDiffFromRefTime[idxEnd]) {
                    timeStampInitSecondsRefPointsInterp.add(timeStampInterpSecondsRef[i]);
                }
            }
            List<S1Metadata.OrbitStatePosVelox> stateVecPoints = vpList.subList(idxStart, idxEnd + 1);
            double initTime = Math.max(secondsDiffFromRefTime[orbPoint - 1], zeroDopplerTimeInitRef);
            int idxInitTime = 0;
            boolean findIdxInitTime = false;
            for (int i = 0; i < timeStampInitSecondsRefPointsInterp.size() && !findIdxInitTime; i++) {
                if (timeStampInitSecondsRefPointsInterp.get(i) >= initTime) {
                    idxInitTime = i;
                    findIdxInitTime = true;
                }
            }
            double endTime = Math.min(secondsDiffFromRefTime[orbPoint], zeroDopplerTimeEndRef);
            int idxEndTime = 0;
            boolean findIdxEndTime = false;
            for (int i = timeStampInitSecondsRefPointsInterp.size() - 1; i >= 0 && !findIdxEndTime; i--) {
                if (timeStampInitSecondsRefPointsInterp.get(i) < endTime) {
                    idxEndTime = i;
                    findIdxEndTime = true;
                }
            }
            double timeRef = timeStampInitSecondsRefPointsInterp.get(0);
            Double[] timeStampInitSecondsRefPointsInterp0 = new Double[timeStampInitSecondsRefPointsInterp.size()];
            for (int i = 0; i < timeStampInitSecondsRefPointsInterp.size(); i++) {
                timeStampInitSecondsRefPointsInterp0[i] = timeStampInitSecondsRefPointsInterp.get(i) - timeRef;
            }
            if (findIdxEndTime && findIdxInitTime && initTime < endTime && idxInitTime < idxEndTime) {
                List<double[]> vPoints = new ArrayList<double[]>();
                List<double[]> pPoints = new ArrayList<double[]>();
                List<Double> timeStampOutput = new ArrayList<Double>();
                HermiteInterpolation.interpolation(timeStampInitSecondsRefPoints, stateVecPoints, timeStampInitSecondsRefPointsInterp0, idxInitTime, idxEndTime, deltaTinv, pPoints, vPoints, timeStampOutput);
                addPointsToResult(vPoints, pPoints);
                List<Double> timeStampInterpSecondsRefOutput = new ArrayList<Double>();
                for (int i = 0; i < timeStampOutput.size(); i++) {
                    timeStampInterpSecondsRefOutput.add(timeStampOutput.get(i) + timeRef);
                }
                if (timeStampInterp == null)
                    timeStampInterp = new ArrayList<>(timeStampInterpSecondsRefOutput);
                else
                    timeStampInterp.addAll(timeStampInterpSecondsRefOutput);
            }
        }
    }
    if (zeroDopplerTimeEndRef > secondsDiffFromRefTime[secondsDiffFromRefTime.length - 1]) {
        int vOrbPointsInit = (nPoints - Math.min(nPoints, N_ORB_POINT_INTERP));
        int vOrbPointsEnd = nPoints - 1;
        double[] timeStampInitSecondsRefPoints = Arrays.copyOfRange(secondsDiffFromRefTime, vOrbPointsInit, vOrbPointsEnd + 1);
        List<Double> timeStampInitSecondsRefPointsInterp = new ArrayList<Double>();
        for (int i = 0; i < timeStampInterpSecondsRef.length; i++) {
            if (timeStampInterpSecondsRef[i] >= secondsDiffFromRefTime[vOrbPointsInit]) {
                timeStampInitSecondsRefPointsInterp.add(timeStampInterpSecondsRef[i]);
            }
        }
        List<S1Metadata.OrbitStatePosVelox> stateVecPoints = vpList.subList(vOrbPointsInit, vOrbPointsEnd + 1);
        double initTime = secondsDiffFromRefTime[vOrbPointsEnd];
        int idxInitTime = 0;
        boolean findIdxInitTime = false;
        for (int i = 0; i < timeStampInitSecondsRefPointsInterp.size() && !findIdxInitTime; i++) {
            if (timeStampInitSecondsRefPointsInterp.get(i) >= initTime) {
                idxInitTime = i;
                findIdxInitTime = true;
            }
        }
        double endTime = zeroDopplerTimeEndRef;
        int idxEndTime = 0;
        boolean findIdxEndTime = false;
        for (int i = timeStampInitSecondsRefPointsInterp.size() - 1; i >= 0 && !findIdxEndTime; i--) {
            if (timeStampInitSecondsRefPointsInterp.get(i) < endTime) {
                idxEndTime = i;
                findIdxEndTime = true;
            }
        }
        double timeRef = timeStampInitSecondsRefPointsInterp.get(0);
        Double[] timeStampInitSecondsRefPointsInterp0 = new Double[timeStampInitSecondsRefPointsInterp.size()];
        for (int i = 0; i < timeStampInitSecondsRefPointsInterp.size(); i++) {
            timeStampInitSecondsRefPointsInterp0[i] = timeStampInitSecondsRefPointsInterp.get(i) - timeRef;
        }
        if (findIdxEndTime && findIdxInitTime && initTime < endTime) {
            List<double[]> vPoints = new ArrayList<double[]>();
            List<double[]> pPoints = new ArrayList<double[]>();
            List<Double> timeStampOutput = new ArrayList<Double>();
            HermiteInterpolation.interpolation(timeStampInitSecondsRefPoints, stateVecPoints, timeStampInitSecondsRefPointsInterp0, idxInitTime, idxEndTime, deltaTinv, pPoints, vPoints, timeStampOutput);
            addPointsToResult(vPoints, pPoints);
            List<Double> timeStampInterpSecondsRefOutput = new ArrayList<Double>();
            for (int i = 0; i < timeStampOutput.size(); i++) {
                timeStampInterpSecondsRefOutput.add(timeStampOutput.get(i) + timeRef);
            }
            if (timeStampInterp == null)
                timeStampInterp = new ArrayList<>(timeStampInterpSecondsRefOutput);
            else
                timeStampInterp.addAll(timeStampInterpSecondsRefOutput);
        }
    }
}

Output:
         if (firstTime < (lastTime)) {
-            minT = FastMath.min(secondsDiffFromRefTime[0], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);
+            minT = FastMath.min(secondsDiffFromRefTime[0], zeroDopplerTimeLastLineWSafetyBufSecondsRef);
             maxT = FastMath.max(secondsDiffFromRefTime[secondsDiffFromRefTime.length - 1], zeroDopplerTimeFirstLineWSafetyBufSecondsRef);


Input:
private OrdinalSet<InstanceKey> toOrdinalInstanceKeySet(Collection c) {
    BimodalMutableIntSet s = new BimodalMutableIntSet();
    for (Iterator it = c.iterator(); it.hasNext(); ) {
        IClass klass = (IClass) it.next();
        int index = getInstanceKeyMapping().getMappedIndex(new ConcreteTypeKey(klass));
        if (index >= 0) {
            s.add(index);
        }
    }
    return new OrdinalSet<InstanceKey>(s, getInstanceKeyMapping());
}

Output:
         IClass klass = (IClass) it.next();
-        int index = getInstanceKeyMapping().getMappedIndex(new ConcreteTypeKey(klass));
-        if (index >= 0) {
-            s.add(index);
-        }
+        int index = getInstanceKeyMapping().add(new ConcreteTypeKey(klass));
+        s.add(index);
     }


Input:
private FieldNode createFieldNodeCopy(String newName, ClassNode newType, FieldNode f) {
    if (newType == null)
        newType = f.getType();
    newType = newType.getPlainNodeReference();
    return new FieldNode(newName, f.getModifiers(), newType, f.getOwner(), f.getInitialValueExpression());
}

Output:
 private FieldNode createFieldNodeCopy(String newName, ClassNode newType, FieldNode f) {
-    if (newType == null)
+    if (newType == null) {
         newType = f.getType();


Input:
public ItemStack getCraftingSlot(int slot) throws LuaException {
    --slot;
    if (slot >= 0 || slot <= craftingInv.getSizeInventory()) {
        return craftingInv.getStackInSlot(slot);
    }
    return null;
}

Output:
     --slot;
-    if (slot >= 0 || slot <= craftingInv.getSizeInventory()) {
+    if (slot >= 0 && slot < craftingInv.getSizeInventory()) {
         return craftingInv.getStackInSlot(slot);


Input:
public Split split(final Arc arc) {
    final BSPTree<Sphere1D> minus = new BSPTree<Sphere1D>();
    minus.setAttribute(Boolean.FALSE);
    final BSPTree<Sphere1D> plus = new BSPTree<Sphere1D>();
    plus.setAttribute(Boolean.FALSE);
    final double reference = FastMath.PI + arc.getInf();
    final double arcLength = arc.getSup() - arc.getInf();
    for (final double[] a : this) {
        final double syncedStart = MathUtils.normalizeAngle(a[0], reference) - arc.getInf();
        final double arcOffset = a[0] - syncedStart;
        final double syncedEnd = a[1] - arcOffset;
        if (syncedStart < arcLength) {
            addArcLimit(minus, a[0], true);
            if (syncedEnd > arcLength) {
                final double minusToPlus = arcLength + arcOffset;
                addArcLimit(minus, minusToPlus, false);
                addArcLimit(plus, minusToPlus, true);
                if (syncedEnd > MathUtils.TWO_PI) {
                    final double plusToMinus = MathUtils.TWO_PI + arcOffset;
                    addArcLimit(plus, plusToMinus, false);
                    addArcLimit(minus, plusToMinus, true);
                    addArcLimit(minus, a[1], false);
                } else {
                    addArcLimit(plus, a[1], false);
                }
            } else {
                addArcLimit(minus, a[1], false);
            }
        } else {
            addArcLimit(plus, a[0], true);
            if (syncedEnd > MathUtils.TWO_PI) {
                final double plusToMinus = MathUtils.TWO_PI + arcOffset;
                addArcLimit(plus, plusToMinus, false);
                addArcLimit(minus, plusToMinus, true);
                if (syncedEnd > MathUtils.TWO_PI + arcLength) {
                    final double minusToPlus = MathUtils.TWO_PI + arcLength + arcOffset;
                    addArcLimit(minus, minusToPlus, false);
                    addArcLimit(plus, minusToPlus, true);
                    addArcLimit(plus, a[1], false);
                } else {
                    addArcLimit(minus, a[1], false);
                }
            } else {
                addArcLimit(plus, a[1], false);
            }
        }
    }
    return new Split(createSplitPart(plus), createSplitPart(minus));
}

Output:
 public Split split(final Arc arc) {
-    final BSPTree<Sphere1D> minus = new BSPTree<Sphere1D>();
-    minus.setAttribute(Boolean.FALSE);
-    final BSPTree<Sphere1D> plus = new BSPTree<Sphere1D>();
-    plus.setAttribute(Boolean.FALSE);
+    final List<Double> minus = new ArrayList<Double>();
+    final List<Double> plus = new ArrayList<Double>();
     final double reference = FastMath.PI + arc.getInf();


Input:
protected void addFieldsListeners() {
    xmlXsdFilePath.addSelectionListener(new SelectionListener() {
        public void widgetSelected(SelectionEvent event) {
            if (xmlXsdFilePath.getResult() == null) {
                return;
            }
            String text = xmlXsdFilePath.getText();
            if (isContextMode()) {
                ContextType contextType = ConnectionContextHelper.getContextTypeForContextMode(connectionItem.getConnection(), true);
                text = TalendQuoteUtils.removeQuotes(ConnectionContextHelper.getOriginalValue(contextType, text));
            }
            File file = new File(text);
            if (file.exists()) {
                List<ATreeNode> treeNodes = new ArrayList<ATreeNode>();
                if (XmlUtil.isXSDFile(text)) {
                    try {
                        XSDSchema xsdSchema = updateXSDSchema(text);
                        List<ATreeNode> list = updateRootNodes(xsdSchema, true);
                        if (list.size() > 1) {
                            RootNodeSelectDialog dialog = new RootNodeSelectDialog(null, list);
                            if (dialog.open() == IDialogConstants.OK_ID) {
                                ATreeNode selectedNode = dialog.getSelectedNode();
                                valid = treePopulator.populateTree(xsdSchema, selectedNode, treeNodes);
                            } else {
                                return;
                            }
                        } else {
                            valid = treePopulator.populateTree(xsdSchema, list.get(0), treeNodes);
                        }
                    } catch (Exception e) {
                        ExceptionHandler.process(e);
                    }
                } else {
                    valid = treePopulator.populateTree(text, treeNode);
                }
                checkFieldsValue();
                if (!valid) {
                    return;
                }
                if (treeNodes.size() > 0) {
                    treeNode = treeNodes.get(0);
                }
                updateConnection(text);
            }
        }
        public void widgetDefaultSelected(SelectionEvent e) {
        }
    });
    xmlXsdFilePath.addFocusListener(new FocusListener() {

        public void focusLost(FocusEvent e) {
            String text = xmlXsdFilePath.getText();
            if (isContextMode()) {
                ContextType contextType = ConnectionContextHelper.getContextTypeForContextMode(connectionItem.getConnection(), true);
                text = TalendQuoteUtils.removeQuotes(ConnectionContextHelper.getOriginalValue(contextType, text));
            }
            if (getConnection().getXmlFilePath() != null && !getConnection().getXmlFilePath().equals(text)) {
                getConnection().getLoop().clear();
                getConnection().getRoot().clear();
                getConnection().getGroup().clear();
                xsdPathChanged = true;
            } else {
                xsdPathChanged = false;
            }
            getConnection().setXmlFilePath(PathUtils.getPortablePath(xmlXsdFilePath.getText()));
            StringBuilder fileContent = new StringBuilder();
            BufferedReader in = null;
            File file = null;
            if (tempXmlXsdPath != null && getConnection().getFileContent() != null && getConnection().getFileContent().length > 0 && !isModifing) {
                file = new File(tempXmlXsdPath);
                if (!file.exists()) {
                    try {
                        file.createNewFile();
                    } catch (IOException e2) {
                        ExceptionHandler.process(e2);
                    }
                    FileOutputStream outStream;
                    try {
                        outStream = new FileOutputStream(file);
                        outStream.write(getConnection().getFileContent());
                        outStream.close();
                    } catch (FileNotFoundException e1) {
                        ExceptionHandler.process(e1);
                    } catch (IOException e2) {
                        ExceptionHandler.process(e2);
                    }
                }
            } else {
                file = new File(text);
            }
            if (!XmlUtil.isXMLFile(file.getPath())) {
                setFileContent(file);
            }
            String str;
            try {
                Charset guessCharset = CharsetToolkit.guessEncoding(file, 4096);
                in = new BufferedReader(new InputStreamReader(new FileInputStream(file), guessCharset.displayName()));
                while ((str = in.readLine()) != null) {
                    fileContent.append(str + "String_Node_Str");
                    if (str.contains("String_Node_Str")) {
                        String regex = "String_Node_Str";
                        Perl5Compiler compiler = new Perl5Compiler();
                        Perl5Matcher matcher = new Perl5Matcher();
                        Pattern pattern = null;
                        try {
                            pattern = compiler.compile(regex);
                            if (matcher.contains(str, pattern)) {
                                MatchResult matchResult = matcher.getMatch();
                                if (matchResult != null) {
                                    encoding = matchResult.group(1);
                                }
                            }
                        } catch (MalformedPatternException malE) {
                            ExceptionHandler.process(malE);
                        }
                    }
                }
                fileContentText.setText(new String(fileContent));
            } catch (Exception e1) {
                String msgError = Messages.getString("String_Node_Str") + "String_Node_Str" + xmlXsdFilePath.getText().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str";
                if (e1 instanceof FileNotFoundException) {
                    msgError = msgError + Messages.getString("String_Node_Str");
                } else if (e1 instanceof EOFException) {
                    msgError = msgError + Messages.getString("String_Node_Str");
                } else if (e1 instanceof IOException) {
                    msgError = msgError + Messages.getString("String_Node_Str");
                } else {
                    msgError = msgError + Messages.getString("String_Node_Str");
                }
                fileContentText.setText(msgError);
                if (!isReadOnly()) {
                    updateStatus(IStatus.ERROR, msgError);
                }
            } finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (Exception exception) {
                    ExceptionHandler.process(exception);
                }
            }
            if (getConnection().getEncoding() == null || "String_Node_Str".equals(getConnection().getEncoding())) {
                getConnection().setEncoding(encoding);
                if (encoding != null && !"String_Node_Str".equals(encoding)) {
                    encodingCombo.setText(encoding);
                } else {
                    encodingCombo.setText("String_Node_Str");
                }
            }
            if (file.exists()) {
                List<ATreeNode> treeNodes = new ArrayList<ATreeNode>();
                if (XmlUtil.isXSDFile(text)) {
                    try {
                        XSDSchema xsdSchema = updateXSDSchema(text);
                        List<ATreeNode> list = updateRootNodes(xsdSchema, true);
                        if (list.size() > 1) {
                            RootNodeSelectDialog dialog = new RootNodeSelectDialog(null, list);
                            if (dialog.open() == IDialogConstants.OK_ID) {
                                ATreeNode selectedNode = dialog.getSelectedNode();
                                valid = treePopulator.populateTree(xsdSchema, selectedNode, treeNodes);
                            } else {
                                return;
                            }
                        } else {
                            valid = treePopulator.populateTree(xsdSchema, list.get(0), treeNodes);
                        }
                    } catch (Exception e1) {
                        ExceptionHandler.process(e1);
                    }
                } else {
                    valid = treePopulator.populateTree(text, treeNode);
                }
                checkFieldsValue();
                if (!valid) {
                    return;
                }
                if (treeNodes.size() > 0) {
                    treeNode = treeNodes.get(0);
                }
                updateConnection(text);
            }
            valid = treePopulator.populateTree(text, treeNode);
            checkFieldsValue();
            isModifing = true;
        }
        public void focusGained(FocusEvent e) {
        }
    });
    encodingCombo.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            getConnection().setEncoding(encodingCombo.getText());
            checkFieldsValue();
        }
    });
    commonNodesLimitation.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            String str = commonNodesLimitation.getText();
            if ((!str.matches("String_Node_Str")) || (Integer.valueOf(str) < 0)) {
                commonNodesLimitation.setText(String.valueOf(treePopulator.getLimit()));
            } else {
                treePopulator.setLimit(Integer.valueOf(str));
            }
            valid = treePopulator.populateTree(xmlXsdFilePath.getText(), treeNode);
            checkFieldsValue();
        }
    });
    commonNodesLimitation.addFocusListener(new FocusListener() {
        public void focusGained(FocusEvent e) {
        }
        public void focusLost(FocusEvent e) {
            commonNodesLimitation.setText(String.valueOf(TreePopulator.getLimit()));
        }
    });
    outputFilePath.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            getConnection().setOutputFilePath(PathUtils.getPortablePath(outputFilePath.getText()));
            checkFieldsValue();
        }
    });
}

Output:
     });
-    xmlXsdFilePath.addFocusListener(new FocusListener() {
+    xmlXsdFilePath.addModifyListener(new ModifyListener() {


Input:
private void indexError(LuaState vm, LValue nontable) {
    vm.error("String_Node_Str" + nontable.luaGetTypeName() + "String_Node_Str", 2);
}

Output:
 private void indexError(LuaState vm, LValue nontable) {
-    vm.error("String_Node_Str" + nontable.luaGetTypeName() + "String_Node_Str", 2);
+    vm.error("String_Node_Str" + nontable.luaGetTypeName() + "String_Node_Str", 1);
 }


Input:
public ConnectionAnchor getTargetConnectionAnchor(Request request) {
    if (getFigure() instanceof LabelFigure) {
        return null;
    } else {
        return ((OPMNodeFigure) getFigure()).getTargetConnectionAnchor();
    }
}

Output:
 public ConnectionAnchor getTargetConnectionAnchor(Request request) {
-    if (getFigure() instanceof LabelFigure) {
-        return null;
-    } else {
+    if (getFigure() instanceof OPMNodeFigure) {
         return ((OPMNodeFigure) getFigure()).getTargetConnectionAnchor();


Input:
public void readPortableData(EntityPlayer player, NBTTagCompound tag) {
    if (!canPlayerAccess(player.getCommandSenderName())) {
        return;
    }
    intensity = tag.getInteger("String_Node_Str");
    angle = tag.getInteger("String_Node_Str");
    updateForce();
    markDirty();
    sendUpdatePacket(Side.CLIENT);
}

Output:
 public void readPortableData(EntityPlayer player, NBTTagCompound tag) {
-    if (!canPlayerAccess(player.getCommandSenderName())) {
+    if (!canPlayerAccess(player)) {
         return;


Input:
public void replace_3arg() {
    SimpleCacheLoader<Integer> loader = new SimpleCacheLoader<Integer>();
    Cache<Integer, Integer> cache = getCacheManager().configureCache(getTestCacheName(), new MutableConfiguration<Integer, Integer>().setCacheLoader(loader));
    Integer key = 1;
    Integer value1 = key + 1;
    Integer value2 = value1 + 1;
    Integer value3 = value2 + 1;
    cache.put(key, value2);
    assertTrue(cache.replace(key, value2, value3));
    assertEquals(value3, cache.get(key));
}

Output:
     SimpleCacheLoader<Integer> loader = new SimpleCacheLoader<Integer>();
-    Cache<Integer, Integer> cache = getCacheManager().configureCache(getTestCacheName(), new MutableConfiguration<Integer, Integer>().setCacheLoader(loader));
+    Cache<Integer, Integer> cache = getCacheManager().configureCache(getTestCacheName(), new MutableConfiguration<Integer, Integer>().setCacheLoaderFactory(Factories.of(loader)));
     Integer key = 1;


Input:
private void verifyDeltaSerials(final List<Delta> orderedDeltas, final Notification notification, RpkiRepository rpkiRepository) {
    if (orderedDeltas.isEmpty()) {
        throw new RrdpException("String_Node_Str" + rpkiRepository.getRrdpSerial() + "String_Node_Str" + notification.serial + "String_Node_Str");
    }
    final BigInteger lastDeltaSerial = orderedDeltas.get(orderedDeltas.size() - 1).getSerial();
    if (!notification.serial.equals(lastDeltaSerial)) {
        throw new RrdpException("String_Node_Str" + lastDeltaSerial + "String_Node_Str" + notification.serial);
    }
    final BigInteger[] previous = { null };
    orderedDeltas.forEach(d -> {
        if (previous[0] == null) {
            previous[0] = d.getSerial();
        } else {
            if (!d.getSerial().equals(previous[0].add(BigInteger.ONE))) {
                throw new RrdpException(String.format("String_Node_Str", previous[0], d.getSerial()));
            }
        }
    });
}

Output:
     if (orderedDeltas.isEmpty()) {
-        throw new RrdpException("String_Node_Str" + rpkiRepository.getRrdpSerial() + "String_Node_Str" + notification.serial + "String_Node_Str");
-    }
-    final BigInteger lastDeltaSerial = orderedDeltas.get(orderedDeltas.size() - 1).getSerial();
-    if (!notification.serial.equals(lastDeltaSerial)) {
-        throw new RrdpException("String_Node_Str" + lastDeltaSerial + "String_Node_Str" + notification.serial);
-    }
-    final BigInteger[] previous = { null };
-    orderedDeltas.forEach(d -> {
-        if (previous[0] == null) {
-            previous[0] = d.getSerial();
-        } else {
-            if (!d.getSerial().equals(previous[0].add(BigInteger.ONE))) {
-                throw new RrdpException(String.format("String_Node_Str", previous[0], d.getSerial()));
-            }
+        if (!rpkiRepository.getRrdpSerial().equals(notification.serial)) {
+            throw new RrdpException("String_Node_Str" + rpkiRepository.getRrdpSerial() + "String_Node_Str" + notification.serial + "String_Node_Str");
         }