Input:
private static void requestTransportStatus(Context context, final SdlRouterStatusProvider.ConnectedStatusCallback callback, final boolean triggerRouterServicePing) {
    if (context == null) {
        if (callback != null) {
            callback.onConnectionStatusUpdate(false, null, context);
        }
        return;
    }
    if (isRouterServiceRunning(context, false) && !runningBluetoothServicePackage.isEmpty()) {
        final ConcurrentLinkedQueue<ComponentName> list = new ConcurrentLinkedQueue<ComponentName>(runningBluetoothServicePackage);
        if (runningBluetoothServicePackage.size() > 0) {
            final SdlRouterStatusProvider.ConnectedStatusCallback sdlBrCallback = new SdlRouterStatusProvider.ConnectedStatusCallback() {
                public void onConnectionStatusUpdate(boolean connected, ComponentName service, Context context) {
                    if (!connected && !list.isEmpty()) {
                        SdlRouterStatusProvider provider = new SdlRouterStatusProvider(context, list.poll(), this);
                        if (triggerRouterServicePing) {
                            provider.setFlags(TransportConstants.ROUTER_STATUS_FLAG_TRIGGER_PING);
                        }
                        provider.checkIsConnected();
                    } else {
                        Log.d(TAG, service.getPackageName() + "String_Node_Str" + connected);
                        if (callback != null) {
                            callback.onConnectionStatusUpdate(connected, service, context);
                        }
                        list.clear();
                    }
                }
            };
            SdlRouterStatusProvider provider = new SdlRouterStatusProvider(context, list.poll(), sdlBrCallback);
            if (triggerRouterServicePing) {
                provider.setFlags(TransportConstants.ROUTER_STATUS_FLAG_TRIGGER_PING);
            }
            provider.checkIsConnected();
        } else {
            SdlRouterStatusProvider provider = new SdlRouterStatusProvider(context, runningBluetoothServicePackage.get(0), callback);
            if (triggerRouterServicePing) {
                provider.setFlags(TransportConstants.ROUTER_STATUS_FLAG_TRIGGER_PING);
            }
            provider.checkIsConnected();
        }
    } else {
        Log.w(TAG, "String_Node_Str");
        if (BluetoothAdapter.getDefaultAdapter() != null && BluetoothAdapter.getDefaultAdapter().isEnabled()) {
            Intent serviceIntent = new Intent();
            serviceIntent.setAction(TransportConstants.START_ROUTER_SERVICE_ACTION);
            serviceIntent.putExtra(TransportConstants.PING_ROUTER_SERVICE_EXTRA, true);
            context.sendBroadcast(serviceIntent);
        }
        if (callback != null) {
            callback.onConnectionStatusUpdate(false, null, context);
        }
    }
}

Output:
             }
-            provider.checkIsConnected();
+        };
+        final SdlRouterStatusProvider provider = new SdlRouterStatusProvider(context, list.poll(), sdlBrCallback);
+        if (triggerRouterServicePing) {
+            provider.setFlags(TransportConstants.ROUTER_STATUS_FLAG_TRIGGER_PING);
         }


Input:
public void testMath70LocalOutputs() throws Exception {
    AstorMain main1 = new AstorMain();
    String dep = new File("String_Node_Str").getAbsolutePath();
    File out = new File(ConfigurationProperties.getProperty("String_Node_Str"));
    int generations = 50;
    String[] args = commandMath70(dep, out, generations);
    CommandSummary cs = new CommandSummary(args);
    cs.command.put("String_Node_Str", "String_Node_Str");
    System.out.println(Arrays.toString(cs.flat()));
    main1.execute(cs.flat());
    List<ProgramVariant> solutions = main1.getEngine().getSolutions();
    assertTrue(solutions.size() > 0);
    assertEquals(1, solutions.size());
    Stats stats = Stats.createStat();
    assertNotNull(stats);
    assertNotNull(stats.getStatsOfPatches());
    assertTrue(stats.getStatsOfPatches().size() > 0);
    String jsonpath = main1.getEngine().getProjectFacade().getProperties().getWorkingDirRoot() + File.separator + ConfigurationProperties.getProperty("String_Node_Str") + "String_Node_Str";
    File filejson = new File(jsonpath);
    assertTrue(filejson.exists());
    JSONParser parser = new JSONParser();
    Object obj = parser.parse(new FileReader(filejson));
    JSONObject jsonroot = (JSONObject) obj;
    JSONArray msg = (JSONArray) jsonroot.get("String_Node_Str");
    assertEquals(1, msg.size());
    JSONObject pob = (JSONObject) msg.get(0);
    JSONArray hunks = (JSONArray) pob.get("String_Node_Str");
    assertEquals(1, hunks.size());
    JSONObject hunkob = (JSONObject) hunks.get(0);
    assertEquals("String_Node_Str", hunkob.get(HunkStatEnum.PATCH_HUNK_CODE.name()));
    assertEquals("String_Node_Str", hunkob.get(HunkStatEnum.ORIGINAL_CODE.name()));
    assertEquals(1, stats.getStatsOfPatches().size());
    PatchStat patchstats = stats.getStatsOfPatches().get(0);
    List<PatchHunkStats> hunksApi = (List<PatchHunkStats>) patchstats.getStats().get(PatchStatEnum.HUNKS);
    assertNotNull(hunksApi);
    PatchHunkStats hunkStats = hunksApi.get(0);
    assertNotNull(hunkStats);
    assertEquals("String_Node_Str", hunkStats.getStats().get(HunkStatEnum.PATCH_HUNK_CODE));
    assertEquals("String_Node_Str", hunkob.get(HunkStatEnum.ORIGINAL_CODE.name()));
}

Output:
     assertEquals(1, solutions.size());
-    Stats stats = Stats.createStat();
+    Stats stats = Stats.getCurrentStat();
     assertNotNull(stats);


Input:
public void setUp() {
    expectProblems.clear();
    expectProblems.add(createNewProblem(MethodProbIds.UndefinedMethod, 7, 0));
    expectProblems.add(createNewProblem(MethodProbIds.UndefinedMethod, 10, 0));
    expectProblems.add(createNewProblem(VjoSyntaxProbIds.TypeUnknownNotInTypeSpace, 2, 0));
}

Output:
     expectProblems.add(createNewProblem(MethodProbIds.UndefinedMethod, 7, 0));
-    expectProblems.add(createNewProblem(MethodProbIds.UndefinedMethod, 10, 0));
+    expectProblems.add(createNewProblem(VarProbIds.UndefinedName, 10, 0));
     expectProblems.add(createNewProblem(VjoSyntaxProbIds.TypeUnknownNotInTypeSpace, 2, 0));


Input:
public void wordCount(IProgressMonitor monitor, List<File> inputFiles, List<String> dictionaryFile, String stopWordsFile, String outputFile, String delimiters, boolean doLower, boolean doLiwcStemming, boolean doSnowBallStemming, boolean doSpss, boolean doWordDistribution, boolean stemDictionary, File oFile, File sFile) throws IOException {
    if (delimiters == null || delimiters.equals("String_Node_Str"))
        this.delimiters = "String_Node_Str";
    else
        this.delimiters = delimiters;
    this.doLower = doLower;
    this.doLiwcStemming = doLiwcStemming;
    this.doSpss = doSpss;
    this.doWordDistribution = doWordDistribution;
    this.doSnowballStemming = doSnowBallStemming;
    this.stemDictionary = stemDictionary;
    if (!this.weighted)
        this.doLiwcStemming = true;
    appendLog("String_Node_Str");
    if (stopWordsFile.equals(null) || stopWordsFile.equals("String_Node_Str"))
        this.doStopWords = false;
    else
        this.doStopWords = true;
    long startTime = System.currentTimeMillis();
    monitor.subTask("String_Node_Str");
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    monitor.subTask("String_Node_Str");
    buildCategorizer(dictionaryFile);
    logger.info("String_Node_Str" + (System.currentTimeMillis() - startTime) + "String_Node_Str");
    appendLog("String_Node_Str" + (System.currentTimeMillis() - startTime) + "String_Node_Str");
    monitor.worked(10);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    if (doStopWords) {
        startTime = System.currentTimeMillis();
        monitor.subTask("String_Node_Str");
        stopWordSetBuild(new File(stopWordsFile));
        logger.info("String_Node_Str" + (System.currentTimeMillis() - startTime) + "String_Node_Str");
        appendLog("String_Node_Str" + (System.currentTimeMillis() - startTime) + "String_Node_Str");
    }
    monitor.worked(10);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    monitor.subTask("String_Node_Str");
    buildOutputFile(oFile);
    monitor.worked(2);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    if (doSpss) {
        monitor.subTask("String_Node_Str" + sFile.getName() + "String_Node_Str");
        buildSpssFile(sFile);
    }
    monitor.worked(10);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    for (File inputFile : inputFiles) {
        if (inputFile.getAbsolutePath().contains("String_Node_Str"))
            continue;
        monitor.subTask("String_Node_Str" + inputFile);
        countWords(inputFile, oFile, sFile);
        monitor.worked(1);
    }
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    monitor.worked(10);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
    monitor.subTask("String_Node_Str");
    if (this.weighted)
        TacitUtility.createReadMe(outputFile, "String_Node_Str");
    else
        TacitUtility.createReadMe(outputFile, "String_Node_Str");
    monitor.worked(5);
    if (monitor.isCanceled()) {
        throw new OperationCanceledException();
    }
}

Output:
     appendLog("String_Node_Str");
-    if (stopWordsFile.equals(null) || stopWordsFile.equals("String_Node_Str"))
+    if (stopWordsFile.equals(null) || stopWordsFile.equals("String_Node_Str") || !this.weighted)
         this.doStopWords = false;


Input:
public void createDataSetsTree(List dataSetList) {
    Assert.isNotNull(tree);
    TreeItem topItem = createTopTreeItem(tree, TREE_ITEM_DATASETS);
    for (Iterator iterator = dataSetList.iterator(); iterator.hasNext(); ) {
        DataSetHandle handle = (DataSetHandle) iterator.next();
        TreeItem dataSetItem = createSubTreeItem(topItem, DEUtil.getDisplayLabel(handle, false), ReportPlatformUIImages.getImage(handle), true);
        try {
            CachedMetaDataHandle cachedMetadata = DataSetUIUtil.getCachedMetaDataHandle(handle);
            for (Iterator iter = cachedMetadata.getResultSet().iterator(); iter.hasNext(); ) {
                ResultSetColumnHandle element = (ResultSetColumnHandle) iter.next();
                createSubTreeItem(dataSetItem, element.getColumnName(), IMAGE_COLUMN, DEUtil.getExpression(element), element.getColumnName(), true);
            }
        } catch (SemanticException e) {
        }
    }
}

Output:
     Assert.isNotNull(tree);
