Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller == null) {
        return false;
    }
    List<Card> cardsToPutIntoPlay = new ArrayList<>();
    TargetCardInHand target = new TargetCardInHand(filter);
    PlayerList playerList = game.getPlayerList().copy();
    playerList.setCurrent(game.getActivePlayerId());
    Player player = game.getPlayer(game.getActivePlayerId());
    do {
        if (player.chooseUse(outcome, "String_Node_Str", game)) {
            target.clearChosen();
            if (player.chooseTarget(outcome, target, source, game)) {
                Card card = game.getCard(target.getFirstTarget());
                if (card != null) {
                    cardsToPutIntoPlay.add(card);
                }
            }
        }
        player = playerList.getNextInRange(controller, game);
    } while (!player.getId().equals(game.getActivePlayerId()));
    for (Card card : cardsToPutIntoPlay) {
        player = game.getPlayer(card.getOwnerId());
        if (player != null) {
            player.putOntoBattlefieldWithInfo(card, game, Zone.HAND, source.getSourceId());
        }
    }
    return true;
}

Output:
     TargetCardInHand target = new TargetCardInHand(filter);
-    PlayerList playerList = game.getPlayerList().copy();
-    playerList.setCurrent(game.getActivePlayerId());
-    Player player = game.getPlayer(game.getActivePlayerId());
-    do {
-        if (player.chooseUse(outcome, "String_Node_Str", game)) {
-            target.clearChosen();
-            if (player.chooseTarget(outcome, target, source, game)) {
-                Card card = game.getCard(target.getFirstTarget());
-                if (card != null) {
-                    cardsToPutIntoPlay.add(card);
+    for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
+        Player player = game.getPlayer(playerId);
+        if (player != null) {
+            if (player.chooseUse(outcome, "String_Node_Str", game)) {
+                target.clearChosen();
+                if (player.chooseTarget(outcome, target, source, game)) {
+                    Card card = game.getCard(target.getFirstTarget());
+                    if (card != null) {
+                        cardsToPutIntoPlay.add(card);
+                    }
                 }


Input:
protected void onEvent(Event event) {
    ApplicationSignUpRemovedEvent applicationSignUpRemovedEvent = (ApplicationSignUpRemovedEvent) event;
    String applicationId = applicationSignUpRemovedEvent.getApplicationId();
    Application application = ApplicationManager.getApplications().getApplication(applicationId);
    if (application != null) {
        for (ClusterDataHolder clusterDataHolder : application.getClusterDataMap().values()) topologyProvider.removeTenantSignUp(clusterDataHolder.getClusterId(), applicationSignUpRemovedEvent.getTenantId());
    }
}

Output:
 protected void onEvent(Event event) {
-    ApplicationSignUpRemovedEvent applicationSignUpRemovedEvent = (ApplicationSignUpRemovedEvent) event;
-    String applicationId = applicationSignUpRemovedEvent.getApplicationId();
-    Application application = ApplicationManager.getApplications().getApplication(applicationId);
-    if (application != null) {
-        for (ClusterDataHolder clusterDataHolder : application.getClusterDataMap().values()) topologyProvider.removeTenantSignUp(clusterDataHolder.getClusterId(), applicationSignUpRemovedEvent.getTenantId());
+    try {
+        ApplicationSignUpRemovedEvent applicationSignUpRemovedEvent = (ApplicationSignUpRemovedEvent) event;
+        String applicationId = applicationSignUpRemovedEvent.getApplicationId();
+        Application application = ApplicationManager.getApplications().getApplication(applicationId);
+        if (application != null) {
+            for (ClusterDataHolder clusterDataHolder : application.getClusterDataMap().values()) topologyProvider.removeTenantSignUp(clusterDataHolder.getClusterId(), applicationSignUpRemovedEvent.getTenantId());
+        }
+    } catch (Exception e) {
+        log.error("String_Node_Str", e);
     }


Input:
public void endUnit(Unit u) {
    int endStmtOffset = output().length() - lastNewline;
    u.addTag(new JimpleLineNumberTag(startLn, currentLn));
    u.addTag(new PositionTag(startStmtOffset, endStmtOffset));
}

Output:
     int endStmtOffset = output().length() - lastNewline;
-    u.addTag(new JimpleLineNumberTag(startLn, currentLn));
-    u.addTag(new PositionTag(startStmtOffset, endStmtOffset));
+    if (hasTag(u)) {
+        u.addTag(new JimpleLineNumberTag(startLn, currentLn));
+    }
+    if (hasColorTag(u)) {
+        u.addTag(new PositionTag(startStmtOffset, endStmtOffset));
+    }
 }


Input:
protected void handleDependentScaling(InstanceContext instanceContext, NetworkPartitionContext networkPartitionContext) {
    List<ScalingEvent> highestScalingEventOfDependencies = new ArrayList<ScalingEvent>();
    for (ScalingDependentList scalingDependentList : scalingDependencies) {
        ScalingEvent highestFactorEvent = null;
        for (String scalingDependentListComponent : scalingDependentList.getScalingDependentListComponents()) {
            ScalingEvent scalingEvent = instanceContext.getScalingEvent(scalingDependentListComponent);
            if (highestFactorEvent == null) {
                highestFactorEvent = scalingEvent;
            } else {
                if (scalingEvent.getFactor() > highestFactorEvent.getFactor()) {
                    highestFactorEvent = scalingEvent;
                }
            }
        }
        highestScalingEventOfDependencies.add(highestFactorEvent);
    }
    for (ScalingEvent highestScalingEventOfChild : highestScalingEventOfDependencies) {
        if (scalingDependencies != null && !scalingDependencies.isEmpty()) {
            for (ScalingDependentList scalingDependentList : scalingDependencies) {
                if (scalingDependentList.getScalingDependentListComponents().contains(highestScalingEventOfChild.getId())) {
                    for (String scalingDependentListComponent : scalingDependentList.getScalingDependentListComponents()) {
                        Monitor monitor = aliasToActiveMonitorsMap.get(scalingDependentListComponent);
                        if (monitor instanceof GroupMonitor || monitor instanceof VMClusterMonitor) {
                            ScalingEvent scalingEvent = new ScalingEvent(monitor.getId(), networkPartitionContext.getId(), instanceContext.getId(), highestScalingEventOfChild.getFactor());
                            monitor.onParentScalingEvent(scalingEvent);
                        }
                    }
                }
                break;
            }
        }
    }
    instanceContext.setIdToScalingEvent(new HashMap<String, ScalingEvent>());
}

Output:
             ScalingEvent scalingEvent = instanceContext.getScalingEvent(scalingDependentListComponent);
-            if (highestFactorEvent == null) {
-                highestFactorEvent = scalingEvent;
-            } else {
-                if (scalingEvent.getFactor() > highestFactorEvent.getFactor()) {
+            if (scalingEvent != null) {
+                if (highestFactorEvent == null) {
                     highestFactorEvent = scalingEvent;


Input:
public final Thread newThread(Runnable r) {
    final Thread t = createThread(r);
    t.setContextClassLoader(classLoader);
    if (t.isDaemon()) {
        t.setDaemon(false);
    }
    if (t.getPriority() != Thread.NORM_PRIORITY) {
        t.setPriority(Thread.NORM_PRIORITY);
    }
    return t;
}

Output:
     final Thread t = createThread(r);
-    t.setContextClassLoader(classLoader);
+    ClassLoader cl = classLoader != null ? classLoader : Thread.currentThread().getContextClassLoader();
+    t.setContextClassLoader(cl);
     if (t.isDaemon()) {


Input:
private static void convertMappingToXMLChoiceMapping(ClassDescriptor jaxbDescriptor, DatabaseMapping jpaMapping, ClassLoader cl) {
    if ((jpaMapping != null) && (jaxbDescriptor != null)) {
        if ((jpaMapping.isAggregateCollectionMapping()) || (jpaMapping.isAggregateMapping())) {
            return;
        }
        String attributeName = jpaMapping.getAttributeName();
        DatabaseMapping jaxbMapping = jaxbDescriptor.getMappingForAttributeName(jpaMapping.getAttributeName());
        if (!(jaxbMapping.isXMLMapping() && (jaxbMapping.isAbstractCompositeCollectionMapping() || jaxbMapping.isAbstractCompositeObjectMapping()))) {
            return;
        }
        String adapterClassName = RestAdapterClassWriter.constructClassNameForReferenceAdapter(jpaMapping.getReferenceDescriptor().getJavaClassName());
        try {
            if (jaxbMapping.isAbstractCompositeObjectMapping()) {
                XMLChoiceObjectMapping xmlChoiceMapping = new XMLChoiceObjectMapping();
                xmlChoiceMapping.setAttributeName(attributeName);
                copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
                xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
                xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
                xmlChoiceMapping.addChoiceElement(attributeName, jpaMapping.getReferenceDescriptor().getJavaClass());
                xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
                jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
                jaxbDescriptor.addMapping(xmlChoiceMapping);
            } else if (jaxbMapping.isAbstractCompositeCollectionMapping()) {
                XMLChoiceCollectionMapping xmlChoiceMapping = new XMLChoiceCollectionMapping();
                xmlChoiceMapping.setAttributeName(attributeName);
                copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
                xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
                xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
                xmlChoiceMapping.addChoiceElement(attributeName, jpaMapping.getReferenceDescriptor().getJavaClass());
                xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
                jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
                jaxbDescriptor.addMapping(xmlChoiceMapping);
            }
        } catch (ClassNotFoundException e) {
            throw new JPARSException(e.toString());
        }
    }
}

Output:
         }
-        String adapterClassName = RestAdapterClassWriter.constructClassNameForReferenceAdapter(jpaMapping.getReferenceDescriptor().getJavaClassName());
-        try {
-            if (jaxbMapping.isAbstractCompositeObjectMapping()) {
-                XMLChoiceObjectMapping xmlChoiceMapping = new XMLChoiceObjectMapping();
-                xmlChoiceMapping.setAttributeName(attributeName);
-                copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
-                xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
-                xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
-                xmlChoiceMapping.addChoiceElement(attributeName, jpaMapping.getReferenceDescriptor().getJavaClass());
-                xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
-                jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
-                jaxbDescriptor.addMapping(xmlChoiceMapping);
-            } else if (jaxbMapping.isAbstractCompositeCollectionMapping()) {
-                XMLChoiceCollectionMapping xmlChoiceMapping = new XMLChoiceCollectionMapping();
-                xmlChoiceMapping.setAttributeName(attributeName);
-                copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
-                xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
-                xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
-                xmlChoiceMapping.addChoiceElement(attributeName, jpaMapping.getReferenceDescriptor().getJavaClass());
-                xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
-                jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
-                jaxbDescriptor.addMapping(xmlChoiceMapping);
+        ClassDescriptor refDesc = jpaMapping.getReferenceDescriptor();
+        if (refDesc == null) {
+            Class clazz = ((ForeignReferenceMapping) jpaMapping).getReferenceClass();
+            refDesc = jpaSession.getDescriptor(clazz);
+        }
+        if (refDesc != null) {
+            String adapterClassName = RestAdapterClassWriter.constructClassNameForReferenceAdapter(refDesc.getJavaClassName());
+            if (adapterClassName != null) {
+                try {
+                    if (jaxbMapping.isAbstractCompositeObjectMapping()) {
+                        XMLChoiceObjectMapping xmlChoiceMapping = new XMLChoiceObjectMapping();
+                        xmlChoiceMapping.setAttributeName(attributeName);
+                        copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
+                        xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
+                        xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
+                        xmlChoiceMapping.addChoiceElement(attributeName, refDesc.getJavaClass());
+                        xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
+                        jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
+                        jaxbDescriptor.addMapping(xmlChoiceMapping);
+                    } else if (jaxbMapping.isAbstractCompositeCollectionMapping()) {
+                        XMLChoiceCollectionMapping xmlChoiceMapping = new XMLChoiceCollectionMapping();
+                        xmlChoiceMapping.setAttributeName(attributeName);
+                        copyAccessorToMapping(jaxbMapping, xmlChoiceMapping);
+                        xmlChoiceMapping.setProperties(jaxbMapping.getProperties());
+                        xmlChoiceMapping.addChoiceElement(attributeName, Link.class);
+                        xmlChoiceMapping.addChoiceElement(attributeName, refDesc.getJavaClass());
+                        xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
+                        jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
+                        jaxbDescriptor.addMapping(xmlChoiceMapping);
+                    }
+                } catch (ClassNotFoundException e) {
+                    throw new JPARSException(e.toString());
+                }
             }


Input:
private void scheduleMorningTask() {
    Calendar firstTime = Calendar.getInstance();
    Calendar now = Calendar.getInstance();
    firstTime.set(Calendar.HOUR_OF_DAY, 8);
    firstTime.set(Calendar.MINUTE, 0);
    firstTime.set(Calendar.SECOND, 0);
    if (firstTime.before(now)) {
        firstTime.roll(Calendar.DATE, true);
    }
    long period = ONE_DAY;
    timer.scheduleAtFixedRate(new MorningTask(sarariman, directory, emailDispatcher), firstTime.getTime(), period);
}

Output:
     if (firstTime.before(now)) {
-        firstTime.roll(Calendar.DATE, true);
+        firstTime.add(Calendar.DATE, 1);
     }


Input:
public boolean addInstanceIDVarToTemplatePlan(final BPELScopeActivity templatePlan) {
    final String xsdPrefix = "String_Node_Str" + System.currentTimeMillis();
    final String xsdNamespace = "String_Node_Str";
    this.bpelProcessHandler.addNamespaceToBPELDoc(xsdPrefix, xsdNamespace, templatePlan.getBuildPlan());
    String templateId = "String_Node_Str";
    String prefix = "String_Node_Str";
    if (templatePlan.getNodeTemplate() != null) {
        templateId = templatePlan.getNodeTemplate().getId();
        prefix = "String_Node_Str";
    } else {
        templateId = templatePlan.getRelationshipTemplate().getId();
        prefix = "String_Node_Str";
    }
    final String instanceIdVarName = prefix + InstanceIDVarKeyword + "String_Node_Str" + templateId.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + System.currentTimeMillis();
    return this.bpelProcessHandler.addVariable(instanceIdVarName, VariableType.TYPE, new QName(xsdNamespace, "String_Node_Str", xsdPrefix), templatePlan.getBuildPlan());
}

Output:
     }
-    final String instanceIdVarName = prefix + InstanceIDVarKeyword + "String_Node_Str" + templateId.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + System.currentTimeMillis();
+    final String instanceIdVarName = prefix + InstanceIDVarKeyword + "String_Node_Str" + ModelUtils.makeValidNCName(templateId) + "String_Node_Str" + System.currentTimeMillis();
     return this.bpelProcessHandler.addVariable(instanceIdVarName, VariableType.TYPE, new QName(xsdNamespace, "String_Node_Str", xsdPrefix), templatePlan.getBuildPlan());


Input:
public boolean onOptionsItemSelected(MenuItem item) {
    super.onOptionsItemSelected(item);
    Intent intent = null;
    switch(item.getItemId()) {
        case android.R.id.home:
            intent = new Intent(this, PrimitiveFtpdActivity.class);
            startActivity(intent);
            break;
    }
    return true;
}

Output:
         case android.R.id.home:
-            intent = new Intent(this, PrimitiveFtpdActivity.class);
-            startActivity(intent);
+            FtpPrefsActivity.this.finish();
             break;


Input:
public void waitForStatus(final String appId, final ProgramType programType, final String programId, String status, long timeout, TimeUnit timeoutUnit) throws UnAuthorizedAccessTokenException, IOException, ProgramNotFoundException, TimeoutException, InterruptedException {
    try {
        ProgramFlowUtil.waitFor(status, new Callable<String>() {
            public String call() throws Exception {
                return getStatus(appId, programType, programId);
            }
        }, timeout, timeoutUnit.toSeconds(1), timeoutUnit);
    } catch (ExecutionException e) {
        Throwables.propagateIfPossible(e.getCause(), UnAuthorizedAccessTokenException.class);
        Throwables.propagateIfPossible(e.getCause(), ProgramNotFoundException.class);
        Throwables.propagateIfPossible(e.getCause(), IOException.class);
    }
}

Output:
             }
-        }, timeout, timeoutUnit.toSeconds(1), timeoutUnit);
+        }, timeout, timeoutUnit, 1, TimeUnit.SECONDS);
     } catch (ExecutionException e) {


Input:
protected void processReport(HttpServletRequest request) throws Exception {
    if (ParameterAccessor.HEADER_REQUEST_TYPE_SOAP.equalsIgnoreCase(this.requestType) || IBirtConstants.SERVLET_PATH_DOWNLOAD.equalsIgnoreCase(request.getServletPath()))
        return;
    if (this.reportDocumentName == null)
        return;
    File reportDocFile = new File(this.reportDocumentName);
    long lastModifiedOfDesign = getLastModifiedOfDesign(request);
    if (lastModifiedOfDesign != -1L && reportDocFile != null && reportDocFile.exists() && reportDocFile.isFile()) {
        if (lastModifiedOfDesign > reportDocFile.lastModified() || ParameterAccessor.isOverwrite(request)) {
            reportDocFile.delete();
        }
    }
}

Output:
 protected void processReport(HttpServletRequest request) throws Exception {
-    if (ParameterAccessor.HEADER_REQUEST_TYPE_SOAP.equalsIgnoreCase(this.requestType) || IBirtConstants.SERVLET_PATH_DOWNLOAD.equalsIgnoreCase(request.getServletPath()))
+    if (ParameterAccessor.HEADER_REQUEST_TYPE_SOAP.equalsIgnoreCase(this.requestType) || IBirtConstants.SERVLET_PATH_DOWNLOAD.equalsIgnoreCase(request.getServletPath()) || IBirtConstants.SERVLET_PATH_EXTRACT.equalsIgnoreCase(request.getServletPath()))
         return;


Input:
public boolean syncDishImage(List<Dish> dishList) {
    boolean result = true;
    if (dishList == null) {
        return result;
    }
    try {
        for (Dish dish : dishList) {
            String imgUrl = DEFAULT_URL + dish.getImageServer();
            String imgName = dish.getImageServer().split("String_Node_Str", 2)[1];
            String filePath = getLocalFileStorageUrl("String_Node_Str", imgName);
            OutputStream fos = new FileOutputStream(filePath);
            reqHelper.getFileFromServer(imgUrl, null, fos);
        }
    } catch (IOException e) {
        LogUtils.logD("String_Node_Str");
        result = false;
    }
    return result;
}

Output:
         for (Dish dish : dishList) {
-            String imgUrl = DEFAULT_URL + dish.getImageServer();
+            String imgUrl = getRequestUrl(null, dish.getImageServer());
             String imgName = dish.getImageServer().split("String_Node_Str", 2)[1];


Input:
public void init() {
    volume.setMin(PLAYBACK.getVolumeMin());
    volume.setMax(PLAYBACK.getVolumeMax());
    volume.setValue(PLAYBACK.getVolume());
    volume.valueProperty().bindBidirectional(PLAYBACK.volumeProperty());
    seeker.bindTime(PLAYBACK.totalTimeProperty(), PLAYBACK.currentTimeProperty());
    d6 = maintain(GUI.snapDistance, d -> d, seeker.chapterSnapDistance);
    seekerPane.setCenter(seeker);
    prevB = new Icon(STEP_BACKWARD, 14, null, PlaylistManager::playPreviousItem);
    playB = new Icon(null, 14, null, PLAYBACK::pause_resume);
    stopB = new Icon(STOP, 14, null, PLAYBACK::stop);
    nextB = new Icon(STEP_FORWARD, 14, null, PlaylistManager::playNextItem);
    controlBox.getChildren().addAll(prevB, playB, stopB, nextB);
    volB = new Icon(null, 14, null, PLAYBACK::toggleMute);
    volBox.getChildren().add(0, volB);
    d1 = maintain(PLAYBACK.volumeProperty(), v -> muteChanged(PLAYBACK.isMute(), v.doubleValue()));
    d2 = maintain(PLAYBACK.muteProperty(), m -> muteChanged(m, PLAYBACK.getVolume()));
    d3 = maintain(PLAYBACK.statusProperty(), this::statusChanged);
    d4 = Player.subscribe(ReadMode.PLAYING, d4, this::playbackItemChanged);
    d5 = maintain(PLAYBACK.currentTimeProperty(), t -> currentTimeChanged());
    root.setOnDragOver(DragUtil.audioDragAccepthandler);
    root.setOnDragDropped(e -> {
        if (DragUtil.hasAudio(e.getDragboard())) {
            List<Item> items = DragUtil.getAudioItems(e);
            e.setDropCompleted(true);
            e.consume();
            if (playDropped) {
                PlaylistManager.playPlaylist(new Playlist(items.stream().map(Item::getURI), true));
            } else {
                PlaylistManager.addItems(items);
            }
        }
    });
    ds = asList(d1, d2, d3, d4, d5, d6);
}

Output:
             if (playDropped) {
-                PlaylistManager.playPlaylist(new Playlist(items.stream().map(Item::getURI), true));
+                PlaylistManager.playPlaylist(new Playlist(map(items, Item::toPlaylist)));
             } else {


Input:
protected void eventFilterChanged(ARXResult result, ModelNodeFilter filter) {
    if (getModel() != null && result != null) {
        updateFilter(result.getLattice(), filter);
    } else {
        reset();
    }
}

Output:
     if (getModel() != null && result != null) {
-        updateFilter(result.getLattice(), filter);
+        ARXLattice lattice = getModel().getProcessStatistics().getNumberOfSteps() > 1 ? getModel().getProcessStatistics().getLattice() : result.getLattice();
+        updateFilter(lattice, filter);
     } else {


Input:
public void onBlockRedstoneChange(BlockRedstoneEvent event) {
    Block block = event.getBlock();
    if (event.getNewCurrent() == 0 && block.getTypeId() == 74) {
        block.setTypeId(Material.REDSTONE_ORE.getId());
    }
    int newPower = event.getNewCurrent() - (event.getNewCurrent() == 0 ? 0 : 1);
    BlockMatrixNode oreCircuit = new BlockMatrixNode(block, new HashMap<Block, BlockMatrixNode>());
    if (block.getTypeId() == 73 || block.getTypeId() == 74) {
        if (event.getNewCurrent() > event.getOldCurrent()) {
            oreCircuit.setFilter(new HashSet<Material>(EnumSet.of(Material.REDSTONE_ORE)));
            oreCircuit.floodFill();
            if (oreCircuit.getBlockMatrix().size() > 1) {
                for (Block change : oreCircuit.getBlockMatrix()) {
                    change.setTypeId(74);
                }
            }
        } else if (event.getNewCurrent() != event.getOldCurrent()) {
            oreCircuit.setFilter(new HashSet<Material>(EnumSet.of(Material.GLOWING_REDSTONE_ORE)));
            oreCircuit.floodFill();
            if (oreCircuit.getBlockMatrix().size() > 1) {
                for (Block change : oreCircuit.getBlockMatrix()) {
                    change.setTypeId(73);
                }
            }
        }
        if (oreCircuit.getBlockMatrix().size() > 1) {
            oreCircuit.setFilter(EnumSet.complementOf(EnumSet.of(Material.REDSTONE_ORE, Material.GLOWING_REDSTONE_ORE)));
            for (BlockMatrixNode next : oreCircuit.getBlockMatrixNodes()) {
                for (Block eventTarget : next.getFilteredExternalAdjancentBlocks()) {
                    int oldPower = 0;
                    if (eventTarget.getState() instanceof RedstoneWire) {
                        oldPower = eventTarget.getBlockPower();
                        eventTarget.setData((byte) newPower);
                    }
                    plugin.getServer().getPluginManager().callEvent(new BlockRedstoneEvent(eventTarget, oldPower, newPower));
                }
            }
        }
    }
}

Output:
             oreCircuit.floodFill();
-            if (oreCircuit.getBlockMatrix().size() > 1) {
-                for (Block change : oreCircuit.getBlockMatrix()) {
-                    change.setTypeId(74);
-                }
+            for (Block change : oreCircuit.getBlockMatrix()) {
+                change.setTypeId(74);
             }


Input:
ImmutableList<Step> buildSteps() {
    ImmutableList.Builder<Step> allSteps = ImmutableList.builder();
    if (resources.isEmpty()) {
        return allSteps.build();
    }
    String targetPackageDir = javaPackageFinder.findJavaPackage(target);
    for (SourcePath rawResource : resources) {
        final Path pathToResource = resolver.getPath(rawResource);
        String resource = MorePaths.pathWithUnixSeparators(pathToResource);
        Matcher matcher;
        if ((matcher = GENERATED_FILE_PATTERN.matcher(resource)).matches()) {
            resource = matcher.group(1);
        }
        Path javaPackageAsPath = javaPackageFinder.findJavaPackageFolder(Paths.get(resource));
        Path relativeSymlinkPath;
        if ("String_Node_Str".equals(javaPackageAsPath.toString())) {
            relativeSymlinkPath = pathToResource.getFileName();
        } else {
            int lastIndex = resource.lastIndexOf(MorePaths.pathWithUnixSeparators(javaPackageAsPath));
            if (lastIndex < 0) {
                Preconditions.checkState(rawResource instanceof BuildTargetSourcePath, "String_Node_Str", pathToResource, javaPackageAsPath);
                relativeSymlinkPath = Paths.get(String.format("String_Node_Str", targetPackageDir, targetPackageDir.isEmpty() ? "String_Node_Str" : "String_Node_Str", resolver.getPath(rawResource).getFileName()));
            } else {
                relativeSymlinkPath = Paths.get(resource.substring(lastIndex));
            }
        }
        Path target = outputDirectory.resolve(relativeSymlinkPath);
        MkdirAndSymlinkFileStep link = new MkdirAndSymlinkFileStep(pathToResource, target);
        allSteps.add(link);
    }
    return allSteps.build();
}

Output:
         } else {
-            int lastIndex = resource.lastIndexOf(MorePaths.pathWithUnixSeparators(javaPackageAsPath));
+            int lastIndex = resource.lastIndexOf(MorePaths.pathWithUnixSeparatorsAndTrailingSlash(javaPackageAsPath));
             if (lastIndex < 0) {


Input:
private Property processReferenceProperty(Property property, TypeInfo info, JavaClass cls) {
    for (org.eclipse.persistence.jaxb.xmlmodel.XmlElementRef nextRef : property.getXmlElementRefs()) {
        JavaClass type = property.getType();
        String typeName = type.getQualifiedName();
        if (isCollectionType(property)) {
            if (type.hasActualTypeArguments()) {
                type = property.getGenericType();
                typeName = type.getQualifiedName();
            }
        }
        if (!(nextRef.getType().equals("String_Node_Str") || nextRef.getType().equals("String_Node_Str"))) {
            typeName = nextRef.getType();
            type = helper.getJavaClass(typeName);
        }
        boolean missingReference = true;
        for (Entry<String, ElementDeclaration> entry : xmlRootElements.entrySet()) {
            ElementDeclaration entryValue = entry.getValue();
            if (!(areEquals(type, Object.class)) && type.isAssignableFrom(entryValue.getJavaType())) {
                addReferencedElement(property, entryValue);
                missingReference = false;
            }
        }
        if (missingReference) {
            String name = nextRef.getName();
            String namespace = nextRef.getNamespace();
            if (namespace.equals(XMLProcessor.DEFAULT)) {
                namespace = EMPTY_STRING;
            }
            QName qname = new QName(namespace, name);
            JavaClass scopeClass = cls;
            ElementDeclaration referencedElement = null;
            while (!(scopeClass.getName().equals(JAVA_LANG_OBJECT))) {
                HashMap<QName, ElementDeclaration> elements = getElementDeclarationsForScope(scopeClass.getName());
                if (elements != null) {
                    referencedElement = elements.get(qname);
                }
                if (referencedElement != null) {
                    break;
                }
                scopeClass = scopeClass.getSuperclass();
            }
            if (referencedElement == null) {
                referencedElement = this.getGlobalElements().get(qname);
            }
            if (referencedElement != null) {
                addReferencedElement(property, referencedElement);
            } else {
                throw org.eclipse.persistence.exceptions.JAXBException.invalidElementRef(property.getPropertyName(), cls.getName());
            }
        }
    }
    return property;
}

Output:
         String typeName = type.getQualifiedName();
-        if (isCollectionType(property)) {
+        if (helper.isCollectionType(property.getType())) {
             if (type.hasActualTypeArguments()) {


Input:
public Vec3d getCouplerPosition(CouplerType coupler, TickPos pos) {
    if (coupler == CouplerType.FRONT) {
        if (couplerFrontPosition == null) {
            couplerFrontPosition = predictRearBogeyPosition(pos, (float) (this.getDefinition().getLength(gauge) / 2 + Config.couplerRange + this.getDefinition().getBogeyRear(gauge))).add(pos.position).addVector(0, 1, 0);
        }
        return couplerFrontPosition;
    } else {
        if (couplerRearPosition == null) {
            couplerRearPosition = predictFrontBogeyPosition(pos, (float) (this.getDefinition().getLength(gauge) / 2 + Config.couplerRange - this.getDefinition().getBogeyFront(gauge))).add(pos.position).addVector(0, 1, 0);
        }
        return couplerRearPosition;
    }
}

Output:
         if (couplerFrontPosition == null) {
-            couplerFrontPosition = predictRearBogeyPosition(pos, (float) (this.getDefinition().getLength(gauge) / 2 + Config.couplerRange + this.getDefinition().getBogeyRear(gauge))).add(pos.position).addVector(0, 1, 0);
+            couplerFrontPosition = predictRearBogeyPosition(pos, (float) (this.getDefinition().frontBounds - this.getDefinition().getBogeyFront(gauge))).add(pos.position).addVector(0, 1, 0);
         }


Input:
protected void applyStyle(int availWidth, int availHeight) {
    Object rootNode = this.modelNode;
    HTMLElementImpl rootElement;
    boolean isRootBlock;
    if (rootNode instanceof HTMLDocumentImpl) {
        isRootBlock = true;
        HTMLDocumentImpl doc = (HTMLDocumentImpl) rootNode;
        rootElement = (HTMLElementImpl) doc.getBody();
    } else {
        isRootBlock = false;
        rootElement = (HTMLElementImpl) rootNode;
    }
    if (rootElement == null) {
        this.clearStyle(isRootBlock);
        return;
    }
    RenderState rs = rootElement.getRenderState();
    if (rs == null) {
        throw new IllegalStateException("String_Node_Str" + rootElement + "String_Node_Str" + rootElement.getParentNode());
    }
    BackgroundInfo binfo = rs.getBackgroundInfo();
    this.backgroundColor = binfo == null ? null : binfo.backgroundColor;
    URL backgroundImageUri = binfo == null ? null : binfo.backgroundImage;
    if (backgroundImageUri == null) {
        this.backgroundImage = null;
        this.lastBackgroundImageUri = null;
    } else if (!backgroundImageUri.equals(this.lastBackgroundImageUri)) {
        this.lastBackgroundImageUri = backgroundImageUri;
        this.loadBackgroundImage(backgroundImageUri);
    }
    AbstractCSS2Properties props = rootElement.getCurrentStyle();
    if (props == null) {
        this.clearStyle(isRootBlock);
    } else {
        BorderInfo borderInfo = rs.getBorderInfo();
        this.borderInfo = borderInfo;
        HtmlInsets binsets = borderInfo == null ? null : borderInfo.insets;
        HtmlInsets minsets = rs.getMarginInsets();
        HtmlInsets pinsets = rs.getPaddingInsets();
        Insets defaultMarginInsets = this.defaultMarginInsets;
        int dmleft = 0, dmright = 0, dmtop = 0, dmbottom = 0;
        if (defaultMarginInsets != null) {
            dmleft = defaultMarginInsets.left;
            dmright = defaultMarginInsets.right;
            dmtop = defaultMarginInsets.top;
            dmbottom = defaultMarginInsets.bottom;
        }
        Insets defaultPaddingInsets = this.defaultPaddingInsets;
        int dpleft = 0, dpright = 0, dptop = 0, dpbottom = 0;
        if (defaultPaddingInsets != null) {
            dpleft = defaultPaddingInsets.left;
            dpright = defaultPaddingInsets.right;
            dptop = defaultPaddingInsets.top;
            dpbottom = defaultPaddingInsets.bottom;
        }
        Insets borderInsets = binsets == null ? null : binsets.getAWTInsets(0, 0, 0, 0, availWidth, availHeight, 0, 0);
        if (borderInsets == null) {
            borderInsets = RBlockViewport.ZERO_INSETS;
        }
        Insets paddingInsets = pinsets == null ? defaultPaddingInsets : pinsets.getAWTInsets(dptop, dpleft, dpbottom, dpright, availWidth, availHeight, 0, 0);
        if (paddingInsets == null) {
            paddingInsets = RBlockViewport.ZERO_INSETS;
        }
        Insets tentativeMarginInsets = minsets == null ? defaultMarginInsets : minsets.getAWTInsets(dmtop, dmleft, dmbottom, dmright, availWidth, availHeight, 0, 0);
        if (tentativeMarginInsets == null) {
            tentativeMarginInsets = RBlockViewport.ZERO_INSETS;
        }
        int actualAvailWidth = availWidth - paddingInsets.left - paddingInsets.right - borderInsets.left - borderInsets.right - tentativeMarginInsets.left - tentativeMarginInsets.right;
        int actualAvailHeight = availHeight - paddingInsets.top - paddingInsets.bottom - borderInsets.top - borderInsets.bottom - tentativeMarginInsets.top - tentativeMarginInsets.bottom;
        Integer declaredWidth = this.getDeclaredWidth(rs, actualAvailWidth);
        Integer declaredHeight = this.getDeclaredHeight(rs, actualAvailHeight);
        int autoMarginX = 0, autoMarginY = 0;
        if (declaredWidth != null) {
            autoMarginX = (availWidth - declaredWidth.intValue() - (borderInsets == null ? 0 : borderInsets.left - borderInsets.right) - (paddingInsets == null ? 0 : paddingInsets.left - paddingInsets.right)) / 2;
        }
        if (declaredHeight != null) {
            autoMarginY = (availHeight - declaredHeight.intValue() - (borderInsets == null ? 0 : borderInsets.top - borderInsets.bottom) - (paddingInsets == null ? 0 : paddingInsets.top - paddingInsets.bottom)) / 2;
        }
        this.borderInsets = borderInsets;
        if (isRootBlock) {
            Insets regularMarginInsets = (autoMarginX == 0 && autoMarginY == 0) ? tentativeMarginInsets : (minsets == null ? defaultMarginInsets : minsets.getAWTInsets(dmtop, dmleft, dmbottom, dmright, availWidth, availHeight, autoMarginX, autoMarginY));
            if (regularMarginInsets == null) {
                regularMarginInsets = RBlockViewport.ZERO_INSETS;
            }
            this.marginInsets = null;
            this.paddingInsets = new Insets(paddingInsets.top + regularMarginInsets.top, paddingInsets.left + regularMarginInsets.left, paddingInsets.bottom + regularMarginInsets.bottom, paddingInsets.right + regularMarginInsets.right);
        } else {
            this.paddingInsets = paddingInsets;
            this.marginInsets = (autoMarginX == 0 && autoMarginY == 0) ? tentativeMarginInsets : (minsets == null ? defaultMarginInsets : minsets.getAWTInsets(dmtop, dmleft, dmbottom, dmright, availWidth, availHeight, autoMarginX, autoMarginY));
        }
        if (borderInfo != null) {
            this.borderTopColor = borderInfo.topColor;
            this.borderLeftColor = borderInfo.leftColor;
            this.borderBottomColor = borderInfo.bottomColor;
            this.borderRightColor = borderInfo.rightColor;
        } else {
            this.borderTopColor = null;
            this.borderLeftColor = null;
            this.borderBottomColor = null;
            this.borderRightColor = null;
        }
        String zIndex = props.getZIndex();
        if (zIndex != null) {
            try {
                this.zIndex = Integer.parseInt(zIndex);
            } catch (NumberFormatException err) {
                logger.log(Level.WARNING, "String_Node_Str" + zIndex + "String_Node_Str" + this.modelNode + "String_Node_Str", err);
                this.zIndex = 0;
            }
        } else {
            this.zIndex = 0;
        }
        this.overflowX = rs.getOverflowX();
        this.overflowY = rs.getOverflowY();
    }
}

Output:
         this.borderInfo = borderInfo;
-        HtmlInsets binsets = borderInfo == null ? null : borderInfo.insets;
+        HtmlInsets binsets = borderInfo == null ? null : borderInfo.getInsets();
         HtmlInsets minsets = rs.getMarginInsets();


Input:
public boolean handle(Object receive) throws Exception {
    if (receive instanceof HttpResponse) {
        HttpResponse response = (HttpResponse) receive;
        if (NettyUtil.isSuccessful(response.getStatus())) {
            handler.handle(RestRiakOperations.this.support.newResponse("String_Node_Str"));
            return true;
        }
    }
    throw new IncomprehensibleProtocolException(procedure);
}

Output:
     }
-    throw new IncomprehensibleProtocolException(procedure);
+    return false;
 }


Input:
private void moveFocus() {
    HasFocus focusableWidget = curSelection.getFocusableWidget();
    if (focusableWidget != null) {
        focusableWidget.setFocus(true);
        DOM.scrollIntoView(((Widget) focusableWidget).getElement());
    } else {
        Element selectedElem = curSelection.getContentElem();
        int containerLeft = getAbsoluteLeft();
        int containerTop = getAbsoluteTop();
        int left = DOM.getAbsoluteLeft(selectedElem) - containerLeft;
        int top = DOM.getAbsoluteTop(selectedElem) - containerTop;
        int width = DOM.getElementPropertyInt(selectedElem, "String_Node_Str");
        int height = DOM.getElementPropertyInt(selectedElem, "String_Node_Str");
        if (width == 0 || height == 0) {
            DOM.setIntStyleAttribute(focusable, "String_Node_Str", 0);
            DOM.setIntStyleAttribute(focusable, "String_Node_Str", 0);
            return;
        }
        DOM.setStyleAttribute(focusable, "String_Node_Str", left + "String_Node_Str");
        DOM.setStyleAttribute(focusable, "String_Node_Str", top + "String_Node_Str");
        DOM.setStyleAttribute(focusable, "String_Node_Str", width + "String_Node_Str");
        DOM.setStyleAttribute(focusable, "String_Node_Str", height + "String_Node_Str");
        DOM.scrollIntoView(focusable);
        updateAriaAttributes();
        setFocus(true);
    }
}

Output:
 private void moveFocus() {
-    HasFocus focusableWidget = curSelection.getFocusableWidget();
+    Focusable focusableWidget = curSelection.getFocusable();
     if (focusableWidget != null) {


Input:
public final void setAll() {
    expand(0, length());
    for (int i = 0; i < bits.length; i++) {
        bits[i] = MASK;
    }
}

Output:
 public final void setAll() {
-    expand(0, length());
+    expand(0, length() - 1);
     for (int i = 0; i < bits.length; i++) {


Input:
private Map<String, LocalizeResource> getExploreDependencies(Path tempDir, List<String> extraClassPaths) throws IOException {
    final Set<File> masterJars = new HashSet<>();
    for (URL url : ClassLoaders.getClassLoaderURLs(getClass().getClassLoader(), new HashSet<URL>())) {
        String path = url.getPath();
        if (!"String_Node_Str".equals(url.getProtocol()) || !path.endsWith("String_Node_Str")) {
            continue;
        }
        try {
            masterJars.add(new File(url.toURI()));
        } catch (URISyntaxException e) {
            LOG.warn("String_Node_Str", e);
        }
    }
    Iterable<File> exploreJars = Iterables.filter(ExploreUtils.getExploreClasspathJarFiles(), new Predicate<File>() {

        public boolean apply(File file) {
            return !masterJars.contains(file);
        }
    });
    Map<String, LocalizeResource> resources = new HashMap<>();
    for (File exploreJar : exploreJars) {
        File targetJar = tempDir.resolve(System.currentTimeMillis() + "String_Node_Str" + exploreJar.getName()).toFile();
        File resultFile = ExploreServiceUtils.rewriteHiveAuthFactory(exploreJar, targetJar);
        if (resultFile == targetJar) {
            LOG.info("String_Node_Str", exploreJar, resultFile);
        }
        resources.put(resultFile.getName(), new LocalizeResource(resultFile));
        extraClassPaths.add(resultFile.getName());
    }
    extraClassPaths.addAll(MapReduceContainerHelper.localizeFramework(hConf, resources));
    return resources;
}

Output:
     }
-    Iterable<File> exploreJars = Iterables.filter(ExploreUtils.getExploreClasspathJarFiles(), new Predicate<File>() {
+    Iterable<File> exploreFiles = Iterables.filter(ExploreUtils.getExploreClasspathJarFiles("String_Node_Str", "String_Node_Str"), new Predicate<File>() {


Input:
public void pause() {
    if (!mEnded) {
        ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
        int numOldAnims = runningAnimators.size();
        for (int i = numOldAnims - 1; i >= 0; i--) {
            Animator anim = runningAnimators.keyAt(i);
            anim.pause();
        }
        if (mListeners != null && mListeners.size() > 0) {
            ArrayList<TransitionListener> tmpListeners = (ArrayList<TransitionListener>) mListeners.clone();
            int numListeners = tmpListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                tmpListeners.get(i).onTransitionPause(this);
            }
        }
        mPaused = true;
    }
}

Output:
         for (int i = numOldAnims - 1; i >= 0; i--) {
-            Animator anim = runningAnimators.keyAt(i);
-            anim.pause();
+            AnimationInfo info = runningAnimators.valueAt(i);
+            if (info.view != null && windowId.equals(info.windowId)) {
+                Animator anim = runningAnimators.keyAt(i);
+                anim.pause();
+            }
         }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setTheme(SettingUtility.getTheme());
    GlobalContext.setActivity(this);
    setContentView(R.layout.activity_main);
    ViewPager pager = (ViewPager) findViewById(R.id.pager);
    pager.setAdapter(new MyPagerAdapter(getSupportFragmentManager()));
    LinePageIndicator mIndicator = (LinePageIndicator) findViewById(R.id.indicator);
    if (SettingUtility.isLightTheme()) {
        mIndicator.setBackgroundColor(Color.WHITE);
    }
    mIndicator.setViewPager(pager);
    if (SettingUtility.enableGTask()) {
        mIndicator.setCurrentItem(1);
    }
    MyUtils.deleteContinueTimes(this);
}

Output:
     mIndicator.setViewPager(pager);
-    if (SettingUtility.enableGTask()) {
-        mIndicator.setCurrentItem(1);
-    }
+    mIndicator.setCurrentItem(1);
     MyUtils.deleteContinueTimes(this);


Input:
private void showDialog() {
    view = layoutInflater.inflate(R.layout.fingerprint_dialog, null);
    ((TextView) view.findViewById(R.id.fingerprint_dialog_title)).setText(title);
    ((TextView) view.findViewById(R.id.fingerprint_dialog_message)).setText(message);
    builder.setPositiveButton(R.string.fingerprint_cancel_button, new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialogInterface, int i) {
            cancellationSignal.cancel();
            if (fingerprintCallback != null) {
                fingerprintCallback.onCancelled();
            }
        }
    });
    builder.setView(view);
    dialog = builder.create();
    if (dialog.getWindow() != null && (enterAnimation != NO_ANIMATION || exitAnimation != NO_ANIMATION)) {
        int style = getStyle();
        if (style == -1) {
            Log.e(TAG, "String_Node_Str");
        } else {
            dialog.getWindow().getAttributes().windowAnimations = style;
        }
    }
    dialog.setCanceledOnTouchOutside(cancelOnTouchOutside);
    dialog.show();
    auth();
}

Output:
     if (dialog.getWindow() != null && (enterAnimation != NO_ANIMATION || exitAnimation != NO_ANIMATION)) {
-        int style = getStyle();
+        int style = getStyle(enterAnimation, exitAnimation);
         if (style == -1) {


Input:
public void updateMigrationSystem(org.talend.core.model.properties.Project project, boolean persistence) {
    MigrationUtil.removeMigrationTaskById(project.getMigrationTask(), MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID);
    IProjectMigrationTask task = GetTasksHelper.getInstance().getProjectTask(MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID);
    task.execute(new org.talend.core.model.general.Project(project), persistence);
    project.getMigrationTask().add(MigrationUtil.convertMigrationTask(task));
}

Output:
 public void updateMigrationSystem(org.talend.core.model.properties.Project project, boolean persistence) {
-    MigrationUtil.removeMigrationTaskById(project.getMigrationTask(), MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID);
-    IProjectMigrationTask task = GetTasksHelper.getInstance().getProjectTask(MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID);
-    task.execute(new org.talend.core.model.general.Project(project), persistence);
-    project.getMigrationTask().add(MigrationUtil.convertMigrationTask(task));
+    if (!MigrationUtil.containsTask(project.getMigrationTask(), MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID)) {
+        IProjectMigrationTask task = GetTasksHelper.getInstance().getProjectTask(MigrationUtil.ADAPT_NEW_MIGRATION_TASK_SYSTEM_ID);
+        task.execute(new org.talend.core.model.general.Project(project), persistence);
+    }
 }


Input:
protected boolean checkNodes(Item item, ProcessType processType) throws Exception {
    boolean modified = false;
    ComponentCategory category = ComponentCategory.getComponentCategoryFromItem(item);
    for (Object nodeObjectType : processType.getNode()) {
        NodeType nodeType = (NodeType) nodeObjectType;
        IComponent component = ComponentsFactoryProvider.getInstance().get(nodeType.getComponentName(), category.getName());
        if (component == null) {
            continue;
        }
        FakeNode fNode = new FakeNode(component);
        for (Object paramObjectType : nodeType.getElementParameter()) {
            ElementParameterType param = (ElementParameterType) paramObjectType;
            IElementParameter paramFromEmf = fNode.getElementParameter(param.getName());
            if (paramFromEmf != null) {
                if (EParameterFieldType.PASSWORD.equals(paramFromEmf.getFieldType()) && param.getValue() != null) {
                    param.setField(EParameterFieldType.PASSWORD.getName());
                    if (reencryptValueIfNeeded(param)) {
                        modified = true;
                    }
                }
            }
        }
    }
    return modified;
}

Output:
     boolean modified = false;
-    ComponentCategory category = ComponentCategory.getComponentCategoryFromItem(item);
-    for (Object nodeObjectType : processType.getNode()) {
-        NodeType nodeType = (NodeType) nodeObjectType;
-        IComponent component = ComponentsFactoryProvider.getInstance().get(nodeType.getComponentName(), category.getName());
-        if (component == null) {
-            continue;
-        }
-        FakeNode fNode = new FakeNode(component);
-        for (Object paramObjectType : nodeType.getElementParameter()) {
-            ElementParameterType param = (ElementParameterType) paramObjectType;
-            IElementParameter paramFromEmf = fNode.getElementParameter(param.getName());
-            if (paramFromEmf != null) {
-                if (EParameterFieldType.PASSWORD.equals(paramFromEmf.getFieldType()) && param.getValue() != null) {
-                    param.setField(EParameterFieldType.PASSWORD.getName());
-                    if (reencryptValueIfNeeded(param)) {
-                        modified = true;
+    if (!checkNodesFromEmf(item, processType)) {
+        ComponentCategory category = ComponentCategory.getComponentCategoryFromItem(item);
+        for (Object nodeObjectType : processType.getNode()) {
+            NodeType nodeType = (NodeType) nodeObjectType;
+            IComponent component = ComponentsFactoryProvider.getInstance().get(nodeType.getComponentName(), category.getName());
+            if (component == null) {
+                continue;
+            }
+            FakeNode fNode = new FakeNode(component);
+            for (Object paramObjectType : nodeType.getElementParameter()) {
+                ElementParameterType param = (ElementParameterType) paramObjectType;
+                IElementParameter paramFromEmf = fNode.getElementParameter(param.getName());
+                if (paramFromEmf != null) {
+                    if (EParameterFieldType.PASSWORD.equals(paramFromEmf.getFieldType()) && param.getValue() != null) {
+                        param.setField(EParameterFieldType.PASSWORD.getName());
+                        if (reencryptValueIfNeeded(param)) {
+                            modified = true;
+                        }
                     }


Input:
public static ServiceTransitionCallback map(TransitionActions transition) {
    return map.get(transition);
}

Output:
 public static ServiceTransitionCallback map(TransitionActions transition) {
-    return map.get(transition);
+    return map.getUnchecked(transition);
 }


Input:
public boolean send(int source, Object message, int flags, int dest) {
    return false;
}

Output:
 public boolean send(int source, Object message, int flags, int dest) {
-    return false;
+    return delegete.sendMessage(source, message, dest, flags, sendRoutingParameters(source, dest));
 }


Input:
public void mouseDoubleClick(MouseEvent e) {
    Tree tree = (Tree) e.getSource();
    Point point = new Point(e.x, e.y);
    TreeItem item = tree.getItem(point);
    if (!item.getText().endsWith("String_Node_Str")) {
        Object obj = item.getData();
        if (obj instanceof AbstractFolderNode) {
            AbstractFolderNode node = (AbstractFolderNode) obj;
            node.loadChildren();
            Object[] children = node.getChildren();
            if (children != null) {
                item.setText(item.getText() + "String_Node_Str" + children.length + "String_Node_Str");
            }
            getCommonViewer().getTree().layout();
        }
    }
    super.mouseDoubleClick(e);
}

Output:
     TreeItem item = tree.getItem(point);
-    if (!item.getText().endsWith("String_Node_Str")) {
+    if (item != null && !item.getText().endsWith("String_Node_Str")) {
         Object obj = item.getData();


Input:
public synchronized void removeCommandListener(DisplaySelectListener li) {
    if (commandListeners != null && commandListeners.contains(li)) {
        Vector v = (Vector) commandListeners.clone();
        v.removeElement(li);
        commandListeners = v;
    }
}

Output:
 public synchronized void removeCommandListener(DisplaySelectListener li) {
-    if (commandListeners != null && commandListeners.contains(li)) {
-        Vector v = (Vector) commandListeners.clone();
-        v.removeElement(li);
-        commandListeners = v;
+    if (listeners != null && listeners.contains(li)) {
+        List temp = new ArrayList();
+        temp.addAll(listeners);
+        temp.remove(li);
+        listeners = temp;
     }


Input:
private void debugVertexBeforeComputation(Vertex<I, V, E> vertex, Iterable<M1> messages) {
    System.out.println("String_Node_Str" + vertex.getId() + "String_Node_Str");
    giraphScenarioWrapper.getContextWrapper().setSuperstepNoWrapper(getSuperstep());
    debugVertex(vertex);
    for (M1 message : messages) {
        giraphScenarioWrapper.getContextWrapper().addIncomingMessageWrapper(message);
        System.out.print("String_Node_Str" + message);
    }
    System.out.println("String_Node_Str" + vertex.getId() + "String_Node_Str");
}

Output:
     giraphScenarioWrapper.getContextWrapper().setSuperstepNoWrapper(getSuperstep());
-    debugVertex(vertex);
+    giraphScenarioWrapper.getContextWrapper().setVertexIdWrapper(vertex.getId());
+    giraphScenarioWrapper.getContextWrapper().setVertexValueBeforeWrapper(vertex.getValue());
+    Iterable<Edge<I, E>> returnVal = vertex.getEdges();
+    for (Edge<I, E> edge : returnVal) {
+        giraphScenarioWrapper.getContextWrapper().addNeighborWrapper(edge.getTargetVertexId(), edge.getValue());
+    }
     for (M1 message : messages) {


Input:
public QueryResult executeQuery(Client elasticClient, ActionRequestBuilder actionRequestBuilder, ProjectParsed queryData) throws ExecutionException {
    QueryResult queryResult = null;
    SearchRequestBuilder requestBuilder = (SearchRequestBuilder) actionRequestBuilder;
    try {
        ResultSet resultSet = new ResultSet();
        SearchResponse response = ((SearchRequestBuilder) requestBuilder).execute().actionGet();
        resultSet.setColumnMetadata(crossdatadataCreator.createColumnMetadata(queryData));
        if (queryData.getGroupBy() != null && !queryData.getGroupBy().getIds().isEmpty()) {
            processAggregation(queryData, resultSet, response);
        } else if (SelectorUtils.hasFunction(queryData.getSelect().getColumnMap(), "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
            processAggregationFucntion(queryData, resultSet, response);
        } else {
            processResults(queryData, resultSet, response);
        }
        queryResult = QueryResult.createQueryResult(resultSet, 0, true);
    } catch (IndexMissingException e) {
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str" + e.getMessage());
        }
        queryResult = QueryResult.createQueryResult(new ResultSet(), 0, true);
    }
    return queryResult;
}

Output:
 public QueryResult executeQuery(Client elasticClient, ActionRequestBuilder actionRequestBuilder, ProjectParsed queryData) throws ExecutionException {
-    QueryResult queryResult = null;
+    QueryResult queryResult;
     SearchRequestBuilder requestBuilder = (SearchRequestBuilder) actionRequestBuilder;


Input:
private void addGlobalStoreToSaveTransaction(SaveTransactionBuilder saveTransaction, Set<EntityRef> unsavedEntities) {
    GlobalStoreSaver globalStoreSaver = new GlobalStoreSaver(entityManager, prefabSerializer);
    for (StoreMetadata table : storeMetadata.values()) {
        globalStoreSaver.addStoreMetadata(table);
    }
    for (EntityRef entity : unsavedEntities) {
        globalStoreSaver.store(entity);
    }
    EntityData.GlobalStore globalStore = globalStoreSaver.save();
    saveTransaction.addGlobalStore(globalStore);
}

Output:
     EntityData.GlobalStore globalStore = globalStoreSaver.save();
-    saveTransaction.addGlobalStore(globalStore);
+    transactionBuilder.setGlobalStore(globalStore);
 }


Input:
public int compare(Object o1, Object o2) {
    Object[] sortKeys1 = ((GroupBoundaryInfo) o1).getSortKeys();
    Object[] sortKeys2 = ((GroupBoundaryInfo) o2).getSortKeys();
    boolean[] sortDirection = ((GroupBoundaryInfo) o1).getSortDirection();
    Comparator[] comparator = ((GroupBoundaryInfo) o1).getCollarComparator();
    int result = 0;
    for (int i = 0; i < sortKeys1.length; i++) {
        try {
            result = ScriptEvalUtil.compare(sortKeys1[i], sortKeys2[i], comparator[i]);
        } catch (DataException e) {
            result = 0;
        }
        if (result != 0) {
            if (sortDirection[i] == false) {
                result = result * -1;
            }
            break;
        }
    }
    return result;
}

Output:
     boolean[] sortDirection = ((GroupBoundaryInfo) o1).getSortDirection();
-    Comparator[] comparator = ((GroupBoundaryInfo) o1).getCollarComparator();
+    CompareHints[] comparator = ((GroupBoundaryInfo) o1).getCollarComparator();
     int result = 0;


Input:
public boolean apply(Game game, Ability source) {
    Player you = game.getPlayer(source.getControllerId());
    Card molten = game.getCard(source.getSourceId());
    if (you != null) {
        ElementalToken token = new ElementalToken();
        token.putOntoBattlefield(2, game, source.getId(), source.getControllerId());
        if (you.flipCoin(game)) {
            molten.moveToZone(Zone.HAND, source.getId(), game, true);
            game.informPlayers(you.getName() + "String_Node_Str" + you.getName() + "String_Node_Str");
        }
    }
    return false;
}

Output:
             molten.moveToZone(Zone.HAND, source.getId(), game, true);
-            game.informPlayers(you.getName() + "String_Node_Str" + you.getName() + "String_Node_Str");
+            game.informPlayers(new StringBuilder(you.getName()).append("String_Node_Str").append(you.getName()).append("String_Node_Str").toString());
         }


Input:
public int hashCode() {
    int hash;
    if (getApplicationName() != null) {
        hash = getApplicationName().hashCode();
    } else {
        hash = getLoader().hashCode();
    }
    return hash;
}

Output:
 public int hashCode() {
-    int hash;
-    if (getApplicationName() != null) {
-        hash = getApplicationName().hashCode();
-    } else {
-        hash = getLoader().hashCode();
-    }
-    return hash;
+    return 7;
 }


Input:
private static void listQuestion(FormDef f, QuestionDef q, FormEntryController fec, int indent, StringBuffer sb) {
    FormEntryModel femodel = fec.getModel();
    TreeElement instanceNode = getInstanceNode(f.getInstance(), q.getBind());
    String caption = "String_Node_Str";
    FormEntryPrompt fep = femodel.getQuestionPrompt();
    caption = getAppropriateTextForm(fep, fep.getTextID());
    int type = instanceNode.dataType;
    if (q.getControlType() != Constants.CONTROL_TRIGGER) {
        println(sb, indent, "String_Node_Str" + caption + "String_Node_Str");
        println(sb, indent + 1, "String_Node_Str" + printType(type));
    } else {
        println(sb, indent, "String_Node_Str" + caption + "String_Node_Str");
    }
    if (q.getControlType() == Constants.CONTROL_SELECT_ONE || q.getControlType() == Constants.CONTROL_SELECT_MULTI) {
        printChoices(f, q, fec, indent + 1, sb);
    }
    printProperty("String_Node_Str", f, instanceNode, indent + 1, sb);
    printProperty("String_Node_Str", f, instanceNode, indent + 1, sb);
    printProperty("String_Node_Str", f, instanceNode, indent + 1, sb);
    String defaultValue = printDefault(instanceNode);
    if (defaultValue != null) {
        println(sb, indent + 1, "String_Node_Str" + defaultValue);
    }
    if (instanceNode.getConstraint() != null) {
        println(sb, indent + 1, "String_Node_Str" + printCondition(instanceNode.getConstraint().constraint));
    }
    println(sb);
}

Output:
     FormEntryPrompt fep = femodel.getQuestionPrompt();
-    caption = getAppropriateTextForm(fep, fep.getTextID());
+    caption = fep.getLongText();
     int type = instanceNode.dataType;


Input:
public void testGlobalUpdateBatch() {
    List<TestGlobalEntity> entities = new ArrayList<TestGlobalEntity>();
    TestGlobalEntity entity1 = createGlobalEntity();
    TestGlobalEntity entity2 = createGlobalEntity();
    entities.add(entity1);
    entities.add(entity2);
    Number[] pks = cacheClient.globalSaveBatch(entities, CLUSTER_KLSTORAGE);
    List<TestGlobalEntity> before = cacheClient.findGlobalByPks(CLUSTER_KLSTORAGE, TestGlobalEntity.class, pks);
    for (TestGlobalEntity entity : before) {
        entity.setTestString("String_Node_Str");
    }
    cacheClient.globalUpdateBatch(before, CLUSTER_KLSTORAGE);
    List<TestGlobalEntity> after = cacheClient.findGlobalByPks(CLUSTER_KLSTORAGE, TestGlobalEntity.class, pks);
    for (int i = 0; i < after.size(); i++) {
        Assert.assertEquals(before.get(i), after.get(i));
    }
    cacheClient.globalRemoveByPks(pks, TestGlobalEntity.class, CLUSTER_KLSTORAGE);
    List<TestGlobalEntity> entitiesFromDB = cacheClient.findGlobalByPks(CLUSTER_KLSTORAGE, TestGlobalEntity.class, pks);
    Assert.assertTrue(entitiesFromDB.isEmpty());
}

Output:
     }
-    cacheClient.globalRemoveByPks(pks, TestGlobalEntity.class, CLUSTER_KLSTORAGE);
+    cacheClient.globalRemoveByPks(CLUSTER_KLSTORAGE, TestGlobalEntity.class, pks);
     List<TestGlobalEntity> entitiesFromDB = cacheClient.findGlobalByPks(CLUSTER_KLSTORAGE, TestGlobalEntity.class, pks);


Input:
protected String toInfeasibleInjectString() {
    throw new IllegalArgumentException("String_Node_Str" + this.toString());
}

Output:
 protected String toInfeasibleInjectString() {
-    throw new IllegalArgumentException("String_Node_Str" + this.toString());
+    return getNode() + "String_Node_Str";
 }


Input:
public void doExplode() {
    int r = this.callCount;
    if (!this.world().isRemote) {
        if (this.thread != null && this.thread.isComplete) {
            Iterator<Vector3> it = this.thread.results.iterator();
            while (it.hasNext()) {
                Vector3 targetPosition = it.next();
                double distance = targetPosition.add(position).magnitude();
                if (distance > r || distance < r - 3)
                    continue;
                Block blockID = targetPosition.getBlock(world());
                double hardness = targetPosition.getHardness(world());
                if (hardness < 0 || hardness > 10000)
                    continue;
                int metadata = this.world().getBlockMetadata(targetPosition.xi(), targetPosition.yi(), targetPosition.zi());
                if (distance < r - 1 || this.world().rand.nextInt(3) > 0) {
                    if (blockID == ICBMExplosion.blockExplosive) {
                        BlockExplosive.yinZha(this.world(), targetPosition.xi(), targetPosition.yi(), targetPosition.zi(), ((TileExplosive) this.world().getTileEntity(targetPosition.xi(), targetPosition.yi(), targetPosition.zi())).explosiveID, 1);
                    } else {
                        this.world().setBlockToAir(targetPosition.xi(), targetPosition.yi(), targetPosition.zi());
                    }
                    targetPosition.add(0.5D);
                    if (this.world().rand.nextFloat() < 0.3 * (this.getRadius() - r)) {
                        EntityFlyingBlock entity = new EntityFlyingBlock(this.world(), targetPosition, blockID, metadata);
                        this.world().spawnEntityInWorld(entity);
                        entity.yawChange = 50 * this.world().rand.nextFloat();
                        entity.pitchChange = 100 * this.world().rand.nextFloat();
                    }
                    it.remove();
                }
            }
        }
    }
    int radius = 2 * this.callCount;
    AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox(position.x() - radius, position.y() - radius, position.z() - radius, position.x() + radius, position.y() + radius, position.z() + radius);
    List<Entity> allEntities = this.world().getEntitiesWithinAABB(Entity.class, bounds);
    synchronized (allEntities) {
        for (Iterator it = allEntities.iterator(); it.hasNext(); ) {
            Entity entity = (Entity) it.next();
            if (entity instanceof EntityMissile) {
                ((EntityMissile) entity).setExplode();
                break;
            } else {
                double xDifference = entity.posX - position.x();
                double zDifference = entity.posZ - position.z();
                r = (int) this.getRadius();
                if (xDifference < 0)
                    r = (int) -this.getRadius();
                entity.motionX += (r - xDifference) * 0.02 * this.world().rand.nextFloat();
                entity.motionY += 3 * this.world().rand.nextFloat();
                r = (int) this.getRadius();
                if (zDifference < 0)
                    r = (int) -this.getRadius();
                entity.motionZ += (r - zDifference) * 0.02 * this.world().rand.nextFloat();
            }
        }
    }
    if (this.callCount > this.getRadius()) {
        this.controller.endExplosion();
    }
}

Output:
                 if (distance < r - 1 || this.world().rand.nextInt(3) > 0) {
-                    if (blockID == ICBMExplosion.blockExplosive) {
-                        BlockExplosive.yinZha(this.world(), targetPosition.xi(), targetPosition.yi(), targetPosition.zi(), ((TileExplosive) this.world().getTileEntity(targetPosition.xi(), targetPosition.yi(), targetPosition.zi())).explosiveID, 1);
+                    if (ent instanceof TileExplosive) {
+                        ((TileExplosive) ent).explode(1);
                     } else {


Input:
public boolean finalizeVirtualMachineProfile(VirtualMachineProfile<ConsoleProxyVO> profile, DeployDestination dest, ReservationContext context) {
    StringBuilder buf = profile.getBootArgsBuilder();
    buf.append("String_Node_Str");
    buf.append("String_Node_Str").append(_mgmt_host);
    buf.append("String_Node_Str").append(_mgmt_port);
    buf.append("String_Node_Str").append(profile.getVirtualMachine().getName());
    if (_sslEnabled) {
        buf.append("String_Node_Str");
    }
    buf.append("String_Node_Str").append(dest.getDataCenter().getId());
    buf.append("String_Node_Str").append(dest.getPod().getId());
    buf.append("String_Node_Str").append(profile.getId());
    buf.append("String_Node_Str").append(profile.getId());
    if (_disable_rp_filter) {
        buf.append("String_Node_Str");
    }
    boolean externalDhcp = false;
    String externalDhcpStr = _configDao.getValue("String_Node_Str");
    if (externalDhcpStr != null && externalDhcpStr.equalsIgnoreCase("String_Node_Str")) {
        externalDhcp = true;
    }
    NicProfile controlNic = null;
    NicProfile managementNic = null;
    for (NicProfile nic : profile.getNics()) {
        int deviceId = nic.getDeviceId();
        if (nic.getIp4Address() == null) {
            buf.append("String_Node_Str").append(deviceId).append("String_Node_Str").append("String_Node_Str");
            buf.append("String_Node_Str").append(deviceId).append("String_Node_Str").append("String_Node_Str");
        } else {
            buf.append("String_Node_Str").append(deviceId).append("String_Node_Str").append(nic.getIp4Address());
            buf.append("String_Node_Str").append(deviceId).append("String_Node_Str").append(nic.getNetmask());
        }
        if (nic.isDefaultNic()) {
            buf.append("String_Node_Str").append(nic.getGateway());
            buf.append("String_Node_Str").append(nic.getDns1());
            if (nic.getDns2() != null) {
                buf.append("String_Node_Str").append(nic.getDns2());
            }
        }
        if (nic.getTrafficType() == TrafficType.Management) {
            buf.append("String_Node_Str").append(dest.getPod().getGateway());
            managementNic = nic;
        } else if (nic.getTrafficType() == TrafficType.Control) {
            if (nic.getIp4Address() != null) {
                controlNic = nic;
            }
        }
    }
    if (externalDhcp) {
        buf.append("String_Node_Str");
    }
    if (controlNic == null) {
        assert (managementNic != null);
        controlNic = managementNic;
    }
    String bootArgs = buf.toString();
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("String_Node_Str" + profile + "String_Node_Str" + bootArgs);
    }
    profile.setParameter("String_Node_Str", controlNic);
    return true;
}

Output:
     }
-    profile.setParameter("String_Node_Str", controlNic);
+    profile.setParameter(VirtualMachineProfile.Param.ControlNic, controlNic);
     return true;


Input:
private void RemoveAllAvailableDbObjects() {
    availableDbObjectsTree.removeAll();
}

Output:
 private void RemoveAllAvailableDbObjects() {
-    availableDbObjectsTree.removeAll();
+    if (availableDbObjectsTree != null)
+        availableDbObjectsTree.removeAll();
 }


Input:
public void getEvents(String streamId, long startTime, long endTime, int limit, Function<? super StreamEvent, Boolean> callback) throws IOException, StreamNotFoundException, UnauthorizedException {
    URL url = config.resolveNamespacedURLV3(String.format("String_Node_Str", streamId, startTime, endTime, limit));
    HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
    AccessToken accessToken = config.getAccessToken();
    if (accessToken != null) {
        urlConn.setRequestProperty(HttpHeaders.AUTHORIZATION, accessToken.getTokenType() + "String_Node_Str" + accessToken.getValue());
    }
    if (urlConn instanceof HttpsURLConnection && !config.isVerifySSLCert()) {
        try {
            HttpRequests.disableCertCheck((HttpsURLConnection) urlConn);
        } catch (Exception e) {
        }
    }
    try {
        if (urlConn.getResponseCode() == HttpURLConnection.HTTP_UNAUTHORIZED) {
            throw new UnauthorizedException("String_Node_Str");
        }
        if (urlConn.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND) {
            throw new StreamNotFoundException(streamId);
        }
        if (urlConn.getResponseCode() == HttpURLConnection.HTTP_NO_CONTENT) {
            return;
        }
        JsonReader jsonReader = new JsonReader(new InputStreamReader(urlConn.getInputStream(), Charsets.UTF_8));
        jsonReader.beginArray();
        while (jsonReader.peek() != JsonToken.END_ARRAY) {
            Boolean result = callback.apply(GSON.<StreamEvent>fromJson(jsonReader, StreamEvent.class));
            if (result == null || !result) {
                break;
            }
        }
    } finally {
        urlConn.disconnect();
    }
}

Output:
         }
-        JsonReader jsonReader = new JsonReader(new InputStreamReader(urlConn.getInputStream(), Charsets.UTF_8));
+        InputStream inputStream = urlConn.getInputStream();
+        JsonReader jsonReader = new JsonReader(new InputStreamReader(inputStream, Charsets.UTF_8));
         jsonReader.beginArray();


Input:
private void generateLavaColumn(World world, int x, int topY, int z, Random rand) {
    if (rand.nextDouble() < Config.volcanoActiveToInactiveRatio) {
        world.setBlock(x, topY, z, BPBlocks.cracked_basalt);
    } else {
        world.setBlock(x, topY + 1, z, Blocks.lava);
        world.setBlock(x, topY, z, Blocks.lava);
    }
    for (int y = 10; y < topY; y++) {
        world.setBlock(x + 1, y, z, BPBlocks.basalt, 0, 0);
        world.setBlock(x - 1, y, z, BPBlocks.basalt, 0, 0);
        world.setBlock(x, y, z + 1, BPBlocks.basalt, 0, 0);
        world.setBlock(x, y, z - 1, BPBlocks.basalt, 0, 0);
        world.setBlock(x, y, z, Blocks.lava, 0, 0);
    }
}

Output:
     }
-    for (int y = 10; y < topY; y++) {
+    for (int y = topY - 1; y >= 10; y--) {
         world.setBlock(x + 1, y, z, BPBlocks.basalt, 0, 0);


Input:
private List<MetricDefinition> buildMetricDefList(List<Serie> result, String offset) throws Exception {
    String decodedOffset = urlDecodeUTF8(offset);
    List<MetricDefinition> metricDefinitionList = new ArrayList<>();
    for (Serie serie : result) {
        for (Map<String, Object> point : serie.getRows()) {
            String encodedMetricName = (String) point.get("String_Node_Str");
            if (offset != null) {
                if (encodedMetricName.compareTo(decodedOffset) <= 0) {
                    continue;
                }
            }
            Utils.SerieNameDecoder serieNameDecoder;
            try {
                serieNameDecoder = new Utils.SerieNameDecoder(encodedMetricName);
            } catch (Utils.SerieNameDecodeException e) {
                logger.warn("String_Node_Str", point.get("String_Node_Str"), e);
                continue;
            }
            MetricDefinition metricDefinition = new MetricDefinition(serieNameDecoder.getMetricName(), serieNameDecoder.getDimensions());
            metricDefinition.setId(urlEncodeUTF8(encodedMetricName));
            metricDefinitionList.add(metricDefinition);
            if (offset != null) {
                if (metricDefinitionList.size() >= Paged.LIMIT) {
                    return metricDefinitionList;
                }
            }
        }
    }
    return metricDefinitionList;
}

Output:
 private List<MetricDefinition> buildMetricDefList(List<Serie> result, String offset) throws Exception {
-    String decodedOffset = urlDecodeUTF8(offset);
+    String decodedOffset = null;
+    if (offset != null) {
+        decodedOffset = urlDecodeUTF8(offset);
+    }
     List<MetricDefinition> metricDefinitionList = new ArrayList<>();


Input:
public void run() {
    ClusterInstanceContext instanceContext = (ClusterInstanceContext) getAllNetworkPartitionCtxts().get(networkPartitionId).getInstanceContext(instanceId);
    boolean allMovedToObsolete = true;
    for (ClusterLevelPartitionContext partitionContext : instanceContext.getPartitionCtxts()) {
        if (log.isInfoEnabled()) {
            log.info("String_Node_Str" + getClusterId() + "String_Node_Str" + "String_Node_Str" + instanceContext.getNetworkPartitionId() + "String_Node_Str" + partitionContext.getPartitionId() + "String_Node_Str");
        }
        if (AutoscalerContext.getInstance().getAppMonitor(getAppId()).isForce()) {
            log.info(String.format("String_Node_Str", partitionContext.getPartitionId(), getAppId()));
            partitionContext.terminateAllRemainingInstances();
        }
        Iterator<MemberContext> pendingIterator = partitionContext.getPendingMembers().listIterator();
        List<String> pendingMemberIdList = new ArrayList<String>();
        while (pendingIterator.hasNext()) {
            MemberContext pendingMemberContext = pendingIterator.next();
            pendingMemberIdList.add(pendingMemberContext.getMemberId());
        }
        for (String memberId : pendingMemberIdList) {
            if (log.isDebugEnabled()) {
                log.debug("String_Node_Str" + memberId + "String_Node_Str");
            }
            partitionContext.movePendingMemberToObsoleteMembers(memberId);
        }
        allMovedToObsolete = partitionContext.getTotalMemberCount() == 0;
    }
    if (allMovedToObsolete) {
        monitor.monitor();
    }
}

Output:
 public void run() {
-    ClusterInstanceContext instanceContext = (ClusterInstanceContext) getAllNetworkPartitionCtxts().get(networkPartitionId).getInstanceContext(instanceId);
-    boolean allMovedToObsolete = true;
-    for (ClusterLevelPartitionContext partitionContext : instanceContext.getPartitionCtxts()) {
-        if (log.isInfoEnabled()) {
-            log.info("String_Node_Str" + getClusterId() + "String_Node_Str" + "String_Node_Str" + instanceContext.getNetworkPartitionId() + "String_Node_Str" + partitionContext.getPartitionId() + "String_Node_Str");
-        }
-        if (AutoscalerContext.getInstance().getAppMonitor(getAppId()).isForce()) {
-            log.info(String.format("String_Node_Str", partitionContext.getPartitionId(), getAppId()));
-            partitionContext.terminateAllRemainingInstances();
-        }
-        Iterator<MemberContext> pendingIterator = partitionContext.getPendingMembers().listIterator();
-        List<String> pendingMemberIdList = new ArrayList<String>();
-        while (pendingIterator.hasNext()) {
-            MemberContext pendingMemberContext = pendingIterator.next();
-            pendingMemberIdList.add(pendingMemberContext.getMemberId());
-        }
-        for (String memberId : pendingMemberIdList) {
-            if (log.isDebugEnabled()) {
-                log.debug("String_Node_Str" + memberId + "String_Node_Str");
+    NetworkPartitionContext networkPartitionContext = getAllNetworkPartitionCtxts().get(networkPartitionId);
+    ClusterInstanceContext instanceContext = (ClusterInstanceContext) networkPartitionContext.getInstanceContext(instanceId);
+    if (instanceContext != null) {
+        for (ClusterLevelPartitionContext partitionContext : instanceContext.getPartitionCtxts()) {
+            if (log.isInfoEnabled()) {
+                log.info("String_Node_Str" + getClusterId() + "String_Node_Str" + "String_Node_Str" + instanceContext.getNetworkPartitionId() + "String_Node_Str" + partitionContext.getPartitionId() + "String_Node_Str");
+            }
+            Iterator<MemberContext> activeIterator = partitionContext.getActiveMembers().listIterator();
+            List<String> activeMemberIdList = new ArrayList<String>();
+            while (activeIterator.hasNext()) {
+                MemberContext activeMemberContext = activeIterator.next();
+                activeMemberIdList.add(activeMemberContext.getMemberId());
+            }
+            for (String memberId : activeMemberIdList) {
+                if (log.isDebugEnabled()) {
+                    log.debug("String_Node_Str" + memberId + "String_Node_Str");
+                }
+                partitionContext.moveActiveMemberToTerminationPendingMembers(memberId);
+                if (partitionContext.getMemberStatsContext(memberId) != null) {
+                    partitionContext.removeMemberStatsContext(memberId);
+                }
+                if (log.isDebugEnabled()) {
+                    log.debug(String.format("String_Node_Str" + "String_Node_Str" + "String_Node_Str", memberId));
+                }
             }


Input:
public String toString() {
    return "String_Node_Str" + splunkURI + "String_Node_Str" + "String_Node_Str" + raw + "String_Node_Str" + "String_Node_Str" + ack + "String_Node_Str" + "String_Node_Str" + indexes + "String_Node_Str" + "String_Node_Str" + sourcetypes + "String_Node_Str" + "String_Node_Str" + sources + "String_Node_Str" + "String_Node_Str" + httpKeepAlive + "String_Node_Str" + "String_Node_Str" + validateCertificates + "String_Node_Str" + "String_Node_Str" + trustStorePath + "String_Node_Str" + "String_Node_Str" + socketTimeout + "String_Node_Str" + "String_Node_Str" + eventBatchTimeout + "String_Node_Str" + "String_Node_Str" + ackPollInterval + "String_Node_Str" + "String_Node_Str" + ackPollThreads + "String_Node_Str" + "String_Node_Str" + maxHttpConnPerChannel + "String_Node_Str" + "String_Node_Str" + totalHecChannels + "String_Node_Str" + "String_Node_Str" + getString(ENRICHEMENT_CONF) + "String_Node_Str" + "String_Node_Str" + maxBatchSize + "String_Node_Str" + "String_Node_Str" + numberOfThreads + "String_Node_Str" + "String_Node_Str" + lineBreaker + "String_Node_Str" + "String_Node_Str" + trackData;
}

Output:
 public String toString() {
-    return "String_Node_Str" + splunkURI + "String_Node_Str" + "String_Node_Str" + raw + "String_Node_Str" + "String_Node_Str" + ack + "String_Node_Str" + "String_Node_Str" + indexes + "String_Node_Str" + "String_Node_Str" + sourcetypes + "String_Node_Str" + "String_Node_Str" + sources + "String_Node_Str" + "String_Node_Str" + httpKeepAlive + "String_Node_Str" + "String_Node_Str" + validateCertificates + "String_Node_Str" + "String_Node_Str" + trustStorePath + "String_Node_Str" + "String_Node_Str" + socketTimeout + "String_Node_Str" + "String_Node_Str" + eventBatchTimeout + "String_Node_Str" + "String_Node_Str" + ackPollInterval + "String_Node_Str" + "String_Node_Str" + ackPollThreads + "String_Node_Str" + "String_Node_Str" + maxHttpConnPerChannel + "String_Node_Str" + "String_Node_Str" + totalHecChannels + "String_Node_Str" + "String_Node_Str" + getString(ENRICHEMENT_CONF) + "String_Node_Str" + "String_Node_Str" + maxBatchSize + "String_Node_Str" + "String_Node_Str" + numberOfThreads + "String_Node_Str" + "String_Node_Str" + lineBreaker + "String_Node_Str" + "String_Node_Str" + trackData;
+    return "String_Node_Str" + splunkURI + "String_Node_Str" + "String_Node_Str" + raw + "String_Node_Str" + "String_Node_Str" + ack + "String_Node_Str" + "String_Node_Str" + indexes + "String_Node_Str" + "String_Node_Str" + sourcetypes + "String_Node_Str" + "String_Node_Str" + sources + "String_Node_Str" + "String_Node_Str" + httpKeepAlive + "String_Node_Str" + "String_Node_Str" + validateCertificates + "String_Node_Str" + "String_Node_Str" + trustStorePath + "String_Node_Str" + "String_Node_Str" + socketTimeout + "String_Node_Str" + "String_Node_Str" + eventBatchTimeout + "String_Node_Str" + "String_Node_Str" + ackPollInterval + "String_Node_Str" + "String_Node_Str" + ackPollThreads + "String_Node_Str" + "String_Node_Str" + maxHttpConnPerChannel + "String_Node_Str" + "String_Node_Str" + totalHecChannels + "String_Node_Str" + "String_Node_Str" + getString(ENRICHMENT_CONF) + "String_Node_Str" + "String_Node_Str" + maxBatchSize + "String_Node_Str" + "String_Node_Str" + numberOfThreads + "String_Node_Str" + "String_Node_Str" + lineBreaker + "String_Node_Str" + "String_Node_Str" + maxOutstandingEvents + "String_Node_Str" + "String_Node_Str" + maxRetries + "String_Node_Str" + "String_Node_Str" + trackData;
 }


Input:
public void run() {
    checkExpired();
}

Output:
 public void run() {
-    checkExpired();
+    try {
+        checkTableHealthState();
+    } catch (Exception ex) {
+        logger.fatal("String_Node_Str");
+        ex.printStackTrace();
+    }
 }


Input:
private double distanceFromSky(int itemIndex) {
    C cell = positioner.getVisibleCell(itemIndex);
    return gravity.get() == Gravity.FRONT ? sizeTracker.getViewportLength() - orientation.maxY(cell) : orientation.minY(cell);
}

Output:
     C cell = positioner.getVisibleCell(itemIndex);
-    return gravity.get() == Gravity.FRONT ? sizeTracker.getViewportLength() - orientation.maxY(cell) : orientation.minY(cell);
+    int lastIndex = cellListManager.getLazyCellList().size() - 1;
+    return gravity.get() == Gravity.FRONT ? itemIndex == lastIndex ? 0 : sizeTracker.getViewportLength() - orientation.maxY(cell) : orientation.minY(cell);
 }


Input:
private static Object despawnPacket(int id) throws Exception {
    return despawnEntityConstructor.newInstance(new int[] { id });
}

Output:
 private static Object despawnPacket(int id) throws Exception {
-    return despawnEntityConstructor.newInstance(new int[] { id });
+    return DESPAWN_ENTITY_CONSTRUCTOR.newInstance(new int[] { id });
 }


Input:
public void run() throws IOException {
    log.info("String_Node_Str");
    CnfGrammarReader builder = new CnfGrammarReader();
    builder.loadFromFile(grammar);
    CnfGrammar grammar = builder.getGrammar(loopOrder);
    log.info("String_Node_Str" + grammar.getNumNonTerminals());
    log.info("String_Node_Str" + grammar.getNumLexicalTypes());
    log.info("String_Node_Str" + train);
    Alphabet<Label> lexAlphabet = new Alphabet<Label>();
    Alphabet<Label> ntAlphabet = new Alphabet<Label>();
    NaryTreebank naryTrees = readPtbTrees(lexAlphabet, ntAlphabet);
    log.info("String_Node_Str" + ntAlphabet.size());
    log.info("String_Node_Str" + lexAlphabet.size());
    log.info("String_Node_Str");
    removeNullElements(naryTrees);
    log.info("String_Node_Str");
    removeFunctionTagsAndTraces(naryTrees);
    log.info("String_Node_Str");
    useSignaturesForUnknownWords(naryTrees, grammar);
    if (treeFile != null) {
        log.info("String_Node_Str" + treeFile);
        naryTrees.writeTreesInOneLineFormat(treeFile);
        naryTrees.writeSentencesInOneLineFormat(treeFile + "String_Node_Str");
    }
    naryTrees.resetAlphabets(grammar.getLexAlphabet(), ntAlphabet);
    log.info("String_Node_Str" + naryTrees.size() + "String_Node_Str");
    BinaryTreebank binaryParses = new BinaryTreebank();
    Timer timer = new Timer();
    CkyPcfgParserPrm prm = new CkyPcfgParserPrm();
    prm.loopOrder = loopOrder;
    prm.cellType = cellType;
    prm.cacheChart = true;
    prm.parseType = ParseType.VITERBI;
    CkyPcfgParser parser = new CkyPcfgParser(prm);
    for (NaryTree tree : naryTrees) {
        Sentence sent = tree.getSentence();
        timer.start();
        Chart chart = parser.parseSentence(sent, grammar);
        timer.stop();
        Pair<BinaryTree, Double> pair = chart.getViterbiParse();
        binaryParses.add(pair.get1());
        log.debug("String_Node_Str" + timer.avgSec());
    }
    binaryParses.resetAlphabets(lexAlphabet, ntAlphabet);
    log.info("String_Node_Str");
    removeRefinements(binaryParses);
    log.info("String_Node_Str");
    NaryTreebank naryParses = binaryParses.collapseToNary(ntAlphabet);
    if (parseFile != null) {
        log.info("String_Node_Str" + parseFile);
        naryParses.writeTreesInOneLineFormat(parseFile);
    }
    if (evalbDir != null) {
        Evalb evalb = new Evalb(evalbDir);
        evalb.runEvalb(treeFile, parseFile, new File("String_Node_Str"));
    }
}

Output:
         Pair<BinaryTree, Double> pair = chart.getViterbiParse();
-        binaryParses.add(pair.get1());
+        BinaryTree parse = pair.get1();
+        if (parse == null) {
+            log.warn("String_Node_Str" + sent);
+        }
+        binaryParses.add(parse);
         log.debug("String_Node_Str" + timer.avgSec());


Input:
public void testGetSubtypes() throws NotFoundException {
    TypeOracle oracle = moduleContext.getOracle();
    JGenericType genericType = oracle.getType(MyList.class.getName()).isGenericType();
    JParameterizedType parameterizedType = oracle.getParameterizedType(genericType, new JClassType[] { integerType });
    JClassType[] actualSubtypes = parameterizedType.getSubtypes();
    JGenericType myCustomListType = oracle.getType(MyCustomList.class.getName()).isGenericType();
    JParameterizedType parameterizedMyCustomList = oracle.getParameterizedType(myCustomListType, new JClassType[] { oracle.getWildcardType(true, oracle.getType(Serializable.class.getName())), integerType });
    JClassType[] expected = { oracle.getType(MyIntegerList.class.getName()), parameterizedMyCustomList };
    validateEquals(oracle, expected, actualSubtypes);
}

Output:
     JGenericType myCustomListType = oracle.getType(MyCustomList.class.getName()).isGenericType();
-    JParameterizedType parameterizedMyCustomList = oracle.getParameterizedType(myCustomListType, new JClassType[] { oracle.getWildcardType(true, oracle.getType(Serializable.class.getName())), integerType });
+    JParameterizedType parameterizedMyCustomList = oracle.getParameterizedType(myCustomListType, new JClassType[] { oracle.getWildcardType(BoundType.EXTENDS, oracle.getType(Serializable.class.getName())), integerType });
     JClassType[] expected = { oracle.getType(MyIntegerList.class.getName()), parameterizedMyCustomList };


Input:
private int createValueListComposite(Composite parent) {
    if (valueListComposite != null && !valueListComposite.isDisposed()) {
        return 0;
    }
    disposeComposites();
    valueListComposite = new Composite(parent, SWT.NONE);
    GridData gdata = new GridData(GridData.FILL_HORIZONTAL);
    gdata.horizontalSpan = 4;
    valueListComposite.setLayoutData(gdata);
    GridLayout layout = new GridLayout();
    layout.numColumns = 4;
    valueListComposite.setLayout(layout);
    compositeList.add(valueListComposite);
    Group group = new Group(valueListComposite, SWT.NONE);
    GridData data = new GridData(GridData.FILL_HORIZONTAL);
    data.heightHint = 118;
    data.horizontalSpan = 3;
    data.horizontalIndent = 0;
    data.grabExcessHorizontalSpace = true;
    group.setLayoutData(data);
    layout = new GridLayout();
    layout.numColumns = 4;
    group.setLayout(layout);
    new Label(group, SWT.NONE).setText(Messages.getString("String_Node_Str"));
    GridData expgd = new GridData();
    expgd.widthHint = 100;
    addExpressionValue = new MultiValueCombo(group, SWT.NONE);
    addExpressionValue.setLayoutData(expgd);
    addBtn = new Button(group, SWT.PUSH);
    addBtn.setText(Messages.getString("String_Node_Str"));
    addBtn.setToolTipText(Messages.getString("String_Node_Str"));
    setButtonLayoutData(addBtn);
    addBtn.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            String value = addExpressionValue.getText().trim();
            if (valueList.indexOf(value) < 0) {
                valueList.add(value);
                tableViewer.refresh();
                updateButtons();
                addExpressionValue.setFocus();
                addExpressionValue.setText("String_Node_Str");
            } else {
                addBtn.setEnabled(false);
            }
        }
    });
    new Label(group, SWT.NONE);
    int tableStyle = SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION;
    table = new Table(group, tableStyle);
    data = new GridData(GridData.FILL_BOTH);
    data.horizontalSpan = 4;
    table.setLayoutData(data);
    table.setHeaderVisible(false);
    table.setLinesVisible(true);
    TableColumn column;
    int i;
    String[] columNames = new String[] { Messages.getString("String_Node_Str") };
    int[] columLength = new int[] { 288 };
    for (i = 0; i < columNames.length; i++) {
        column = new TableColumn(table, SWT.NONE, i);
        column.setText(columNames[i]);
        column.setWidth(columLength[i]);
    }
    table.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            checkEditDelButtonStatus();
        }
    });
    table.addKeyListener(new KeyListener() {
        public void keyPressed(KeyEvent e) {
            if (e.keyCode == SWT.DEL) {
                delTableValue();
            }
        }
        public void keyReleased(KeyEvent e) {
        }
    });
    table.addMouseListener(new MouseAdapter() {
        public void mouseDoubleClick(MouseEvent e) {
            editTableValue();
        }
    });
    tableViewer = new TableViewer(table);
    tableViewer.setUseHashlookup(true);
    tableViewer.setColumnProperties(columNames);
    tableViewer.setLabelProvider(tableLableProvier);
    tableViewer.setContentProvider(tableContentProvider);
    Composite rightPart = new Composite(valueListComposite, SWT.NONE);
    data = new GridData(GridData.FILL_BOTH | GridData.VERTICAL_ALIGN_END);
    rightPart.setLayoutData(data);
    layout = new GridLayout();
    layout.makeColumnsEqualWidth = true;
    rightPart.setLayout(layout);
    editBtn = new Button(rightPart, SWT.PUSH);
    editBtn.setText(Messages.getString("String_Node_Str"));
    editBtn.setToolTipText(Messages.getString("String_Node_Str"));
    setButtonLayoutData(editBtn);
    editBtn.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }

        public void widgetSelected(SelectionEvent e) {
            editTableValue();
        }
    });
    delBtn = new Button(rightPart, SWT.PUSH);
    delBtn.setText(Messages.getString("String_Node_Str"));
    delBtn.setToolTipText(Messages.getString("String_Node_Str"));
    setButtonLayoutData(delBtn);
    delBtn.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            delTableValue();
        }
    });
    delAllBtn = new Button(rightPart, SWT.PUSH);
    delAllBtn.setText(Messages.getString("String_Node_Str"));
    delAllBtn.setToolTipText(Messages.getString("String_Node_Str"));
    setButtonLayoutData(delAllBtn);
    delAllBtn.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            int count = valueList.size();
            if (count > 0) {
                valueList.clear();
                tableViewer.refresh();
                updateButtons();
            } else {
                delAllBtn.setEnabled(false);
            }
        }
    });
    addExpressionValue.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            checkAddButtonStatus();
            updateButtons();
        }
    });
    addExpressionValue.addSelectionListener(0, mAddSelValueAction);
    addExpressionValue.addSelectionListener(1, mAddExpValueAction);
    addExpressionValue.setItems(popupItems);
    parent.getParent().layout(true, true);
    if (parent.getShell() != null)
        parent.getShell().pack();
    return 1;
}

Output:
     setButtonLayoutData(editBtn);
-    editBtn.addSelectionListener(new SelectionListener() {
-        public void widgetDefaultSelected(SelectionEvent e) {
-        }
+    editBtn.addSelectionListener(new SelectionAdapter() {


Input:
public boolean detectSafeMode() {
    try {
        int menuState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_MENU);
        int sState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_S);
        int dpadState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_DPAD_CENTER);
        int trackballState = mWindowManager.getScancodeState(RawInputEvent.BTN_MOUSE);
        mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0;
        performHapticFeedbackLw(null, mSafeMode ? HapticFeedbackConstants.SAFE_MODE_ENABLED : HapticFeedbackConstants.SAFE_MODE_DISABLED, true);
        if (mSafeMode) {
            Log.i(TAG, "String_Node_Str" + menuState + "String_Node_Str" + sState + "String_Node_Str" + dpadState + "String_Node_Str" + trackballState + "String_Node_Str");
        } else {
            Log.i(TAG, "String_Node_Str");
        }
        return mSafeMode;
    } catch (RemoteException e) {
        throw new RuntimeException("String_Node_Str");
    }
}

Output:
         int sState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_S);
-        int dpadState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_DPAD_CENTER);
-        int trackballState = mWindowManager.getScancodeState(RawInputEvent.BTN_MOUSE);
+        int dpadState = mWindowManager.getDPadKeycodeState(KeyEvent.KEYCODE_DPAD_CENTER);
+        int trackballState = mWindowManager.getTrackballScancodeState(RawInputEvent.BTN_MOUSE);
         mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0;