-    TreeItem topItem = createTopTreeItem(tree, TREE_ITEM_DATASETS);
-    for (Iterator iterator = dataSetList.iterator(); iterator.hasNext(); ) {
-        DataSetHandle handle = (DataSetHandle) iterator.next();
-        TreeItem dataSetItem = createSubTreeItem(topItem, DEUtil.getDisplayLabel(handle, false), ReportPlatformUIImages.getImage(handle), true);
-        try {
-            CachedMetaDataHandle cachedMetadata = DataSetUIUtil.getCachedMetaDataHandle(handle);
-            for (Iterator iter = cachedMetadata.getResultSet().iterator(); iter.hasNext(); ) {
-                ResultSetColumnHandle element = (ResultSetColumnHandle) iter.next();
-                createSubTreeItem(dataSetItem, element.getColumnName(), IMAGE_COLUMN, DEUtil.getExpression(element), element.getColumnName(), true);
-            }
-        } catch (SemanticException e) {
-        }
-    }
+    dataSetsItem = createTopTreeItem(tree, TREE_ITEM_DATASETS);
+    buildDataSetsTree(dataSetList);
 }


Input:
private final void notifyMessageListener(Message msg, ReplyHandler handler) {
    List all = (List) _messageListeners.get(msg.getGUID());
    if (all != null) {
        for (Iterator i = all.iterator(); i.hasNext(); ) {
            MessageListener next = (MessageListener) i.next();
            next.processMessage(msg, handler);
        }
    }
}

Output:
 private final void notifyMessageListener(Message msg, ReplyHandler handler) {
-    List all = (List) _messageListeners.get(msg.getGUID());
+    List<MessageListener> all = _messageListeners.get(msg.getGUID());
     if (all != null) {


Input:
public default Response toResponse() {
    if (isBaseRequirementsMet() && isPhysicallyPossible() && !isBannedFromSexManager()) {
        if (this.getActionType() == SexActionType.POSITIONING && !Sex.isPositionChangingAllowed()) {
            return null;
        }
        for (Entry<SexAreaInterface, SexAreaInterface> entry : getSexAreaInteractions().entrySet()) {
            if (isForbiddenArea(entry.getKey()) || isForbiddenArea(entry.getValue())) {
                return null;
            }
        }
        if (Sex.getCharacterPerformingAction().isPlayer()) {
            if (this.getParticipantType() == SexParticipantType.CATCHER && this.getTargetedCharacterPenetrations().contains(SexAreaPenetration.PENIS) && !Sex.getCharacterTargetedForSexAction().getPlayerKnowsAreas().contains(CoverableArea.PENIS)) {
                return null;
            }
            for (SexAreaOrifice sArea : this.getTargetedCharacterOrifices()) {
                switch(sArea) {
                    case NIPPLE:
                        if (!Sex.getActivePartner().getPlayerKnowsAreas().contains(CoverableArea.NIPPLES)) {
                            return null;
                        }
                        break;
                    case URETHRA_PENIS:
                        if (!Sex.getActivePartner().getPlayerKnowsAreas().contains(CoverableArea.PENIS)) {
                            return null;
                        }
                        break;
                    case URETHRA_VAGINA:
                        if (!Sex.getActivePartner().getPlayerKnowsAreas().contains(CoverableArea.VAGINA)) {
                            return null;
                        }
                        break;
                    case VAGINA:
                        if (!Sex.getActivePartner().getPlayerKnowsAreas().contains(CoverableArea.VAGINA)) {
                            return null;
                        }
                        break;
                    default:
                        break;
                }
            }
        }
        if (Sex.getCharacterPerformingAction().isPlayer() && getActionType() == SexActionType.PREPARE_FOR_PARTNER_ORGASM) {
            if (!Sex.isPartnerReadyToOrgasm()) {
                return null;
            } else {
                return convertToResponse();
            }
        }
        if (!Sex.getCharacterPerformingAction().isPlayer() && getActionType() == SexActionType.PREPARE_FOR_PARTNER_ORGASM) {
            if (!Sex.isPlayerReadyToOrgasm()) {
                return null;
            } else {
                return convertToResponse();
            }
        }
        if (getSexPace(Sex.getCharacterPerformingAction()) == SexPace.SUB_RESISTING) {
            if (Sex.isConsensual() || !Main.game.isNonConEnabled()) {
                return null;
            }
        }
        if (getActionType() == SexActionType.POSITIONING) {
            return convertToResponse();
        } else if (getActionType() == SexActionType.STOP_ONGOING) {
            if (!this.getSexAreaInteractions().isEmpty()) {
                boolean ongoingFound = false;
                for (SexAreaInterface sArea : this.getSexAreaInteractions().keySet()) {
                    if (Sex.getCharacterContactingSexArea(Sex.getCharacterPerformingAction(), sArea).contains(Sex.getCharacterTargetedForSexAction())) {
                        ongoingFound = true;
                        break;
                    }
                }
                if (!ongoingFound) {
                    return null;
                }
                if (this.getParticipantType() != SexParticipantType.SELF) {
                    if (!Sex.isSubHasEqualControl() && !Sex.isDom(Sex.getCharacterPerformingAction())) {
                        return null;
                    }
                }
            } else {
                return null;
            }
            return convertToResponse();
        } else if (getActionType() == SexActionType.START_ONGOING) {
            if (!this.getSexAreaInteractions().isEmpty()) {
                if (this.getParticipantType() != SexParticipantType.SELF) {
                    if ((!Sex.isSubHasEqualControl() && !Sex.isDom(Sex.getCharacterPerformingAction())) || getSexPace(Sex.getCharacterPerformingAction()) == SexPace.SUB_RESISTING) {
                        return null;
                    }
                }
            }
            for (SexAreaOrifice sArea : this.getPerformingCharacterOrifices()) {
                switch(sArea) {
                    case NIPPLE:
                        if (!Sex.getCharacterPerformingAction().isBreastFuckableNipplePenetration()) {
                            return null;
                        }
                        break;
                    default:
                        break;
                }
                if (!Sex.getCharacterPerformingAction().isOrificeTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaOrifice sArea : this.getTargetedCharacterOrifices()) {
                switch(sArea) {
                    case NIPPLE:
                        if (!Sex.getCharacterTargetedForSexAction().isBreastFuckableNipplePenetration()) {
                            return null;
                        }
                        break;
                    default:
                        break;
                }
                if (!Sex.getCharacterTargetedForSexAction().isOrificeTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaPenetration sArea : this.getPerformingCharacterPenetrations()) {
                if (!Sex.getCharacterPerformingAction().isPenetrationTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaPenetration sArea : this.getTargetedCharacterPenetrations()) {
                if (!Sex.getCharacterTargetedForSexAction().isPenetrationTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            return convertToResponse();
        } else if (getActionType() == SexActionType.REQUIRES_NO_PENETRATION_AND_EXPOSED) {
            for (SexAreaPenetration sArea : this.getPerformingCharacterPenetrations()) {
                if (!Sex.getCharacterPerformingAction().isPenetrationTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaPenetration sArea : this.getTargetedCharacterPenetrations()) {
                if (!Sex.getCharacterTargetedForSexAction().isPenetrationTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaOrifice sArea : this.getPerformingCharacterOrifices()) {
                if (!Sex.getCharacterPerformingAction().isOrificeTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaOrifice sArea : this.getTargetedCharacterOrifices()) {
                if (!Sex.getCharacterTargetedForSexAction().isOrificeTypeExposed(sArea)) {
                    return convertToNullResponse();
                }
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            return convertToResponse();
        } else if (getActionType() == SexActionType.REQUIRES_NO_PENETRATION) {
            for (SexAreaPenetration sArea : this.getPerformingCharacterPenetrations()) {
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaPenetration sArea : this.getTargetedCharacterPenetrations()) {
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaOrifice sArea : this.getPerformingCharacterOrifices()) {
                if (!sArea.isFree(Sex.getCharacterPerformingAction())) {
                    return convertToNullResponse();
                }
            }
            for (SexAreaOrifice sArea : this.getTargetedCharacterOrifices()) {
                if (!sArea.isFree(Sex.getCharacterTargetedForSexAction())) {
                    return convertToNullResponse();
                }
            }
            return convertToResponse();
        } else {
            if (!this.getSexAreaInteractions().isEmpty()) {
                boolean ongoingFound = false;
                for (SexAreaInterface sArea : this.getSexAreaInteractions().keySet()) {
                    for (SexAreaInterface sAreaTarget : this.getSexAreaInteractions().values()) {
                        if (Sex.getContactingSexAreas(Sex.getCharacterPerformingAction(), sArea, Sex.getCharacterTargetedForSexAction()).contains(sAreaTarget)) {
                            ongoingFound = true;
                            return convertToResponse();
                        }
                    }
                }
                if (!ongoingFound) {
                    return null;
                }
            }
            return convertToResponse();
        }
    } else {
        return null;
    }
}

Output:
                 boolean ongoingFound = false;
-                for (SexAreaInterface sArea : this.getSexAreaInteractions().keySet()) {
-                    if (Sex.getCharacterContactingSexArea(Sex.getCharacterPerformingAction(), sArea).contains(Sex.getCharacterTargetedForSexAction())) {
-                        ongoingFound = true;
-                        break;
+                if (this.getParticipantType().isUsingSelfPenetrationType()) {
+                    outerloop: for (SexAreaInterface sArea : this.getSexAreaInteractions().keySet()) {
+                        for (SexAreaInterface sAreaTarget : this.getSexAreaInteractions().values()) {
+                            if (Sex.getContactingSexAreas(Sex.getCharacterPerformingAction(), sArea, Sex.getCharacterTargetedForSexAction()).contains(sAreaTarget)) {
+                                ongoingFound = true;
+                                break outerloop;
+                            }
+                        }
+                    }
+                } else {
+                    outerloop: for (SexAreaInterface sArea : this.getSexAreaInteractions().keySet()) {
+                        for (SexAreaInterface sAreaTarget : this.getSexAreaInteractions().values()) {
+                            if (Sex.getContactingSexAreas(Sex.getCharacterTargetedForSexAction(), sArea, Sex.getCharacterPerformingAction()).contains(sAreaTarget)) {
+                                ongoingFound = true;
+                                break outerloop;
+                            }
+                        }
                     }


Input:
public void create(Table table) {
    Jump.DEBUG_ENABLED = true;
    drawDebug = true;
    shapeRenderer = new ShapeRenderer();
    spriteBatch = new SpriteBatch();
    world = createWorld(-9.81f);
    setContactListener();
    PolygonShape groundPoly = new PolygonShape();
    groundPoly.setAsBox(Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_WIDTH), Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_HEIGHT));
    BodyDef groundBodyDef = new BodyDef();
    groundBodyDef.type = BodyType.StaticBody;
    groundBodyDef.position.set(Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_WIDTH), Box2dSteeringTest.pixelsToMeters(PLATFORM_Y));
    leftPlatform = world.createBody(groundBodyDef);
    groundBodyDef.position.set(Box2dSteeringTest.pixelsToMeters((int) container.stageWidth - PLATFORM_HALF_WIDTH), Box2dSteeringTest.pixelsToMeters(PLATFORM_Y));
    rightPlatform = world.createBody(groundBodyDef);
    FixtureDef fixtureDef = new FixtureDef();
    fixtureDef.shape = groundPoly;
    fixtureDef.filter.groupIndex = 0;
    leftPlatform.createFixture(fixtureDef);
    rightPlatform.createFixture(fixtureDef);
    groundPoly.dispose();
    character = createSteeringEntity(world, container.badlogicSmall, true);
    character.setMaxLinearSpeed(4);
    character.setMaxLinearAcceleration(200);
    Vector2 takeoffPoint = new Vector2(leftPlatform.getPosition()).add(Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_WIDTH - 20), Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_HEIGHT) + character.getBoundingRadius());
    Vector2 landingPoint = new Vector2(rightPlatform.getPosition()).add(Box2dSteeringTest.pixelsToMeters(20 - PLATFORM_HALF_WIDTH), Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_HEIGHT) + character.getBoundingRadius());
    System.out.println("String_Node_Str" + takeoffPoint);
    System.out.println("String_Node_Str" + landingPoint);
    jumpDescriptor = new JumpDescriptor<Vector2>(takeoffPoint, landingPoint);
    JumpCallback jumpCallback = new JumpCallback() {
        JumpDescriptor<Vector2> newJumpDescriptor = new JumpDescriptor<Vector2>(new Vector2(), new Vector2());
        public void reportAchievability(boolean achievable) {
            System.out.println("String_Node_Str" + achievable);
        }
        public void takeoff(float maxVerticalVelocity, float time) {
            System.out.println("String_Node_Str");
            System.out.println("String_Node_Str" + character.getLinearVelocity() + "String_Node_Str" + character.getLinearVelocity().len());
            float h = maxVerticalVelocity * maxVerticalVelocity / (-2f * jumpSB.getGravity().y);
            System.out.println("String_Node_Str" + h);
            switch(airbornePlanarVelocityToUse) {
                case 0:
                    character.getBody().setLinearVelocity(character.getBody().getLinearVelocity().add(0, maxVerticalVelocity));
                    break;
                case 1:
                    Vector2 targetLinearVelocity = jumpSB.getTarget().getLinearVelocity();
                    character.getBody().setLinearVelocity(newJumpDescriptor.takeoffPosition.set(targetLinearVelocity.x, maxVerticalVelocity));
                    break;
                case 2:
                    Vector2 newLinearVelocity = character.getBody().getLinearVelocity();
                    newJumpDescriptor.set(character.getPosition(), jumpSB.getJumpDescriptor().landingPosition);
                    System.out.println("String_Node_Str" + character.getPosition());
                    time = jumpSB.calculateAirborneTimeAndVelocity(newLinearVelocity, newJumpDescriptor, jumpSB.getLimiter().getMaxLinearSpeed());
                    character.getBody().setLinearVelocity(newLinearVelocity.add(0, maxVerticalVelocity));
                    break;
            }
            character.setSteeringBehavior(null);
        }
    };
    jumpSB = new Jump<Vector2>(character, jumpDescriptor, world.getGravity(), GRAVITY_COMPONENT_HANDLER, jumpCallback).setMaxVerticalVelocity(5).setTakeoffPositionTolerance(.3f).setTakeoffVelocityTolerance(.7f).setTimeToTarget(.01f);
    jumpSB.setLimiter(new LinearLimiter(Float.POSITIVE_INFINITY, character.getMaxLinearSpeed() * 3));
    seekSB = new Seek<Vector2>(character, new SteerableAdapter<Vector2>() {
        Vector2 pos = new Vector2(jumpDescriptor.landingPosition).add(1000, 0);
        public Vector2 getPosition() {
            return pos;
        }
    });
    restart();
    Table detailTable = new Table(container.skin);
    detailTable.row();
    final Label labelRunUpLenght = new Label("String_Node_Str" + runUpLength + "String_Node_Str", container.skin);
    detailTable.add(labelRunUpLenght);
    detailTable.row();
    Slider sliderRunUpLenght = new Slider(0.1f, 4f, 0.1f, false, container.skin);
    sliderRunUpLenght.setValue(runUpLength);
    sliderRunUpLenght.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            runUpLength = slider.getValue();
            labelRunUpLenght.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(sliderRunUpLenght);
    detailTable.row();
    final Label labelTakeoffPosTol = new Label("String_Node_Str" + jumpSB.getTakeoffPositionTolerance() + "String_Node_Str", container.skin);
    detailTable.add(labelTakeoffPosTol);
    detailTable.row();
    Slider takeoffPosTol = new Slider(0.01f, 1f, 0.01f, false, container.skin);
    takeoffPosTol.setValue(jumpSB.getTakeoffPositionTolerance());
    takeoffPosTol.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            jumpSB.setTakeoffPositionTolerance(slider.getValue());
            labelTakeoffPosTol.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(takeoffPosTol);
    detailTable.row();
    final Label labelTakeoffVelTol = new Label("String_Node_Str" + jumpSB.getTakeoffVelocityTolerance() + "String_Node_Str", container.skin);
    detailTable.add(labelTakeoffVelTol);
    detailTable.row();
    Slider takeoffVelTol = new Slider(0.01f, 1f, 0.01f, false, container.skin);
    takeoffVelTol.setValue(jumpSB.getTakeoffVelocityTolerance());
    takeoffVelTol.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            jumpSB.setTakeoffVelocityTolerance(slider.getValue());
            labelTakeoffVelTol.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(takeoffVelTol);
    detailTable.row();
    final Label labelMaxVertVel = new Label("String_Node_Str" + jumpSB.getMaxVerticalVelocity() + "String_Node_Str", container.skin);
    detailTable.add(labelMaxVertVel);
    detailTable.row();
    Slider maxVertVel = new Slider(1f, 15f, 0.5f, false, container.skin);
    maxVertVel.setValue(jumpSB.getMaxVerticalVelocity());
    maxVertVel.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            Slider slider = (Slider) actor;
            jumpSB.setMaxVerticalVelocity(slider.getValue());
            labelMaxVertVel.setText("String_Node_Str" + slider.getValue() + "String_Node_Str");
        }
    });
    detailTable.add(maxVertVel);
    detailTable.row();
    addSeparator(detailTable);
    detailTable.row();
    final Label labelJumpVel = new Label("String_Node_Str", container.skin);
    detailTable.add(labelJumpVel);
    detailTable.row();
    SelectBox<String> jumpVel = new SelectBox<String>(container.skin);
    jumpVel.setItems(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" });
    jumpVel.setSelectedIndex(0);
    jumpVel.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            SelectBox<String> selectBox = (SelectBox<String>) actor;
            airbornePlanarVelocityToUse = selectBox.getSelectedIndex();
        }
    });
    detailTable.add(jumpVel);
    detailTable.row();
    addSeparator(detailTable);
    detailTable.row();
    addMaxLinearAccelerationController(detailTable, character);
    detailTable.row();
    addMaxLinearSpeedController(detailTable, character);
    detailTable.row();
    addSeparator(detailTable);
    detailTable.row();
    Button buttonRestart = new TextButton("String_Node_Str", container.skin);
    buttonRestart.addListener(new ChangeListener() {
        public void changed(ChangeEvent event, Actor actor) {
            restart();
        }
    });
    detailTable.add(buttonRestart);
    detailWindow = createDetailWindow(detailTable);
}

Output:
     character.setMaxLinearSpeed(4);
-    character.setMaxLinearAcceleration(200);
+    character.setMaxLinearAcceleration(40);
     Vector2 takeoffPoint = new Vector2(leftPlatform.getPosition()).add(Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_WIDTH - 20), Box2dSteeringTest.pixelsToMeters(PLATFORM_HALF_HEIGHT) + character.getBoundingRadius());


Input:
public void testAudio() {
    clearDirectory();
    LimeXMLReplyCollection collection = new LimeXMLReplyCollection(files, schemaURI, mfm, audio);
    Assert.assertTrue("String_Node_Str" + collection.getCount(), (collection.getCount() == 2));
    LimeXMLDocument doc = null;
    doc = collection.getDocForHash(mfm.readFromMap(mason));
    Assert.assertTrue("String_Node_Str", doc == null);
    doc = collection.getDocForHash(mfm.readFromMap(vader));
    Assert.assertTrue("String_Node_Str", doc != null);
    doc = collection.getDocForHash(mfm.readFromMap(swing));
    Assert.assertTrue("String_Node_Str", doc != null);
    List keywords = collection.getKeyWords();
    Assert.assertTrue("String_Node_Str" + keywords.size(), (keywords.size() == 4));
    Assert.assertTrue("String_Node_Str", (keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str")));
}

Output:
     List keywords = collection.getKeyWords();
-    Assert.assertTrue("String_Node_Str" + keywords.size(), (keywords.size() == 4));
-    Assert.assertTrue("String_Node_Str", (keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str")));
+    Assert.assertTrue("String_Node_Str" + keywords.size(), (keywords.size() == 6));
+    Assert.assertTrue("String_Node_Str", (keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str") && keywords.contains("String_Node_Str")));
 }


Input:
public static void main(String[] args) throws Exception {
    org.apache.log4j.Logger.getRootLogger().addAppender(new ConsoleAppender(new SimpleLayout()));
    org.apache.log4j.Logger.getRootLogger().setLevel(Level.INFO);
    org.apache.log4j.Logger.getLogger(DataPropertyDomainAxiomLearner.class).setLevel(Level.INFO);
    SparqlEndpointKS ks = new SparqlEndpointKS(SparqlEndpoint.getEndpointDBpediaLiveAKSW());
    SPARQLReasoner reasoner = new SPARQLReasoner(ks);
    reasoner.prepareSubsumptionHierarchy();
    ObjectPropertyDomainAxiomLearner l = new ObjectPropertyDomainAxiomLearner(ks);
    l.setReasoner(reasoner);
    l.setPropertyToDescribe(new ObjectProperty("String_Node_Str"));
    l.setMaxExecutionTimeInSeconds(10);
    l.addFilterNamespace("String_Node_Str");
    l.init();
    l.start();
    System.out.println(l.getCurrentlyBestEvaluatedAxioms(10, 0.75));
}

Output:
     l.setPropertyToDescribe(new ObjectProperty("String_Node_Str"));
-    l.setMaxExecutionTimeInSeconds(10);
+    l.setMaxExecutionTimeInSeconds(40);
     l.addFilterNamespace("String_Node_Str");


Input:
public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
    try {
        XMLDescriptor xmlDescriptor = null;
        boolean isPrimitiveType = false;
        Class primitiveWrapperClass = null;
        String type = null;
        if (xmlReader.isNamespaceAware()) {
            type = atts.getValue(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
        } else {
            type = atts.getValue(XMLConstants.EMPTY_STRING, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
        }
        if (null != type) {
            XPathFragment typeFragment = new XPathFragment(type, xmlReader.namespaceSeparator, xmlReader.isNamespaceAware());
            if (xmlReader.isNamespaceAware() && null != unmarshalNamespaceResolver) {
                typeFragment.setNamespaceURI(unmarshalNamespaceResolver.getNamespaceURI(typeFragment.getPrefix()));
            }
            xmlDescriptor = xmlContext.getDescriptorByGlobalType(typeFragment);
            if (xmlDescriptor == null) {
                primitiveWrapperClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(new QName(typeFragment.getNamespaceURI(), typeFragment.getLocalName()));
            }
        }
        if (xmlDescriptor == null) {
            String name;
            if (localName == null || localName.length() == 0) {
                name = qName;
            } else {
                name = localName;
            }
            XPathQName rootQName;
            if (namespaceURI == null || namespaceURI.length() == 0) {
                rootQName = new XPathQName(name, xmlReader.isNamespaceAware());
            } else {
                rootQName = new XPathQName(namespaceURI, name, xmlReader.isNamespaceAware());
            }
            xmlDescriptor = xmlContext.getDescriptor(rootQName);
            if (null == xmlDescriptor) {
                Object obj = this.xmlReader.getCurrentObject(session, null);
                if (obj != null) {
                    xmlDescriptor = (XMLDescriptor) xmlContext.getSession(obj.getClass()).getDescriptor(obj.getClass());
                }
                if (xmlDescriptor == null) {
                    isPrimitiveType = primitiveWrapperClass != null;
                }
            }
            if (null == xmlDescriptor && !isPrimitiveType) {
                if (this.keepAsElementPolicy != UnmarshalKeepAsElementPolicy.KEEP_NONE_AS_ELEMENT) {
                    this.documentBuilder = new SAXDocumentBuilder();
                    documentBuilder.startDocument();
                    for (String prefix : this.unmarshalNamespaceResolver.getPrefixes()) {
                        documentBuilder.startPrefixMapping(prefix, this.unmarshalNamespaceResolver.getNamespaceURI(prefix));
                    }
                    documentBuilder.startElement(namespaceURI, localName, qName, atts);
                    this.xmlReader.setContentHandler(documentBuilder);
                    return;
                }
                Class unmappedContentHandlerClass = unmarshaller.getUnmappedContentHandlerClass();
                if (null == unmappedContentHandlerClass) {
                    throw XMLMarshalException.noDescriptorWithMatchingRootElement(rootQName.toString());
                } else {
                    UnmappedContentHandler unmappedContentHandler;
                    try {
                        PrivilegedNewInstanceFromClass privilegedNewInstanceFromClass = new PrivilegedNewInstanceFromClass(unmappedContentHandlerClass);
                        unmappedContentHandler = (UnmappedContentHandler) privilegedNewInstanceFromClass.run();
                    } catch (ClassCastException e) {
                        throw XMLMarshalException.unmappedContentHandlerDoesntImplement(e, unmappedContentHandlerClass.getName());
                    } catch (IllegalAccessException e) {
                        throw XMLMarshalException.errorInstantiatingUnmappedContentHandler(e, unmappedContentHandlerClass.getName());
                    } catch (InstantiationException e) {
                        throw XMLMarshalException.errorInstantiatingUnmappedContentHandler(e, unmappedContentHandlerClass.getName());
                    }
                    UnmappedContentHandlerWrapper unmappedContentHandlerWrapper = new UnmappedContentHandlerWrapper(unmappedContentHandler, this);
                    unmappedContentHandler.setUnmarshalRecord(unmappedContentHandlerWrapper);
                    unmappedContentHandler.startElement(namespaceURI, localName, qName, atts);
                    xmlReader.setContentHandler(unmappedContentHandler);
                    setObject(unmappedContentHandlerWrapper.getCurrentObject());
                    return;
                }
            }
        }
        session = xmlContext.getReadSession(xmlDescriptor);
        UnmarshalRecord unmarshalRecord;
        if (isPrimitiveType) {
            unmarshalRecord = new XMLRootRecord(primitiveWrapperClass);
            unmarshalRecord.setSession((AbstractSession) unmarshaller.getXMLContext().getSession(0));
            unmarshalRecord.setXMLReader(this.getXMLReader());
        } else if (xmlDescriptor.hasInheritance()) {
            unmarshalRecord = new UnmarshalRecord(null);
            unmarshalRecord.setUnmarshaller(unmarshaller);
            unmarshalRecord.setUnmarshalNamespaceResolver(unmarshalNamespaceResolver);
            unmarshalRecord.setXMLReader(this.getXMLReader());
            unmarshalRecord.setAttributes(atts);
            Class classValue = xmlDescriptor.getInheritancePolicy().classFromRow(unmarshalRecord, session);
            if (classValue == null) {
                QName leafElementType = xmlDescriptor.getDefaultRootElementType();
                if (leafElementType != null) {
                    Object indicator = xmlDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(leafElementType);
                    if (indicator != null) {
                        classValue = (Class) indicator;
                    }
                }
            }
            if (classValue != null) {
                xmlDescriptor = (XMLDescriptor) session.getDescriptor(classValue);
            } else {
                if (Modifier.isAbstract(xmlDescriptor.getJavaClass().getModifiers())) {
                    throw DescriptorException.missingClassIndicatorField(unmarshalRecord, xmlDescriptor.getInheritancePolicy().getDescriptor());
                }
            }
            unmarshalRecord = (UnmarshalRecord) xmlDescriptor.getObjectBuilder().createRecord(session);
        } else {
            unmarshalRecord = (UnmarshalRecord) xmlDescriptor.getObjectBuilder().createRecord(session);
            unmarshalRecord.setXMLReader(this.getXMLReader());
        }
        this.descriptor = xmlDescriptor;
        this.rootRecord = unmarshalRecord;
        if (locator != null) {
            unmarshalRecord.setDocumentLocator(locator);
        }
        unmarshalRecord.setUnmarshaller(this.unmarshaller);
        unmarshalRecord.setXMLReader(this.getXMLReader());
        unmarshalRecord.setAttributes(atts);
        if (atts != null && null != atts.getValue(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_NIL_ATTRIBUTE)) {
            unmarshalRecord.setNil(true);
        }
        unmarshalRecord.setUnmarshalNamespaceResolver(unmarshalNamespaceResolver);
        unmarshalRecord.startDocument();
        unmarshalRecord.initializeRecord(null);
        xmlReader.setContentHandler(unmarshalRecord);
        xmlReader.setLexicalHandler(unmarshalRecord);
        unmarshalRecord.startElement(namespaceURI, localName, qName, atts);
    } catch (EclipseLinkException e) {
        if (null == xmlReader.getErrorHandler()) {
            throw e;
        } else {
            SAXParseException saxParseException = new SAXParseException(null, null, null, 0, 0, e);
            xmlReader.getErrorHandler().error(saxParseException);
        }
    }
}

Output:
             if (xmlDescriptor == null) {
-                primitiveWrapperClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(new QName(typeFragment.getNamespaceURI(), typeFragment.getLocalName()));
+                QName lookupQName = null;
+                if (typeFragment.getNamespaceURI() == null) {
+                    lookupQName = new QName(XMLConstants.SCHEMA_URL, typeFragment.getLocalName());
+                } else {
+                    lookupQName = new QName(typeFragment.getNamespaceURI(), typeFragment.getLocalName());
+                }
+                primitiveWrapperClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(lookupQName);
             }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_shuffle);
    desk = (ShuffleDesk) findViewById(R.id.shuffle_desk);
    desk.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
        public void onGlobalLayout() {
            desk.getViewTreeObserver().removeGlobalOnLayoutListener(this);
            initView();
        }
    });
    netTask = new LoaderFromNetTask();
    netTask.executeOnExecutor(android.os.AsyncTask.THREAD_POOL_EXECUTOR);
}

Output:
     });
-    netTask = new LoaderFromNetTask();
-    netTask.executeOnExecutor(android.os.AsyncTask.THREAD_POOL_EXECUTOR);
+    dbTask = new LoaderFromDBTask();
+    dbTask.executeOnExecutor(android.os.AsyncTask.THREAD_POOL_EXECUTOR);
 }


Input:
protected void performChanges(final UpdateMonthlyReports cmd, Map<Month, ReportingPeriod> periods, Site site) {
    for (UpdateMonthlyReports.Change change : cmd.getChanges()) {
        ReportingPeriod period = periods.get(change.month);
        if (period == null) {
            period = new ReportingPeriod(site);
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.YEAR, change.month.getYear());
            calendar.set(Calendar.MONTH, change.month.getMonth() - 1);
            calendar.set(Calendar.DATE, 5);
            period.setDate1(calendar.getTime());
            calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE) - 5);
            period.setDate2(calendar.getTime());
            em().persist(period);
            periods.put(change.month, period);
        } else {
            boolean wasValid = ReportingPeriodValidation.validate(period);
            if (!wasValid) {
                em().merge(period);
            }
        }
        updateIndicatorValue(em(), period, change.indicatorId, change.value, false);
    }
}

Output:
             period = new ReportingPeriod(site);
-            Calendar calendar = Calendar.getInstance();
+            final Calendar calendar = Calendar.getInstance();
+            calendar.clear();
             calendar.set(Calendar.YEAR, change.month.getYear());


Input:
public boolean acceptsURL(String url) throws SQLException {
    return url != null && url.toLowerCase().startsWith(Url.SIMON_JDBC);
}

Output:
 public boolean acceptsURL(String url) throws SQLException {
-    return url != null && url.toLowerCase().startsWith(Url.SIMON_JDBC);
+    return SimonConnectionConfiguration.isSimonUrl(url);
 }


Input:
public E take(final long waitMillis) {
    try {
        lock.lockInterruptibly();
        if (waitMillis < 0)
            added.await();
        else
            added.await(waitMillis, TimeUnit.MILLISECONDS);
        return take();
    } catch (final InterruptedException e) {
        LOG.error(e.getMessage(), e);
    } finally {
        lock.unlock();
    }
    return null;
}

Output:
         lock.lockInterruptibly();
-        if (waitMillis < 0)
-            added.await();
-        else
-            added.await(waitMillis, TimeUnit.MILLISECONDS);
-        return take();
+        E elem = take();
+        if (elem == null) {
+            if (waitMillis < 0)
+                added.await();
+            else
+                added.await(waitMillis, TimeUnit.MILLISECONDS);
+            elem = take();
+        }
+        return elem;
     } catch (final InterruptedException e) {


Input:
public INDArray broadcast(int... shape) {
    if (Shape.shapeEquals(shape, shape()))
        return this;
    boolean compatible = true;
    int count = shape.length - 1;
    int thisCount = Shape.rank(shapeInformation.asNioInt()) - 1;
    for (int i = shape.length - 1; i > 0; i--) {
        if (count < 0 || thisCount < 0)
            break;
        if (shape[count] != shape()[thisCount] && shape[count] != 1 && shape()[thisCount] != 1) {
            compatible = false;
            break;
        }
        count--;
        thisCount--;
    }
    if (!compatible)
        throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(shape()) + "String_Node_Str" + Arrays.toString(shape));
    int[] retShape = new int[shape.length];
    List<Integer> broadCastDimensions = new ArrayList<>();
    List<Integer> nonBroadCastDimensions = new ArrayList<>();
    for (int i = 0; i < retShape.length; i++) {
        if (shape().length == 1) {
            if (i == 0) {
                if (i < shape().length)
                    retShape[i] = Math.max(1, shape[i]);
                else
                    retShape[i] = shape[i];
            } else {
                if (i < shape().length)
                    retShape[i] = Math.max(shape[i], size(i));
                else
                    retShape[i] = shape[i];
            }
        } else {
            if (i < rank() && size(i) == 1)
                broadCastDimensions.add(i);
            else
                nonBroadCastDimensions.add(i);
            if (i < shape().length)
                retShape[i] = Math.max(shape[i], size(i));
            else
                retShape[i] = shape[i];
        }
    }
    INDArray ret = create(retShape, ordering());
    if (isRowVector()) {
        for (int i = 0; i < ret.slices(); i++) {
            ret.putSlice(i, this);
        }
    } else {
        int repeatDelta = ArrayUtil.prod(retShape) / length();
        for (int i = 0; i < slices(); i++) {
            INDArray thisTensor = slice(i);
            INDArray retTensor = ret.slice(i);
            int retIdx = 0;
            int tensorLen = thisTensor.rank();
            outer: for (int k = 0; k < tensorLen; k++) {
                for (int j = 0; j < repeatDelta; j++) {
                    if (retIdx >= retTensor.length())
                        break outer;
                    retTensor.putScalar(retIdx++, thisTensor.getDouble(k));
                }
            }
        }
    }
    return ret;
}

Output:
     int count = shape.length - 1;
-    int thisCount = Shape.rank(shapeInformation.asNioInt()) - 1;
+    int thisCount = Shape.rank(shapeInformation) - 1;
     for (int i = shape.length - 1; i > 0; i--) {


Input:
public static Set<BapiInterceptor> createBapiInterceptors(SessionManagerConfig sessionManagerConfig) {
    final Set<String> classNames = sessionManagerConfig.getBapiInterceptorClasses();
    final Set<BapiInterceptor> bapiInterceptors = new HashSet<BapiInterceptor>();
    bapiInterceptors.addAll(createInstances(classNames, BapiInterceptor.class));
    activateBeanValidation(bapiInterceptors, sessionManagerConfig);
    return bapiInterceptors;
}

Output:
 public static Set<BapiInterceptor> createBapiInterceptors(SessionManagerConfig sessionManagerConfig) {
-    final Set<String> classNames = sessionManagerConfig.getBapiInterceptorClasses();
+    final List<String> classNames = sessionManagerConfig.getBapiInterceptorClasses();
     final Set<BapiInterceptor> bapiInterceptors = new HashSet<BapiInterceptor>();


Input:
private void processType(TypeElement type) {
    AutoValue autoValue = type.getAnnotation(AutoValue.class);
    if (autoValue == null) {
        errorReporter.abortWithError("String_Node_Str" + "String_Node_Str", type);
    }
    if (type.getKind() != ElementKind.CLASS) {
        errorReporter.abortWithError("String_Node_Str" + AutoValue.class.getName() + "String_Node_Str", type);
    }
    if (ancestorIsAutoValue(type)) {
        errorReporter.abortWithError("String_Node_Str", type);
    }
    if (implementsAnnotation(type)) {
        errorReporter.abortWithError("String_Node_Str" + "String_Node_Str", type);
    }
    checkModifiersIfNested(type);
    ImmutableSet<ExecutableElement> methods = getLocalAndInheritedMethods(type, processingEnv.getTypeUtils(), processingEnv.getElementUtils());
    ImmutableSet<ExecutableElement> abstractMethods = abstractMethodsIn(methods);
    BuilderSpec builderSpec = new BuilderSpec(type, processingEnv, errorReporter);
    Optional<BuilderSpec.Builder> builder = builderSpec.getBuilder();
    ImmutableSet<ExecutableElement> toBuilderMethods;
    if (builder.isPresent()) {
        toBuilderMethods = builder.get().toBuilderMethods(typeUtils, abstractMethods);
    } else {
        toBuilderMethods = ImmutableSet.of();
    }
    ImmutableSet<ExecutableElement> propertyMethods = propertyMethodsIn(immutableSetDifference(abstractMethods, toBuilderMethods));
    ImmutableBiMap<String, ExecutableElement> properties = propertyNameToMethodMap(propertyMethods);
    ExtensionContext context = new ExtensionContext(processingEnv, type, properties, abstractMethods);
    ImmutableList<AutoValueExtension> applicableExtensions = applicableExtensions(type, context);
    ImmutableSet<ExecutableElement> consumedMethods = methodsConsumedByExtensions(type, applicableExtensions, context, abstractMethods, properties);
    if (!consumedMethods.isEmpty()) {
        ImmutableSet<ExecutableElement> allAbstractMethods = abstractMethods;
        abstractMethods = immutableSetDifference(abstractMethods, consumedMethods);
        toBuilderMethods = immutableSetDifference(toBuilderMethods, consumedMethods);
        propertyMethods = propertyMethodsIn(immutableSetDifference(abstractMethods, toBuilderMethods));
        properties = propertyNameToMethodMap(propertyMethods);
        context = new ExtensionContext(processingEnv, type, properties, allAbstractMethods);
    }
    boolean extensionsPresent = !applicableExtensions.isEmpty();
    validateMethods(type, abstractMethods, toBuilderMethods, propertyMethods, extensionsPresent);
    String finalSubclass = generatedSubclassName(type, 0);
    AutoValueTemplateVars vars = new AutoValueTemplateVars();
    vars.pkg = TypeSimplifier.packageNameOf(type);
    vars.origClass = TypeSimplifier.classNameOf(type);
    vars.simpleClassName = TypeSimplifier.simpleNameOf(vars.origClass);
    vars.finalSubclass = TypeSimplifier.simpleNameOf(finalSubclass);
    vars.isFinal = applicableExtensions.isEmpty();
    vars.types = processingEnv.getTypeUtils();
    determineObjectMethodsToGenerate(methods, vars);
    TypeSimplifier typeSimplifier = defineVarsForType(type, vars, toBuilderMethods, propertyMethods, builder);
    if (isAnnotationPresent(type, AutoValue.CopyAnnotations.class)) {
        Set<String> excludedAnnotations = union(getFieldOfClasses(type, AutoValue.CopyAnnotations.class, "String_Node_Str", processingEnv.getElementUtils()), getAnnotationsMarkedWithInherited(type));
        vars.annotations = copyAnnotations(type, typeSimplifier, excludedAnnotations);
    } else {
        vars.annotations = ImmutableList.of();
    }
    GwtCompatibility gwtCompatibility = new GwtCompatibility(type);
    vars.gwtCompatibleAnnotation = gwtCompatibility.gwtCompatibleAnnotationString();
    String subclass = writeExtensions(type, context, applicableExtensions);
    vars.subclass = TypeSimplifier.simpleNameOf(subclass);
    String text = vars.toText();
    text = Reformatter.fixup(text);
    writeSourceFile(subclass, text, type);
    GwtSerialization gwtSerialization = new GwtSerialization(gwtCompatibility, processingEnv, type);
    gwtSerialization.maybeWriteGwtSerializer(vars);
}

Output:
     vars.gwtCompatibleAnnotation = gwtCompatibility.gwtCompatibleAnnotationString();
-    String subclass = writeExtensions(type, context, applicableExtensions);
+    int subclassDepth = writeExtensions(type, context, applicableExtensions);
+    String subclass = generatedSubclassName(type, subclassDepth);
     vars.subclass = TypeSimplifier.simpleNameOf(subclass);


Input:
void updateLayout() throws LayoutException {
    int[] sectionSize = new int[components.size()];
    for (int i = 0; i < components.size(); i++) {
        sectionSize[i] = components.get(i).getMinSize();
    }
    int sizeNeeded = 0;
    for (int i = 0; i < components.size(); i++) {
        Component.Instance component = components.get(i);
        if (component.isBlockAligned()) {
            sizeNeeded = ((sizeNeeded + context.get(Context.KEY_COLUMNS) - 1) / context.get(Context.KEY_COLUMNS)) * context.get(Context.KEY_COLUMNS);
        }
        sizeNeeded += sectionSize[i];
    }
    if (sizeNeeded > size) {
        throw new LayoutException(String.format("String_Node_Str", sizeNeeded, size));
    }
    boolean repeat;
    boolean max = false;
    do {
        repeat = false;
        for (int i = 0; i < components.size(); i++) {
            Component.Instance component = components.get(i);
            int oldSectionSize = sectionSize[i];
            if (oldSectionSize >= (max ? component.getMaxSize() : component.getPreferredSize())) {
                continue;
            }
            sectionSize[i] += component.isBlockAligned() ? context.get(Context.KEY_COLUMNS) : 1;
            sizeNeeded = 0;
            for (int j = 0; j < components.size(); j++) {
                Component.Instance component1 = components.get(j);
                if (component1.isBlockAligned()) {
                    sizeNeeded = ((sizeNeeded + context.get(Context.KEY_COLUMNS) - 1) / context.get(Context.KEY_COLUMNS)) * context.get(Context.KEY_COLUMNS);
                }
                sizeNeeded += sectionSize[j];
            }
            if (sizeNeeded <= size) {
                repeat = true;
            } else {
                sectionSize[i] = oldSectionSize;
            }
        }
        if (!repeat && !max) {
            max = true;
            repeat = true;
        }
    } while (repeat);
    int pos = 0;
    for (int i = 0; i < components.size(); i++) {
        Component.Instance component = components.get(i);
        if (component.isBlockAligned()) {
            pos = ((pos + context.get(Context.KEY_COLUMNS) - 1) / context.get(Context.KEY_COLUMNS)) * context.get(Context.KEY_COLUMNS);
        }
        component.setPosition(row + (pos / context.get(Context.KEY_COLUMNS)), column + (pos % context.get(Context.KEY_COLUMNS)), sectionSize[i]);
        pos += sectionSize[i];
    }
}

Output:
         }
-        component.setPosition(row + (pos / context.get(Context.KEY_COLUMNS)), column + (pos % context.get(Context.KEY_COLUMNS)), sectionSize[i]);
+        component.setPosition(leftMostColumn, row + (pos / context.get(Context.KEY_COLUMNS)), column + (pos % context.get(Context.KEY_COLUMNS)), sectionSize[i]);
         pos += sectionSize[i];


Input:
public boolean updatePathPoints() {
    float distance = mPathWidth / 2;
    float dx = 0, dy = 0;
    PointF leftTop, leftBottom, rightBottom, rightTop;
    PointF direction = new PointF(mEndX - mStartX, mEndY - mStartY);
    direction.x = direction.x / direction.length();
    direction.y = direction.y / direction.length();
    PointF directionV = new PointF(direction.y, -direction.x);
    dx = distance * directionV.x;
    dy = distance * directionV.y;
    leftTop = new PointF(mEndX + dx, mEndY + dy);
    rightTop = new PointF(mEndX - dx, mEndY - dy);
    leftBottom = new PointF(mStartX + dx, mStartY + dy);
    rightBottom = new PointF(mStartX - dx, mStartY - dy);
    mPoints[0] = leftTop;
    mPoints[1] = rightTop;
    mPoints[2] = rightBottom;
    mPoints[3] = leftBottom;
    return true;
}

Output:
     PointF directionV = new PointF(direction.y, -direction.x);
-    dx = distance * directionV.x;
-    dy = distance * directionV.y;
-    leftTop = new PointF(mEndX + dx, mEndY + dy);
-    rightTop = new PointF(mEndX - dx, mEndY - dy);
-    leftBottom = new PointF(mStartX + dx, mStartY + dy);
-    rightBottom = new PointF(mStartX - dx, mStartY - dy);
+    float dx = distance * directionV.x;
+    float dy = distance * directionV.y;
+    PointF leftTop = new PointF(mEndX + dx, mEndY + dy);
+    PointF rightTop = new PointF(mEndX - dx, mEndY - dy);
+    PointF leftBottom = new PointF(mStartX + dx, mStartY + dy);
+    PointF rightBottom = new PointF(mStartX - dx, mStartY - dy);
     mPoints[0] = leftTop;


Input:
public static void cleanUp() throws OseeCoreException {
    Operations.executeWorkAndCheckStatus(new PurgeBranchHttpRequestOperation(topLevel, true));
}

Output:
 public static void cleanUp() throws OseeCoreException {
-    Operations.executeWorkAndCheckStatus(new PurgeBranchHttpRequestOperation(topLevel, true));
+    try {
+        OseeEventManager.getPreferences().setPendRunning(true);
+        Operations.executeWorkAndCheckStatus(new PurgeBranchHttpRequestOperation(topLevel, true));
+    } finally {
+        OseeEventManager.getPreferences().setPendRunning(false);
+    }
 }


Input:
public static void newMIDIUtilPlay(Network cppn) throws InvalidMidiDataException, IOException {
    File midiFile = new File(CLASSICAL_MID);
    Sequence sequence = MidiSystem.getSequence(midiFile);
    Track[] tracks = sequence.getTracks();
    ArrayList<Triple<ArrayList<Double>, ArrayList<Long>, ArrayList<Long>>> midiLists = MIDIUtil.soundLines(tracks);
    double[] amplitudes = MIDIUtil.lineToAmplitudeArray(CLASSICAL_MID, midiLists, cppn, 1);
    PlayDoubleArray.playDoubleArray(amplitudes);
}

Output:
 public static void newMIDIUtilPlay(Network cppn) throws InvalidMidiDataException, IOException {
-    File midiFile = new File(CLASSICAL_MID);
+    File midiFile = new File(SOLO_PIANO_MID);
     Sequence sequence = MidiSystem.getSequence(midiFile);


Input:
protected void handlePickingEvents(EPickingType ePickingType, EPickingMode pickingMode, int iExternalID, Pick pick) {
    if (detailLevel == EDetailLevel.VERY_LOW) {
        return;
    }
    ESelectionType eSelectionType;
    switch(ePickingType) {
        case SCATTER_POINT_SELECTION:
            iCurrentMouseOverElement = iExternalID;
            switch(pickingMode) {
                case CLICKED:
                    eSelectionType = ESelectionType.SELECTION;
                    break;
                case MOUSE_OVER:
                    eSelectionType = ESelectionType.MOUSE_OVER;
                    elementSelectionManager.clearSelection(eSelectionType);
                    break;
                case RIGHT_CLICKED:
                    eSelectionType = ESelectionType.SELECTION;
                default:
                    return;
            }
            createContentSelection(eSelectionType, iExternalID);
            break;
    }
}

Output:
                 case RIGHT_CLICKED:
-                    eSelectionType = ESelectionType.SELECTION;
+                    eSelectionType = ESelectionType.DESELECTED;
+                    break;
                 default:


Input:
private boolean check_context_slot_decisions(int level) {
    if (DEBUG_CONSISTENCY_CHECK) {
        if (tempMemory.highest_goal_whose_context_changed != null)
            context.getPrinter().print("String_Node_Str", tempMemory.highest_goal_whose_context_changed);
    }
    for (IdentifierImpl goal = tempMemory.highest_goal_whose_context_changed; goal != null && goal.level <= level; goal = goal.lower_goal) {
        if (DEBUG_CONSISTENCY_CHECK) {
            context.getPrinter().print("String_Node_Str", goal);
        }
        Slot s = goal.operator_slot;
        if ((goal.lower_goal != null) || (s.getWmes() != null)) {
            if (DEBUG_CONSISTENCY_CHECK) {
                context.getPrinter().print("String_Node_Str");
            }
            if (s.changed != null) {
                if (DEBUG_CONSISTENCY_CHECK) {
                    context.getPrinter().print("String_Node_Str");
                }
                if (!decision_consistent_with_current_preferences(goal, s)) {
                    if (DEBUG_CONSISTENCY_CHECK) {
                        context.getPrinter().print("String_Node_Str", goal);
                    }
                    if (context.getTrace().isEnabled(Category.VERBOSE) || context.getTrace().isEnabled(Category.WM_CHANGES))
                        context.getTrace().print("String_Node_Str", goal);
                    remove_current_decision(s);
                    return false;
                }
            }
        }
    }
    return true;
}

Output:
                     }
-                    if (context.getTrace().isEnabled(Category.VERBOSE) || context.getTrace().isEnabled(Category.WM_CHANGES))
-                        context.getTrace().print("String_Node_Str", goal);
+                    context.getTrace().print(EnumSet.of(Category.VERBOSE, Category.WM_CHANGES), "String_Node_Str", goal);
                     remove_current_decision(s);


Input:
public static File findPlayersDir(File worldDir) {
    if (worldDir == null)
        return null;
    return new File(worldDir, "String_Node_Str");
}

Output:
         return null;
-    return new File(worldDir, "String_Node_Str");
+    File oldDir = new File(worldDir, "String_Node_Str");
+    if (oldDir.exists())
+        return oldDir;
+    else
+        return new File(worldDir, "String_Node_Str");
 }


Input:
public static ExcitationSourceList updateReferences(ModelComponent host, ExcitationSourceList sources, boolean undo, Deque<Object> undoInfo) {
    if (undo) {
        Object obj = undoInfo.removeFirst();
        if (obj != ModelComponentBase.NULL_OBJ) {
            ListRemove<ExcitationSource> remove = (ListRemove<ExcitationSource>) obj;
            if (sources == null) {
                sources = (ExcitationSourceList) remove.getList();
            }
            remove.undo();
        }
    } else if (sources != null) {
        ListRemove<ExcitationSource> remove = null;
        for (int i = 0; i < sources.size(); i++) {
            if (!ComponentUtils.isConnected(host, sources.get(i).myComp)) {
                if (remove == null) {
                    remove = new ListRemove<ExcitationSource>(sources);
                }
                remove.requestRemove(i);
            }
        }
        if (remove != null) {
            remove.remove();
            if (sources.size() == 0) {
                sources = null;
            }
            undoInfo.addLast(remove);
        } else {
            undoInfo.addLast(ModelComponentBase.NULL_OBJ);
        }
    }
    return sources;
}

Output:
         }
-    } else if (sources != null) {
+    } else {
         ListRemove<ExcitationSource> remove = null;


Input:
public void parse(IParserManager pm, IToken token) throws SyntaxError {
    int type = token.type();
    if (this.mode == 0) {
        if (this.value != null) {
            this.field.setValue(this.value);
        }
        pm.popParser(true);
        return;
    }
    switch(type) {
        case Symbols.SEMICOLON:
        case Symbols.COMMA:
        case Tokens.STRING_PART:
        case Tokens.STRING_END:
            if (this.value != null) {
                this.field.setValue(this.value);
            }
            pm.popParser(true);
            return;
    }
    switch(this.mode) {
        case VALUE:
            if (type == Symbols.OPEN_PARENTHESIS) {
                IToken next = token.next();
                if (next.type() == Symbols.CLOSE_PARENTHESIS) {
                    if (next.next().type() == Symbols.ARROW_OPERATOR) {
                        LambdaExpression le = new LambdaExpression(next.next().raw());
                        this.value = le;
                        pm.skip(2);
                        pm.pushParser(pm.newExpressionParser(le));
                        this.mode = ACCESS;
                        return;
                    }
                    this.value = new VoidValue(token.to(token.next()));
                    pm.skip();
                    this.mode = 0;
                    return;
                }
                pm.pushParser(new LambdaOrTupleParser(this), true);
                this.mode = ACCESS;
                return;
            }
            if (type == Symbols.OPEN_SQUARE_BRACKET) {
                this.mode = ARRAY_END;
                Array vl = new Array(token);
                this.value = vl;
                int nextType = token.next().type();
                if (nextType != Symbols.CLOSE_SQUARE_BRACKET) {
                    pm.pushParser(new ExpressionListParser(vl));
                }
                return;
            }
            if (type == Symbols.OPEN_CURLY_BRACKET) {
                this.mode = LIST_END;
                StatementList sl = new StatementList(token);
                this.value = sl;
                int nextType = token.next().type();
                if (nextType != Symbols.CLOSE_CURLY_BRACKET) {
                    pm.pushParser(new StatementListParser(sl));
                }
                return;
            }
            if (type == Tokens.SYMBOL_IDENTIFIER) {
                if (token.nameValue() == Name.at && token.next().type() == Symbols.OPEN_CURLY_BRACKET) {
                    Bytecode bc = new Bytecode(token);
                    pm.skip();
                    pm.pushParser(new BytecodeParser(bc));
                    this.mode = BYTECODE_END;
                    this.value = bc;
                    return;
                }
                this.getAccess(pm, token.nameValue(), token, type);
                return;
            }
            if (type == Symbols.ARROW_OPERATOR) {
                LambdaExpression le = new LambdaExpression(token.raw());
                this.value = le;
                this.mode = ACCESS;
                pm.pushParser(pm.newExpressionParser(le));
                return;
            }
            if (type == Symbols.COLON) {
                throw new SyntaxError(token, "String_Node_Str");
            }
            if ((type & Tokens.IDENTIFIER) != 0) {
                this.getAccess(pm, token.nameValue(), token, type);
                return;
            }
            if (this.parseKeyword(pm, token, type)) {
                return;
            }
            this.mode = ACCESS;
            pm.reparse();
            return;
        case PATTERN_IF:
            this.mode = PATTERN_END;
            if (type == Keywords.IF) {
                pm.pushParser(pm.newExpressionParser(this));
                return;
            }
        case PATTERN_END:
            if (type == Symbols.COLON) {
                this.mode = 0;
                if (token.next().type() != Keywords.CASE) {
                    pm.pushParser(pm.newExpressionParser((IValued) this.value));
                }
                return;
            }
            throw new SyntaxError(token, "String_Node_Str");
        case ARRAY_END:
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                this.mode = ACCESS;
                return;
            }
            this.field.setValue(this.value);
            pm.popParser();
            throw new SyntaxError(token, "String_Node_Str");
        case LIST_END:
            this.field.setValue(this.value);
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_CURLY_BRACKET) {
                if (token.next().type() == Symbols.DOT) {
                    this.mode = ACCESS_2;
                    this.dotless = false;
                    pm.skip();
                    return;
                }
                pm.popParser();
                return;
            }
            pm.popParser(true);
            throw new SyntaxError(token, "String_Node_Str");
        case PARAMETERS_END:
            this.mode = ACCESS;
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_PARENTHESIS) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case SUBSCRIPT_END:
            this.mode = ACCESS;
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case CONSTRUCTOR:
            {
                ConstructorCall cc = (ConstructorCall) this.value;
                if (type == Symbols.OPEN_CURLY_BRACKET) {
                    this.createBody(cc.toClassConstructor(), pm);
                    return;
                }
                if (type == Symbols.OPEN_PARENTHESIS) {
                    ArgumentList list = new ArgumentList();
                    cc.arguments = list;
                    pm.pushParser(new ExpressionListParser(list));
                    this.mode = CONSTRUCTOR_END;
                    return;
                }
                if (ParserUtil.isTerminator2(type)) {
                    this.mode = ACCESS;
                    pm.reparse();
                    return;
                }
                SingleArgument sa = new SingleArgument();
                cc.arguments = sa;
                pm.pushParser(pm.newExpressionParser(sa), true);
                this.mode = 0;
                return;
            }
        case CONSTRUCTOR_END:
            this.mode = ACCESS;
            if (token.next().type() == Symbols.OPEN_CURLY_BRACKET) {
                this.createBody(((ConstructorCall) this.value).toClassConstructor(), pm);
                return;
            }
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_PARENTHESIS) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case BYTECODE_END:
            this.field.setValue(this.value);
            pm.popParser();
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_CURLY_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case TYPE_ARGUMENTS_END:
            MethodCall mc = (MethodCall) this.value;
            IToken next = token.next();
            if (next.type() == Symbols.OPEN_PARENTHESIS) {
                pm.skip();
                mc.arguments = this.getArguments(pm, next.next());
            }
            this.mode = ACCESS;
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str");
    }
    if (type == Symbols.COLON) {
        this.mode = ACCESS;
        throw new SyntaxError(token, "String_Node_Str");
    }
    if (ParserUtil.isCloseBracket(type)) {
        if (this.value != null) {
            this.field.setValue(this.value);
        }
        pm.popParser(true);
        return;
    }
    if (this.mode == ACCESS) {
        if (type == Symbols.DOT) {
            this.mode = ACCESS_2;
            this.dotless = false;
            return;
        }
        this.dotless = true;
        this.mode = ACCESS_2;
        if (type == Keywords.ELSE) {
            this.field.setValue(this.value);
            pm.popParser(true);
            return;
        }
        if (type == Symbols.EQUALS) {
            this.getAssign(pm, token);
            return;
        }
        if (type == Keywords.AS) {
            CastOperator co = new CastOperator(token.raw(), this.value);
            pm.pushParser(pm.newTypeParser(co));
            this.value = co;
            return;
        }
        if (type == Keywords.IS) {
            InstanceOfOperator io = new InstanceOfOperator(token.raw(), this.value);
            pm.pushParser(pm.newTypeParser(io));
            this.value = io;
            return;
        }
        if (type == Keywords.MATCH) {
            MatchExpression me = new MatchExpression(token.raw(), this.value);
            pm.pushParser(new MatchExpressionParser(me));
            this.value = me;
            return;
        }
        if (type == Symbols.OPEN_SQUARE_BRACKET) {
            SubscriptGetter getter = new SubscriptGetter(token, this.value);
            this.value = getter;
            this.mode = SUBSCRIPT_END;
            pm.pushParser(new ExpressionListParser(getter.getArguments()));
            return;
        }
        if (type == Symbols.OPEN_PARENTHESIS) {
            IToken prev = token.prev();
            IToken next = token.next();
            IArguments args;
            args = this.getArguments(pm, next);
            int prevType = prev.type();
            if (ParserUtil.isIdentifier(prevType)) {
                MethodCall mc = new MethodCall(prev, null, prev.nameValue());
                mc.arguments = args;
                this.value = mc;
            } else if (prevType == Symbols.CLOSE_SQUARE_BRACKET) {
                AbstractCall mc;
                if (this.value.valueTag() == IValue.FIELD_ACCESS) {
                    mc = ((FieldAccess) this.value).toMethodCall(null);
                } else {
                    mc = (AbstractCall) this.value;
                }
                mc.arguments = args;
                this.value = mc;
            } else {
                ApplyMethodCall amc = new ApplyMethodCall(this.value.getPosition());
                amc.instance = this.value;
                amc.arguments = args;
                this.value = amc;
            }
            this.mode = PARAMETERS_END;
            return;
        }
    }
    if (this.mode == ACCESS_2) {
        if (ParserUtil.isIdentifier(type)) {
            Name name = token.nameValue();
            if (this.prefix) {
                this.field.setValue(this.value);
                pm.popParser(true);
                return;
            }
            if (this.dotless && this.operator != null) {
                Operator operator = pm.getOperator(name);
                int p;
                if (operator == null || (p = this.operator.precedence) > operator.precedence) {
                    this.field.setValue(this.value);
                    pm.popParser(true);
                    return;
                }
                if (p == operator.precedence) {
                    switch(operator.type) {
                        case Operator.INFIX_LEFT:
                            this.field.setValue(this.value);
                            pm.popParser(true);
                            return;
                        case Operator.INFIX_NONE:
                            throw new SyntaxError(token, "String_Node_Str" + name + "String_Node_Str");
                        case Operator.INFIX_RIGHT:
                    }
                }
            }
            this.getAccess(pm, name, token, type);
            return;
        }
        if (ParserUtil.isTerminator(type)) {
            this.field.setValue(this.value);
            pm.popParser(true);
            return;
        }
        if (type == Symbols.HASH || type == Symbols.COLON) {
            throw new SyntaxError(token, "String_Node_Str" + token);
        }
        IToken prev = token.prev();
        if (ParserUtil.isIdentifier(prev.type())) {
            this.value = null;
            pm.reparse();
            this.getAccess(pm, prev.nameValue(), prev, type);
            return;
        }
        if (this.value != null) {
            ApplyMethodCall call = new ApplyMethodCall(token.raw());
            call.instance = this.value;
            SingleArgument sa = new SingleArgument();
            call.arguments = sa;
            this.value = call;
            this.mode = 0;
            pm.pushParser(pm.newExpressionParser(sa), true);
            return;
        }
        throw new SyntaxError(token, "String_Node_Str" + token);
    }
    if (this.value != null) {
        this.value.expandPosition(token);
        this.field.setValue(this.value);
        pm.popParser(true);
        return;
    }
    throw new SyntaxError(token, "String_Node_Str" + token);
}

Output:
             Name name = token.nameValue();
-            if (this.prefix) {
-                this.field.setValue(this.value);
-                pm.popParser(true);
-                return;
-            }
-            if (this.dotless && this.operator != null) {
-                Operator operator = pm.getOperator(name);
-                int p;
-                if (operator == null || (p = this.operator.precedence) > operator.precedence) {
+            if (this.dotless) {
+                if (this.prefix) {
                     this.field.setValue(this.value);


Input:
private void getRates(String name, String params) {
    for (int i = 0; i < extensions.size(); i++) {
        IExtension extension = extensions.get(i);
        final IRateSource rs = extension.createRateSource(name + "String_Node_Str" + params);
        if (rs != null) {
            final String preferredFiatCurrency = rs.getPreferredFiatCurrency();
            final Set<String> fiatCurrencies = rs.getFiatCurrencies();
            final Set<String> cryptoCurrencies = rs.getCryptoCurrencies();
            System.out.println("String_Node_Str" + preferredFiatCurrency);
            System.out.println("String_Node_Str");
            for (String fiatCurrency : fiatCurrencies) {
                System.out.println("String_Node_Str" + fiatCurrency);
            }
            System.out.println("String_Node_Str");
            String selectedCryptoCurrency = null;
            for (String cryptoCurrency : cryptoCurrencies) {
                if (selectedCryptoCurrency == null) {
                    selectedCryptoCurrency = cryptoCurrency;
                }
                System.out.println("String_Node_Str" + cryptoCurrency);
            }
            final BigDecimal exchangeRateLast = rs.getExchangeRateLast(selectedCryptoCurrency, preferredFiatCurrency);
            if (exchangeRateLast != null) {
                System.out.println("String_Node_Str" + selectedCryptoCurrency + "String_Node_Str" + exchangeRateLast.stripTrailingZeros().toPlainString() + "String_Node_Str" + preferredFiatCurrency);
            } else {
                System.err.println("String_Node_Str");
            }
            if (rs instanceof IRateSourceAdvanced) {
                IRateSourceAdvanced rsa = (IRateSourceAdvanced) rs;
                for (String fiatCurrency : fiatCurrencies) {
                    System.out.println("String_Node_Str" + fiatCurrency);
                    final BigDecimal buyPrice = rsa.getExchangeRateForBuy(selectedCryptoCurrency, fiatCurrency);
                    if (buyPrice != null) {
                        System.out.println("String_Node_Str" + selectedCryptoCurrency + "String_Node_Str" + buyPrice.stripTrailingZeros().toPlainString() + "String_Node_Str" + fiatCurrency);
                    } else {
                        System.err.println("String_Node_Str");
                    }
                    final BigDecimal sellPrice = rsa.getExchangeRateForSell(selectedCryptoCurrency, fiatCurrency);
                    if (sellPrice != null) {
                        System.out.println("String_Node_Str" + selectedCryptoCurrency + "String_Node_Str" + sellPrice.stripTrailingZeros().toPlainString() + "String_Node_Str" + fiatCurrency);
                    } else {
                        System.err.println("String_Node_Str");
                    }
                }
            }
            return;
        }
    }
    System.err.println("String_Node_Str");
}

Output:
             System.out.println("String_Node_Str");
-            String selectedCryptoCurrency = null;
+            String selectedCryptoCurrency = params;
             for (String cryptoCurrency : cryptoCurrencies) {


Input:
private void finaliseBuildingSectionPanelWithoutStats(InstructorFeedbackResultsSectionPanel sectionPanel, String sectionWithoutResponses) {
    LinkedHashMap<String, Map<FeedbackQuestionAttributes, List<FeedbackResponseAttributes>>> emptyResponseMap = new LinkedHashMap<String, Map<FeedbackQuestionAttributes, List<FeedbackResponseAttributes>>>();
    Set<String> emptyTeamList = new LinkedHashSet<String>();
    finalizeBuildingSectionPanel(sectionPanel, sectionWithoutResponses, emptyResponseMap, emptyTeamList);
}

Output:
     LinkedHashMap<String, Map<FeedbackQuestionAttributes, List<FeedbackResponseAttributes>>> emptyResponseMap = new LinkedHashMap<String, Map<FeedbackQuestionAttributes, List<FeedbackResponseAttributes>>>();
-    Set<String> emptyTeamList = new LinkedHashSet<String>();
+    LinkedHashSet<String> emptyTeamList = new LinkedHashSet<String>();
     finalizeBuildingSectionPanel(sectionPanel, sectionWithoutResponses, emptyResponseMap, emptyTeamList);


Input:
public void handle(ProcessorManager processorManager, RoundEnvironment roundEnvironment) {
    for (BaseContainerHandler containerHandler : handlers) {
        containerHandler.handle(processorManager, roundEnvironment);
    }
    ContentProviderValidator validator = new ContentProviderValidator();
    Collection<ContentProviderDefinition> contentProviderDefinitions = providerMap.values();
    for (ContentProviderDefinition contentProviderDefinition : contentProviderDefinitions) {
        if (validator.validate(processorManager, contentProviderDefinition)) {
            WriterUtils.writeBaseDefinition(contentProviderDefinition, processorManager);
        }
    }
    List<DatabaseDefinition> databaseDefinitions = getDatabaseDefinitionMap();
    for (DatabaseDefinition databaseDefinition : databaseDefinitions) {
        try {
            JavaFile.builder(databaseDefinition.packageName, databaseDefinition.getTypeSpec()).build().writeTo(processorManager.getProcessingEnvironment().getFiler());
            Collection<ManyToManyDefinition> manyToManyDefinitions = databaseDefinition.manyToManyDefinitionMap.values();
            for (ManyToManyDefinition manyToMany : manyToManyDefinitions) {
                WriterUtils.writeBaseDefinition(manyToMany, processorManager);
            }
            Collection<TableDefinition> tableDefinitions = databaseDefinition.tableDefinitionMap.values();
            for (TableDefinition tableDefinition : tableDefinitions) {
                WriterUtils.writeBaseDefinition(tableDefinition, processorManager);
                tableDefinition.writePackageHelper(processorManager.getProcessingEnvironment());
            }
            tableDefinitions = databaseDefinition.tableDefinitionMap.values();
            for (TableDefinition tableDefinition : tableDefinitions) {
                tableDefinition.writeAdapter(processorManager.getProcessingEnvironment());
            }
            Collection<ModelContainerDefinition> modelContainerDefinitions = databaseDefinition.modelContainerDefinitionMap.values();
            for (ModelContainerDefinition modelContainerDefinition : modelContainerDefinitions) {
                WriterUtils.writeBaseDefinition(modelContainerDefinition, processorManager);
            }
            Collection<ModelViewDefinition> modelViewDefinitions = databaseDefinition.modelViewDefinitionMap.values();
            for (ModelViewDefinition modelViewDefinition : modelViewDefinitions) {
                WriterUtils.writeBaseDefinition(modelViewDefinition, processorManager);
                modelViewDefinition.writePackageHelper(processorManager.getProcessingEnvironment());
                modelViewDefinition.writeViewTable();
            }
            Collection<QueryModelDefinition> queryModelDefinitions = databaseDefinition.queryModelDefinitionMap.values();
            for (QueryModelDefinition queryModelDefinition : queryModelDefinitions) {
                WriterUtils.writeBaseDefinition(queryModelDefinition, processorManager);
                queryModelDefinition.writePackageHelper(processorManager.getProcessingEnvironment());
                queryModelDefinition.writeAdapter(processorManager.getProcessingEnvironment());
            }
        } catch (IOException e) {
        }
    }
    try {
        JavaFile.builder(ClassNames.FLOW_MANAGER_PACKAGE, new FlowManagerHolderDefinition(processorManager).getTypeSpec()).build().writeTo(processorManager.getProcessingEnvironment().getFiler());
    } catch (IOException e) {
    }
}

Output:
     }
-    try {
-        JavaFile.builder(ClassNames.FLOW_MANAGER_PACKAGE, new FlowManagerHolderDefinition(processorManager).getTypeSpec()).build().writeTo(processorManager.getProcessingEnvironment().getFiler());
-    } catch (IOException e) {
+    if (roundEnvironment.processingOver()) {
+        try {
+            JavaFile.builder(ClassNames.FLOW_MANAGER_PACKAGE, new FlowManagerHolderDefinition(processorManager).getTypeSpec()).build().writeTo(processorManager.getProcessingEnvironment().getFiler());
+        } catch (IOException e) {
+        }
     }


Input:
public void populate(PlotConfiguration settings) {
    cachedFlags = getSelectedDrawingFlags();
    settings.setPlotLineDraw(cachedFlags);
    cachedConnectionType = getSelectedConnectionType();
    settings.setPlotLineConnectionType(cachedConnectionType);
}

Output:
 public void populate(PlotConfiguration settings) {
-    cachedFlags = getSelectedDrawingFlags();
-    settings.setPlotLineDraw(cachedFlags);
-    cachedConnectionType = getSelectedConnectionType();
-    settings.setPlotLineConnectionType(cachedConnectionType);
+    settings.setPlotLineDraw(getSelectedDrawingFlags());
+    settings.setPlotLineConnectionType(getSelectedConnectionType());
 }


Input:
private void linkProxies() {
    for (int y = 0; y < blueprint.ySize; y++) {
        for (int x = 0; x < blueprint.xSize; x++) {
            for (int z = 0; z < blueprint.zSize; z++) {
                linkProxy(x, y, z);
            }
        }
    }
}

Output:
     for (int y = 0; y < blueprint.ySize; y++) {
-        for (int x = 0; x < blueprint.xSize; x++) {
-            for (int z = 0; z < blueprint.zSize; z++) {
+        for (int x = 7; x < blueprint.xSize; ) {
+            for (int z = 7; z < blueprint.zSize; ) {
                 linkProxy(x, y, z);


Input:
public void clear() {
    fDataModel.clear();
    fScaledData = null;
}

Output:
     fDataModel.clear();
-    fScaledData = null;
+    synchronized (fDataModel) {
+        fScaledData = null;
+    }
 }


Input:
public void calculate_path(int x, int y) {
    Point target = new Point(x, y);
    target = WorldModel.tile_map.world2local(target);
    Point source = new Point(owner.origin);
    source = WorldModel.tile_map.world2local(source);
    try {
        path = finder.findPath(this, source.getX(), source.getY(), target.getX(), target.getY());
    } catch (ArrayIndexOutOfBoundsException ex) {
        path = null;
    }
    step = null;
    if (path != null && path.getLength() >= 1) {
        path.steps.remove(0);
    }
}

Output:
     Point target = new Point(x, y);
-    target = WorldModel.tile_map.world2local(target);
+    target = WorldModel.getWorldLayer(Player.get_zindex()).tile_map.world2local(target);
     Point source = new Point(owner.origin);


Input:
public static String getEID(EObject eObject) {
    if (eObject == null) {
        return null;
    }
    if (!(eObject instanceof Element)) {
        return EcoreUtil.getID(eObject);
    }
    Element element = (Element) eObject;
    Project project = Project.getProject(element);
    if (element instanceof Model && project.getPrimaryModel() == element) {
        return Converters.getIProjectToIdConverter().apply(project.getPrimaryProject()) + MDKConstants.PRIMARY_MODEL_ID_SUFFIX;
    }
    if (element instanceof InstanceSpecification && ((InstanceSpecification) element).getStereotypedElement() != null) {
        return getEID(((InstanceSpecification) element).getStereotypedElement()) + MDKConstants.APPLIED_STEREOTYPE_INSTANCE_ID_SUFFIX;
    }
    if (element instanceof ValueSpecification && ((ValueSpecification) element).getOwningSlot() != null) {
        ValueSpecification slotValue = (ValueSpecification) element;
        return getEID(slotValue.getOwningSlot()) + MDKConstants.SLOT_VALUE_ID_SEPARATOR + slotValue.getOwningSlot().getValue().indexOf(slotValue) + "String_Node_Str" + slotValue.eClass().getName().toLowerCase();
    }
    if (element instanceof Slot) {
        Slot slot = (Slot) element;
        if (slot.getOwningInstance() != null && ((Slot) element).getDefiningFeature() != null) {
            return getEID(slot.getOwner()) + MDKConstants.SLOT_ID_SEPARATOR + getEID(slot.getDefiningFeature());
        }
    }
    return element.getLocalID();
}

Output:
         if (slot.getOwningInstance() != null && ((Slot) element).getDefiningFeature() != null) {
-            return getEID(slot.getOwner()) + MDKConstants.SLOT_ID_SEPARATOR + getEID(slot.getDefiningFeature());
+            return getEID(slot.getOwningInstance()) + MDKConstants.SLOT_ID_SEPARATOR + getEID(slot.getDefiningFeature());
         }


Input:
public void onComplete() {
    synchronized (localInvitedUsers) {
        localInvitedUsers.remove(userId);
    }
    if (localInvitedUsers.size() == 0) {
        initiateConversation(false, null);
    }
    dispose();
}

Output:
     if (localInvitedUsers.size() == 0) {
-        initiateConversation(false, null);
+        initiateConversation(true, null);
     }


Input:
public int execute(HttpState state, HttpConnection conn) throws HttpException, IOException {
    Trace.entering(Activator.PLUGIN_ID, DebugOptions.METHODS_ENTERING, this.getClass(), "String_Node_Str" + gzipReceived);
    if (getFileRangeSpecification() == null)
        this.setRequestHeader(ACCEPT_ENCODING, CONTENT_ENCODING_ACCEPTED);
    gzipReceived = false;
    int result = super.execute(state, conn);
    if (isZippedReply()) {
        gzipReceived = true;
    }
    Trace.exiting(Activator.PLUGIN_ID, DebugOptions.METHODS_EXITING, this.getClass(), "String_Node_Str" + gzipReceived, new Integer(result));
    return result;
}

Output:
 public int execute(HttpState state, HttpConnection conn) throws HttpException, IOException {
-    Trace.entering(Activator.PLUGIN_ID, DebugOptions.METHODS_ENTERING, this.getClass(), "String_Node_Str" + gzipReceived);
-    if (getFileRangeSpecification() == null)
-        this.setRequestHeader(ACCEPT_ENCODING, CONTENT_ENCODING_ACCEPTED);
-    gzipReceived = false;
+    Trace.entering(Activator.PLUGIN_ID, DebugOptions.METHODS_ENTERING, this.getClass(), "String_Node_Str");
     int result = super.execute(state, conn);


Input:
private QName createQName(String name) {
    if (revertedXml2JsonNs.isEmpty() || !name.contains("String_Node_Str")) {
        return new QName(name);
    } else {
        int dotIndex = name.indexOf("String_Node_Str");
        String prefix = name.substring(0, dotIndex);
        String suffix = name.substring(dotIndex + 1);
        return revertedXml2JsonNs.containsKey(prefix) ? new QName(revertedXml2JsonNs.get(prefix), suffix) : new QName(name);
    }
}

Output:
 private QName createQName(String name) {
-    if (revertedXml2JsonNs.isEmpty() || !name.contains("String_Node_Str")) {
+    if (revertedXml2JsonNs.isEmpty() || !name.contains(nsSeparatorAsSequence)) {
         return new QName(name);


Input:
public Collection<InvocationEntry> getSignatures(long organisationId) {
    String[] queries = { "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" };
    long startedAt = System.currentTimeMillis();
    List<InvocationEntry> result = jdbcTemplate.query(queries[0], new InvocationsEntryRowMapper(), organisationId);
    log.warn("String_Node_Str", organisationId, (System.currentTimeMillis() - startedAt) / 1000L);
    return result;
}

Output:
     long startedAt = System.currentTimeMillis();
-    List<InvocationEntry> result = jdbcTemplate.query(queries[0], new InvocationsEntryRowMapper(), organisationId);
-    log.warn("String_Node_Str", organisationId, (System.currentTimeMillis() - startedAt) / 1000L);
+    Set<InvocationEntry> result = new HashSet<>(jdbcTemplate.query("String_Node_Str", new InvocationsEntryRowMapper(), organisationId));
+    log.debug("String_Node_Str", organisationId, System.currentTimeMillis() - startedAt);
     return result;