Input:
public void init() {
    System.out.println("String_Node_Str");
    SpringLayout<P2PVertex, P2PConnection> sp_layout = null;
    try {
        BufferedReader in;
        if (ontheweb) {
            URL yahoo = new URL(DEF_LOG_URL);
            in = new BufferedReader(new InputStreamReader(yahoo.openStream()));
        } else {
            if (mylogfile == null)
                in = new BufferedReader(new FileReader(DEF_LOG_FILE));
            else {
                in = new BufferedReader(new FileReader(mylogfile));
                System.out.println("String_Node_Str" + mylogfile.getAbsolutePath());
            }
        }
        myGraphEvolution = new LinkedList<LogEvent>();
        hiddenGraph = new P2PNetworkGraph();
        sp_layout = new SpringLayout<P2PVertex, P2PConnection>(hiddenGraph, new P2PNetEdgeLengthFunction());
        sp_layout.setSize(new Dimension(DEFWIDTH, DEFHEIGHT));
        sp_layout.setForceMultiplier(0.6);
        sp_layout.setInitializer(new P2PVertexPlacer(sp_layout, new Dimension(DEFWIDTH, DEFHEIGHT)));
        sp_layout.initialize();
        String str;
        List<LogEvent> colouringEvents = new LinkedList<LogEvent>();
        List<P2PVertex> queryPeers = new LinkedList<P2PVertex>();
        int totalLines = Integer.parseInt(in.readLine());
        int lineCount = 0;
        myGraphEvolution.add(new LogEvent("String_Node_Str"));
        while ((str = in.readLine()) != null) {
            lineCount++;
            LogEvent gev = new LogEvent(str);
            if (gev.isConstructing()) {
                graphConstructionEvent(gev, hiddenGraph);
                sp_layout.step();
                sp_layout.step();
            }
            if (gev.getType().equals("String_Node_Str") || gev.getType().equals("String_Node_Str")) {
                colouringEvents.add(LogEvent.createOpposingLogEvent(gev, 2000));
                if (gev.getType().equals("String_Node_Str")) {
                    queryPeers.add(new PeerVertex(gev.getParam(1)));
                }
            } else if (gev.getType().equals("String_Node_Str")) {
                colouringEvents.add(LogEvent.createOpposingLogEvent(gev, 750));
                P2PVertex queriedPeer = new PeerVertex(gev.getParam(1));
                for (P2PVertex querySender : queryPeers) {
                    if (hiddenGraph.findEdge(querySender, queriedPeer) != null) {
                        LogEvent ev = new LogEvent(gev.getTime() + 1, "String_Node_Str", querySender.getKey(), queriedPeer.getKey());
                        colouringEvents.add(ev);
                        colouringEvents.add(LogEvent.createOpposingLogEvent(ev, 750));
                        break;
                    }
                }
                queryPeers.add(queriedPeer);
            }
            Collections.sort(colouringEvents);
            for (Iterator<LogEvent> iter = colouringEvents.iterator(); iter.hasNext(); ) {
                LogEvent event = (LogEvent) iter.next();
                if (event.getTime() < gev.getTime()) {
                    myGraphEvolution.addLast(event);
                    iter.remove();
                } else {
                    break;
                }
            }
            myGraphEvolution.addLast(gev);
        }
        myGraphEvolution.add(new LogEvent((myGraphEvolution.getLast().getTime()) + "String_Node_Str"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    layout = sp_layout;
    visibleGraph = new P2PNetworkGraph();
    vv = new VisualizationViewer<P2PVertex, P2PConnection>(layout, new Dimension(DEFWIDTH, DEFHEIGHT));
    JRootPane rp = this.getRootPane();
    rp.putClientProperty("String_Node_Str", Boolean.TRUE);
    getContentPane().setLayout(new BorderLayout());
    getContentPane().setFont(new Font("String_Node_Str", Font.PLAIN, 12));
    getContentPane().setBounds(0, 0, DEFWIDTH, DEFHEIGHT);
    DefaultModalGraphMouse<P2PVertex, P2PConnection> gm = new DefaultModalGraphMouse<P2PVertex, P2PConnection>();
    vv.setGraphMouse(gm);
    vv.getRenderer().getVertexLabelRenderer().setPosition(Renderer.VertexLabel.Position.CNTR);
    vv.getRenderContext().setVertexLabelTransformer(new ToStringLabeller<P2PVertex>());
    vv.getRenderContext().setVertexShapeTransformer(new P2PVertexShapeTransformer());
    vv.getRenderContext().setEdgeStrokeTransformer(new P2PEdgeStrokeTransformer());
    vv.getRenderContext().setEdgeShapeTransformer(new P2PEdgeShapeTransformer());
    vv.getRenderContext().setVertexFillPaintTransformer(new P2PVertexFillPaintTransformer(vv.getPickedVertexState()));
    vv.getRenderContext().setVertexStrokeTransformer(new P2PVertexStrokeTransformer());
    vv.setForeground(Color.white);
    eventthread = new EventPlayingThread(myGraphEvolution);
    vv.addComponentListener(new ComponentAdapter() {
        public void componentResized(ComponentEvent arg0) {
            super.componentResized(arg0);
            layout.setSize(arg0.getComponent().getSize());
        }
    });
    JPanel graphsPanel = new JPanel();
    graphsPanel.add(vv);
    Relaxer relaxer = new VisRunner((IterativeContext) layout);
    relaxer.stop();
    relaxer.setSleepTime(80L);
    relaxer.relax();
    relaxerButton = new JButton("String_Node_Str");
    relaxerButton.addActionListener(new relaxerButtonListener(relaxer));
    stopButton = new JButton("String_Node_Str");
    stopButton.addActionListener(new StopButtonListener());
    fastReverseButton = new JButton("String_Node_Str");
    fastReverseButton.addActionListener(new FastReverseButtonListener());
    reverseButton = new JButton("String_Node_Str");
    reverseButton.addActionListener(new ReverseButtonListener());
    pauseButton = new JButton("String_Node_Str");
    pauseButton.addActionListener(new PauseButtonListener());
    forwardButton = new JButton("String_Node_Str");
    forwardButton.addActionListener(new ForwardButtonListener());
    fastforwardButton = new JButton("String_Node_Str");
    fastforwardButton.addActionListener(new FastforwardButtonListener());
    playbackSlider = new JSlider(JSlider.HORIZONTAL, 0, (int) myGraphEvolution.getLast().getTime(), 0);
    playbackSlider.addChangeListener(new SliderListener());
    playbackSlider.setMajorTickSpacing(playbackSlider.getExtent() / 4);
    playbackSlider.setMajorTickSpacing(playbackSlider.getExtent() / 8);
    playbackSlider.setPaintTicks(true);
    playbackSlider.setPaintLabels(false);
    playbackSlider.setBackground(Color.GRAY);
    playbackSlider.setForeground(Color.BLUE);
    GridBagLayout southLayout = new GridBagLayout();
    GridBagConstraints southConstraints = new GridBagConstraints();
    JPanel south = new JPanel();
    south.setBackground(Color.GRAY);
    south.setLayout(new GridLayout(2, 1));
    JPanel buttonPanel = new JPanel();
    buttonPanel.setBackground(Color.GRAY);
    buttonPanel.setLayout(southLayout);
    buttonPanel.add(fastReverseButton);
    buttonPanel.add(reverseButton);
    buttonPanel.add(pauseButton);
    buttonPanel.add(forwardButton);
    southConstraints.gridwidth = GridBagConstraints.REMAINDER;
    southLayout.setConstraints(fastforwardButton, southConstraints);
    buttonPanel.add(fastforwardButton);
    south.add(buttonPanel);
    south.add(playbackSlider);
    stopButton.setEnabled(false);
    fastReverseButton.setEnabled(false);
    reverseButton.setEnabled(false);
    pauseButton.setEnabled(false);
    forwardButton.setEnabled(false);
    fastforwardButton.setEnabled(false);
    playbackSlider.setEnabled(false);
    GridBagLayout westLayout = new GridBagLayout();
    GridBagConstraints westConstraints = new GridBagConstraints();
    JPanel west = new JPanel();
    west.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    west.setBackground(Color.GRAY);
    west.setLayout(westLayout);
    JPanel p = new JPanel();
    p.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    p.setBackground(Color.GRAY);
    p.add(gm.getModeComboBox());
    westConstraints.gridwidth = GridBagConstraints.REMAINDER;
    westLayout.setConstraints(p, westConstraints);
    west.add(p);
    westLayout.setConstraints(relaxerButton, westConstraints);
    west.add(relaxerButton);
    westLayout.setConstraints(stopButton, westConstraints);
    west.add(stopButton);
    getContentPane().add(graphsPanel, BorderLayout.CENTER);
    getContentPane().add(south, BorderLayout.SOUTH);
    getContentPane().add(west, BorderLayout.WEST);
}

Output:
     playbackSlider = new JSlider(JSlider.HORIZONTAL, 0, (int) myGraphEvolution.getLast().getTime(), 0);
-    playbackSlider.addChangeListener(new SliderListener());
+    SliderListener s = new SliderListener();
+    playbackSlider.addChangeListener(s);
+    playbackSlider.addMouseListener(s);
     playbackSlider.setMajorTickSpacing(playbackSlider.getExtent() / 4);


Input:
public void messageReceived(ConnectorMessageEvent event) {
    String message = event.getMessage();
    for (String responseHeader : responseHeaders) {
        if (message.startsWith(responseHeader) || message.startsWith("String_Node_Str")) {
            responses.add(message);
            return;
        }
    }
}

Output:
     String message = event.getMessage();
-    for (String responseHeader : responseHeaders) {
-        if (message.startsWith(responseHeader) || message.startsWith("String_Node_Str")) {
-            responses.add(message);
-            return;
-        }
+    if (responseChecker.isTarget(message) || message.startsWith("String_Node_Str")) {
+        responses.add(message);
     }


Input:
private void openConfig() {
    int index = configTable.getSelectionIndex();
    if (index >= 0) {
        JettyLaunchConfigEntry entry = configEntryList.get(index);
        IWorkbench workbench = PlatformUI.getWorkbench();
        IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorInput input = null;
        IEditorDescriptor descriptor = null;
        switch(entry.getType()) {
            case DEFAULT:
                try {
                    ILaunchConfiguration configuration = getCurrentLaunchConfiguration();
                    ILaunchDelegate[] delegates = configuration.getType().getDelegates(new HashSet<String>(Arrays.asList("String_Node_Str")));
                    if (delegates.length == 1) {
                        JettyLaunchConfigurationDelegate delegate = (JettyLaunchConfigurationDelegate) delegates[0].getDelegate();
                        File file = delegate.createJettyConfigurationFile(configuration, true);
                        descriptor = workbench.getEditorRegistry().getDefaultEditor(file.getName());
                        input = new FileStoreEditorInput(EFS.getLocalFileSystem().fromLocalFile(file));
                    }
                } catch (CoreException ex) {
                    JettyPlugin.error("String_Node_Str", ex);
                }
                break;
            case PATH:
                {
                    File file = new File(entry.getPath());
                    descriptor = workbench.getEditorRegistry().getDefaultEditor(file.getName());
                    input = new FileStoreEditorInput(EFS.getLocalFileSystem().fromLocalFile(file));
                }
                break;
            case WORKSPACE:
                {
                    IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(entry.getPath()));
                    descriptor = workbench.getEditorRegistry().getDefaultEditor(file.getName());
                    input = new FileEditorInput(file);
                }
                break;
        }
        try {
            IDE.openEditor(page, input, descriptor.getId());
        } catch (PartInitException ex) {
            JettyPlugin.error("String_Node_Str", ex);
        }
    }
}

Output:
         }
-        try {
-            IDE.openEditor(page, input, descriptor.getId());
-        } catch (PartInitException ex) {
-            JettyPlugin.error("String_Node_Str", ex);
+        if (descriptor != null) {
+            try {
+                IDE.openEditor(page, input, descriptor.getId());
+            } catch (PartInitException ex) {
+                JettyPlugin.error("String_Node_Str", ex);
+            }
         }


Input:
private static void handleProviderAdded(ProtocolProviderService protocolProvider) {
    if (protocolProvider.getOperationSet(OperationSetServerStoredContactInfo.class) != null && protocolProvider.isRegistered() && !phoneProviders.contains(protocolProvider)) {
        phoneProviders.add(protocolProvider);
    }
}

Output:
 private static void handleProviderAdded(ProtocolProviderService protocolProvider) {
-    if (protocolProvider.getOperationSet(OperationSetServerStoredContactInfo.class) != null && protocolProvider.isRegistered() && !phoneProviders.contains(protocolProvider)) {
-        phoneProviders.add(protocolProvider);
+    if (protocolProvider.getOperationSet(OperationSetServerStoredContactInfo.class) != null && !phoneProviders.contains(protocolProvider)) {
+        if (protocolProvider.isRegistered()) {
+            phoneProviders.add(protocolProvider);
+        } else {
+            protocolProvider.addRegistrationStateChangeListener(ppRegListener);
+        }
     }


Input:
public void testSecuritiesWithoutAssignment() {
    Client client = new Client();
    Taxonomy taxonomy = new TaxonomyBuilder().addClassification("String_Node_Str").addTo(client);
    Security a = new SecurityBuilder().addPrice("String_Node_Str", 1000).addTo(client);
    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", 1000000, 10000).addTo(client);
    PortfolioSnapshot snapshot = PortfolioSnapshot.create(portfolio, new DateTime("String_Node_Str").toDate());
    assertNotNull(snapshot);
    GroupByTaxonomy grouping = snapshot.groupByTaxonomy(taxonomy);
    AssetCategory debt = grouping.byClassification(taxonomy.getClassificationById("String_Node_Str"));
    assertThat(debt, nullValue());
    List<AssetCategory> categories = grouping.asList();
    assertThat(categories.size(), is(1));
    AssetCategory unassigned = categories.get(0);
    assertThat(unassigned.getValuation(), is(10000L));
    assertThat(unassigned.getPositions().size(), is(1));
}

Output:
     Security a = new SecurityBuilder().addPrice("String_Node_Str", 1000).addTo(client);
-    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", 1000000, 10000).addTo(client);
+    Portfolio portfolio = new PortfolioBuilder().inbound_delivery(a, "String_Node_Str", Values.Share.factorize(10), 10000).addTo(client);
     PortfolioSnapshot snapshot = PortfolioSnapshot.create(portfolio, new DateTime("String_Node_Str").toDate());


Input:
public void onAnimationEnd(Animator animation) {
    removeAt(position);
    EventBus.getDefault().send(new DeleteTaskDataEvent(taskCardView.getTask()));
}

Output:
     removeAt(position);
-    EventBus.getDefault().send(new DeleteTaskDataEvent(taskCardView.getTask()));
+    EventBus.getDefault().send(new DeleteTaskDataEvent(task));
 }


Input:
private boolean checkLimits(MapContainer mapContainer) {
    MaxSizeConfig maxSizeConfig = mapContainer.getMapConfig().getMaxSizeConfig();
    MaxSizeConfig.MaxSizePolicy maxSizePolicy = maxSizeConfig.getMaxSizePolicy();
    String mapName = mapContainer.getName();
    int maxSize = maxSizeConfig.getSize() * 95 / 100;
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
        int totalSize = 0;
        for (int i = 0; i < nodeEngine.getPartitionService().getPartitionCount(); i++) {
            Address owner = nodeEngine.getPartitionService().getPartitionOwner(i);
            if (nodeEngine.getThisAddress().equals(owner)) {
                int size = partitionContainers[i].getRecordStore(mapName).getRecords().size();
                if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
                    if (size >= maxSize)
                        return true;
                } else {
                    totalSize += size;
                }
            }
        }
        if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_NODE)
            return totalSize >= maxSize;
        else
            return false;
    }
    if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE || maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_PERCENTAGE) {
        long total = Runtime.getRuntime().totalMemory();
        long used = (total - Runtime.getRuntime().freeMemory());
        if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.USED_HEAP_SIZE) {
            return maxSize > (used / 1024 / 1024);
        } else {
            return maxSize > (used / total);
        }
    }
    return false;
}

Output:
                 if (maxSizePolicy == MaxSizeConfig.MaxSizePolicy.PER_PARTITION) {
-                    if (size >= maxSize)
+                    if (size >= maxSize) {
                         return true;


Input:
private void mapValuesToFields(T instance, Object[] row, ParsingContext context) {
    if (!fieldIndexesMapped) {
        mapFieldIndexes(row, context.headers(), context.extractedFieldIndexes(), context.columnsReordered());
    }
    int last = row.length < readOrder.length ? row.length : readOrder.length;
    for (int i = 0; i < last; i++) {
        FieldMapping field = readOrder[i];
        if (field != null) {
            Object value = row[i];
            field.write(instance, value);
        }
    }
}

Output:
 private void mapValuesToFields(T instance, Object[] row, ParsingContext context) {
-    if (!fieldIndexesMapped) {
+    if (row.length > lastFieldIndexMapped) {
+        this.lastFieldIndexMapped = row.length;
         mapFieldIndexes(row, context.headers(), context.extractedFieldIndexes(), context.columnsReordered());


Input:
public void onClick(final View view) {
    WelcomeUtils.markUserRefusedSignInDuringOnboarding(mActivity, true);
    doNext();
}

Output:
 public void onClick(final View view) {
-    WelcomeUtils.markUserRefusedSignInDuringOnboarding(mActivity, true);
+    WelcomeUtils.markUserRefusedOnboardingSignIn(mActivity);
     doNext();


Input:
public V10Teleport teleport(Entity entity, Location oloc, V10Location locTo, Vector vector, boolean really) {
    if (entity == null || entity.isDead() || blockedEntities.contains(entity))
        return null;
    Region regionTo = plugin.regionManager.getRegion(locTo);
    Portal portal = plugin.portalManager.insideBlocks.get(locTo);
    if (portal == null) {
        if ((entity instanceof FallingBlock || entity instanceof TNTPrimed) && vector.getX() == 0.0D && vector.getZ() == 0.0D) {
            portal = plugin.portalManager.awayBlocksY.get(locTo);
        } else if ((Math.abs(vector.getX()) > 0.5 || (Math.abs(vector.getY()) > 1 || (Math.abs(vector.getZ()) > 0.5))) || entity instanceof Boat) {
            portal = plugin.portalManager.awayBlocks.get(locTo);
            if (portal == null)
                return null;
            Block to = locTo.getHandle().getBlock();
            for (int i = 0; i < 2; i++) {
                BlockFace face = portal.awayBlocksY[i].getHandle().getBlock().getFace(to);
                if (face == null)
                    continue;
                if (face != BlockFace.SELF) {
                    double x = 1.0D, z = 1.0D;
                    switch(face) {
                        case NORTH_WEST:
                            z = 0.5D;
                        case NORTH:
                            x = 1.5D;
                            break;
                        case NORTH_EAST:
                            x = 1.5D;
                        case EAST:
                            z = 1.5D;
                            break;
                        case SOUTH_EAST:
                            z = 1.5D;
                        case SOUTH:
                            x = 0.5D;
                            break;
                        case SOUTH_WEST:
                            x = 0.5D;
                        default:
                            z = 0.5D;
                    }
                    if (oloc.getX() - locTo.x > x || oloc.getZ() - locTo.z > z)
                        return null;
                } else {
                    System.out.print("String_Node_Str");
                    break;
                }
            }
        } else
            return null;
    }
    if (!portal.open || portal.disabled || (Math.abs(vector.getY()) > 1 && !portal.vertical))
        return null;
    Portal destination = portal.getDestination();
    Location teleport = destination.teleport.getHandle();
    teleport.setX(teleport.getX() + 0.5D);
    teleport.setZ(teleport.getZ() + 0.5D);
    float yaw = entity.getLocation().getYaw();
    float pitch = entity.getLocation().getPitch();
    float startyaw = yaw;
    switch(portal.teleportFace) {
        case EAST:
            yaw -= 90;
            break;
        case SOUTH:
            yaw -= 180;
            break;
        case WEST:
            yaw -= 270;
            break;
        case DOWN:
            teleport.add(0, 1, 0);
        case UP:
            yaw = pitch;
            pitch = 0;
            break;
    }
    double momentum = 0.0;
    switch(portal.teleportFace) {
        case NORTH:
        case SOUTH:
            momentum = vector.getX();
            break;
        case EAST:
        case WEST:
            momentum = vector.getZ();
            break;
        case UP:
        case DOWN:
            momentum = vector.getY();
            break;
    }
    momentum = Math.abs(momentum);
    momentum *= regionTo.getDouble(RegionSetting.VELOCITY_MULTIPLIER);
    Vector outvector = entity.getVelocity().zero();
    switch(destination.teleportFace) {
        case NORTH:
            yaw += 180;
            outvector = outvector.setX(momentum);
            break;
        case EAST:
            yaw += 270;
            outvector = outvector.setZ(momentum);
            break;
        case SOUTH:
            yaw += 360;
            outvector = outvector.setX(-momentum);
            break;
        case WEST:
            yaw += 450;
            outvector = outvector.setZ(-momentum);
            break;
        case DOWN:
            if (portal.teleportFace != BlockFace.UP && portal.teleportFace != BlockFace.DOWN) {
                yaw = pitch;
                pitch = startyaw;
            } else {
                pitch = yaw;
                yaw = startyaw;
            }
            outvector = outvector.setY(momentum);
            break;
        case UP:
            if (portal.teleportFace != BlockFace.UP && portal.teleportFace != BlockFace.DOWN) {
                yaw = pitch;
                pitch = startyaw + 180;
            } else {
                pitch = yaw;
                yaw = startyaw;
            }
            outvector = outvector.setY(-momentum);
            break;
    }
    if (!(entity instanceof Player) && !(entity instanceof Chicken) && momentum < 0.5 && (portal.teleportFace == BlockFace.UP || portal.teleportFace == BlockFace.DOWN) && (destination.teleportFace == BlockFace.UP || destination.teleportFace == BlockFace.DOWN))
        teleport.setX(teleport.getX() + 0.5D);
    entity.setFallDistance(0);
    teleport.setPitch(pitch);
    teleport.setYaw(yaw);
    if (entity instanceof Arrow)
        teleport.setY(teleport.getY() + 0.5);
    if (really) {
        if (!entity.teleport(teleport))
            return null;
        entity.setVelocity(outvector);
    }
    destination.disabled = true;
    plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new enablePortal(destination), 10L);
    if (portal.orange)
        plugin.util.PlaySound(Sound.PORTAL_EXIT_ORANGE, entity instanceof Player ? (Player) entity : null, new V10Location(teleport));
    else
        plugin.util.PlaySound(Sound.PORTAL_EXIT_BLUE, entity instanceof Player ? (Player) entity : null, new V10Location(teleport));
    return new V10Teleport(teleport, outvector);
}

Output:
                         case NORTH:
-                            x = 1.5D;
+                            x = 0.5D;
+                            nwf = true;
                             break;


Input:
public AutoFillPlayers parseServerSections(TabListConfig config, SlotTemplate g_prefix, SlotTemplate g_suffix, List<String> g_filter, List<String> g_sort, int g_maxPlayers, List<SlotTemplate> playerLines, List<SlotTemplate> morePlayerLines) {
    Map<String, ServerInfo> servers = ProxyServer.getInstance().getServers();
    Set<String> serverSet = new HashSet<>(servers.keySet());
    HashMultimap<String, String> aliasToServerMap = HashMultimap.create();
    for (Map.Entry<String, String> entry : BungeeTabListPlus.getInstance().getConfigManager().getMainConfig().serverAlias.entrySet()) {
        if (ProxyServer.getInstance().getServerInfo(entry.getKey()) == null) {
            BungeeTabListPlus.getInstance().getLogger().warning("String_Node_Str" + entry.getKey() + "String_Node_Str");
            continue;
        }
        aliasToServerMap.put(entry.getValue(), entry.getKey());
    }
    List<ServerGroup> list = new ArrayList<>();
    while (!serverSet.isEmpty()) {
        String server = serverSet.iterator().next();
        String alias = BungeeTabListPlus.getInstance().getConfigManager().getMainConfig().serverAlias.get(server);
        if (alias != null) {
            Set<String> strings = aliasToServerMap.get(alias);
            serverSet.removeAll(strings);
            list.add(GenericServerGroup.of(serverSet, alias));
        } else {
            serverSet.remove(server);
            list.add(GenericServerGroup.of(server));
        }
    }
    List<Function<ServerGroup, Section>> sections = new ArrayList<>();
    for (String line : config.groupLines) {
        final int[] startColumn = { -1 };
        final List<String> sortrules = new ArrayList<>();
        final int[] maxplayers = { g_maxPlayers };
        line = findTag(line, PATTERN_ALIGN_LEFT, matcher -> {
            if (config.verticalMode) {
                plugin.getLogger().warning("String_Node_Str");
            } else {
                startColumn[0] = 0;
            }
        });
        line = findTag(line, PATTERN_ALIGN_RIGHT, matcher -> {
            if (config.verticalMode) {
                plugin.getLogger().warning("String_Node_Str");
            } else {
                startColumn[0] = ConfigManager.getCols() - 1;
            }
        });
        line = findTag(line, PATTERN_SORT, matcher -> {
            sortrules.addAll(Arrays.asList(matcher.group(1).split("String_Node_Str")));
        });
        line = findTag(line, PATTERN_COLUMN, matcher -> {
            if (config.verticalMode) {
                plugin.getLogger().warning("String_Node_Str");
            } else {
                startColumn[0] = Integer.parseInt(matcher.group(1));
                if (startColumn[0] > ConfigManager.getCols()) {
                    plugin.getLogger().warning(String.format("String_Node_Str", startColumn[0], ConfigManager.getCols(), ConfigManager.getCols() - 1));
                    startColumn[0] = ConfigManager.getCols() - 1;
                }
            }
        });
        line = findTag(line, PATTERN_ROW, matcher -> {
            if (!config.verticalMode) {
                plugin.getLogger().warning("String_Node_Str");
            } else {
                startColumn[0] = Integer.parseInt(matcher.group(1));
                if (startColumn[0] > ConfigManager.getRows()) {
                    plugin.getLogger().warning(String.format("String_Node_Str", startColumn[0], ConfigManager.getRows(), ConfigManager.getRows() - 1));
                    startColumn[0] = ConfigManager.getRows() - 1;
                }
            }
        });
        line = findTag(line, PATTERN_MAXPLAYERS, matcher -> {
            maxplayers[0] = Integer.parseInt(matcher.group(1));
        });
        sortrules.addAll(g_sort);
        PlayerSorter sorter = parseSortrules(sortrules);
        Matcher fillplayersMatcher = PATTERN_FILLPLAYERS.matcher(line);
        if (fillplayersMatcher.matches()) {
            SlotTemplate prefix = SlotTemplate.of(g_prefix, parseSlot(fillplayersMatcher.group("String_Node_Str")));
            SlotTemplate suffix = SlotTemplate.of(parseSlot(fillplayersMatcher.group("String_Node_Str")), g_suffix);
            String args = fillplayersMatcher.group("String_Node_Str");
            List<String> filter;
            if (args == null || args.isEmpty()) {
                filter = new ArrayList<>();
            } else {
                filter = new ArrayList<>(Arrays.asList(args.split("String_Node_Str")));
            }
            checkServer(filter);
            filter.addAll(g_filter);
            sections.add(group -> {
                List<String> finalFilters = new ArrayList<>();
                finalFilters.addAll(filter);
                finalFilters.addAll(group.getServerNames());
                return new FillPlayersSection(startColumn[0], finalFilters, prefix, suffix, sorter, maxplayers[0], playerLines, morePlayerLines);
            });
        } else {
            SlotTemplate slotTemplate = SlotTemplate.of(g_prefix, parseSlot(line), g_suffix);
            sections.add(group -> {
                ServerSection serverSection = new ServerSection(startColumn[0], group);
                serverSection.add(slotTemplate);
                return serverSection;
            });
        }
    }
    return new AutoFillPlayers(list, sections, config.showEmptyGroups);
}

Output:
             serverSet.removeAll(strings);
-            list.add(GenericServerGroup.of(serverSet, alias));
+            list.add(GenericServerGroup.of(strings, alias));
         } else {


Input:
public void processModule(final Module module) {
    if (module instanceof FacetModule) {
        ((FacetModule) module).addFacetProcessor(TermListFacetParser.class);
        InternalTermListFacet.registerStreams();
    }
}

Output:
         ((FacetModule) module).addFacetProcessor(TermListFacetParser.class);
-        InternalTermListFacet.registerStreams();
+        InternalTermListFacet.registerStream();
     }


Input:
private void answerQuestion(byte answer) {
    try {
        JSONObject json = new JSONObject(client.newCall(new Request.Builder().get().url(Strings.buildQueryUrl(ANSWER_URL, "String_Node_Str", session, "String_Node_Str", signature, "String_Node_Str", str(stepInfo.getStepNum()), "String_Node_Str", Byte.toString(answer))).build()).execute().body().string());
        stepInfo = new StepInfo(json);
        if (stepInfo.getProgression() > 90) {
            presentGuess();
        } else {
            presentNextQuestion();
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}

Output:
         JSONObject json = new JSONObject(client.newCall(new Request.Builder().get().url(Strings.buildQueryUrl(ANSWER_URL, "String_Node_Str", session, "String_Node_Str", signature, "String_Node_Str", str(stepInfo.getStepNum()), "String_Node_Str", Byte.toString(answer))).build()).execute().body().string());
-        stepInfo = new StepInfo(json);
+        try {
+            stepInfo = new StepInfo(json);
+        } catch (JSONException ignored) {
+            emb.setImage(null).clearFields().addField("String_Node_Str", "String_Node_Str", false);
+            onFinish.run();
+        }
         if (stepInfo.getProgression() > 90) {


Input:
private static OkHttpClient createClientWithCache(Config config) {
    File httpCacheDirectory;
    try {
        httpCacheDirectory = Files.createTempDirectory(config.getCacheConfig().getName()).toFile();
    } catch (IOException e) {
        throw new IllegalStateException("String_Node_Str", e);
    }
    Cache cache = new Cache(httpCacheDirectory, config.getCacheConfig().getSize());
    return new OkHttpClient.Builder().connectTimeout(config.getTimeout(), TimeUnit.SECONDS).readTimeout(config.getTimeout(), TimeUnit.SECONDS).cache(cache).build();
}

Output:
     try {
-        httpCacheDirectory = Files.createTempDirectory(config.getCacheConfig().getName()).toFile();
+        httpCacheDirectory = Files.createTempFile(config.getCacheConfig().getName(), "String_Node_Str").toFile();
+        httpCacheDirectory.deleteOnExit();
     } catch (IOException e) {


Input:
public void build(IProgressMonitor monitor) throws Exception {
    final ITalendProcessJavaProject talendJavaProject = getTalendJavaProject();
    final Map<String, Object> argumentsMap = new HashMap<String, Object>();
    argumentsMap.put(ITalendProcessJavaProject.ARG_GOAL, getGoals());
    talendJavaProject.buildModules(monitor, null, argumentsMap);
}

Output:
     final Map<String, Object> argumentsMap = new HashMap<String, Object>();
-    argumentsMap.put(ITalendProcessJavaProject.ARG_GOAL, getGoals());
+    argumentsMap.put(TalendProcessArgumentConstant.ARG_GOAL, getGoals());
     talendJavaProject.buildModules(monitor, null, argumentsMap);


Input:
public String getRowSelectionScript(boolean allCurrentPageRows) {
    if (currentData == null)
        return null;
    List<Integer> indexToUpdate;
    if (!hasOnRender() && (bgColorScript != null || (getRowSelectedStyle() != null && getRowSelectedStyle().getAttributeCount() > 0)) && (indexToUpdate = getIndexToUpdate(allCurrentPageRows)) != null) {
        int firstRow = table.isPageableMode() ? table.getCurrentPage() * table.getRowsPerPage() : table.getStartIndex();
        int lastRow = firstRow + table.getViewSize() - 1;
        int[] newSelectedIndexes = getSelectedIndexes();
        AppendingStringBuffer sab = new AppendingStringBuffer();
        for (int rowIdx : indexToUpdate) {
            ArrayList<String> bgRuntimeColorjsArray = new ArrayList<String>();
            ArrayList<String> fgRuntimeColorjsArray = new ArrayList<String>();
            ArrayList<String> fstyleJsAray = new ArrayList<String>();
            ArrayList<String> fweightJsAray = new ArrayList<String>();
            ArrayList<String> fsizeJsAray = new ArrayList<String>();
            ArrayList<String> ffamilyJsAray = new ArrayList<String>();
            ArrayList<String> bstyleJsAray = new ArrayList<String>();
            ArrayList<String> bwidthJsAray = new ArrayList<String>();
            ArrayList<String> bcolorJsAray = new ArrayList<String>();
            if (rowIdx >= firstRow && rowIdx <= lastRow) {
                ListItem<IRecordInternal> selectedListItem = (ListItem<IRecordInternal>) table.get(Integer.toString(rowIdx));
                if (selectedListItem != null) {
                    String selectedId = selectedListItem.getMarkupId();
                    boolean isSelected = Arrays.binarySearch(newSelectedIndexes, rowIdx) >= 0;
                    if (bgColorScript == null && !isSelected && (getRowOddStyle().getAttributeCount() == 0) && (getRowEvenStyle().getAttributeCount() == 0)) {
                        Iterable<? extends Component> it = Utils.iterate(selectedListItem.iterator());
                        for (Component c : it) {
                            if (c instanceof CellContainer) {
                                CellContainer cell = (CellContainer) c;
                                Component cellContents = cell.iterator().next();
                                if (cellContents instanceof IScriptableProvider) {
                                    IScriptable scriptableComponent = ((IScriptableProvider) cellContents).getScriptObject();
                                    if (scriptableComponent instanceof IRuntimeComponent) {
                                        IRuntimeComponent runtimeComponent = (IRuntimeComponent) scriptableComponent;
                                        bgRuntimeColorjsArray.add(runtimeComponentStyleAttributes.get(runtimeComponent).get(RenderableWrapper.PROPERTY_BGCOLOR));
                                        fgRuntimeColorjsArray.add(runtimeComponentStyleAttributes.get(runtimeComponent).get(RenderableWrapper.PROPERTY_FGCOLOR));
                                        String fontStyle = runtimeComponentStyleAttributes.get(runtimeComponent).get(RenderableWrapper.PROPERTY_FONT);
                                        StringBuilder fstyle = new StringBuilder("String_Node_Str"), fweight = new StringBuilder("String_Node_Str"), fsize = new StringBuilder("String_Node_Str"), ffamily = new StringBuilder("String_Node_Str");
                                        splitFontStyle(fontStyle, fstyle, fweight, fsize, ffamily);
                                        fstyleJsAray.add(fstyle.toString());
                                        fweightJsAray.add(fweight.toString());
                                        fsizeJsAray.add(fsize.toString());
                                        ffamilyJsAray.add(ffamily.toString());
                                        String borderStyle = runtimeComponentStyleAttributes.get(runtimeComponent).get(RenderableWrapper.PROPERTY_BORDER);
                                        StringBuilder bstyle = new StringBuilder("String_Node_Str"), bwidth = new StringBuilder("String_Node_Str"), bcolor = new StringBuilder("String_Node_Str");
                                        splitBorderStyle(borderStyle, bstyle, bwidth, bcolor);
                                        bstyleJsAray.add(bstyle.toString());
                                        bwidthJsAray.add(bwidth.toString());
                                        bcolorJsAray.add(bcolor.toString());
                                    }
                                }
                            }
                        }
                    }
                    Object selectedColor = null, selectedFgColor = null, selectedFont = null, selectedBorder = null;
                    selectedColor = getListItemBgColor(selectedListItem, isSelected, true);
                    if (!isListViewMode()) {
                        selectedFgColor = getListItemFgColor(selectedListItem, isSelected, true);
                        selectedFont = getListItemFont(selectedListItem, isSelected);
                        selectedBorder = getListItemBorder(selectedListItem, isSelected);
                    }
                    selectedColor = (selectedColor == null ? "String_Node_Str" : selectedColor.toString());
                    selectedFgColor = (selectedFgColor == null) ? "String_Node_Str" : selectedFgColor.toString();
                    StringBuilder fstyle = new StringBuilder("String_Node_Str"), fweight = new StringBuilder("String_Node_Str"), fsize = new StringBuilder("String_Node_Str"), ffamily = new StringBuilder("String_Node_Str");
                    splitFontStyle(selectedFont, fstyle, fweight, fsize, ffamily);
                    StringBuilder bstyle = new StringBuilder("String_Node_Str"), bwidth = new StringBuilder("String_Node_Str"), bcolor = new StringBuilder("String_Node_Str");
                    splitBorderStyle(selectedBorder, bstyle, bwidth, bcolor);
                    if (bgColorScript == null && !isSelected && (getRowOddStyle().getAttributeCount() == 0) && (getRowEvenStyle().getAttributeCount() == 0) && !isListViewMode()) {
                        sab.append("String_Node_Str").append(selectedId).append("String_Node_Str").append(toJsArrayString(bgRuntimeColorjsArray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(fgRuntimeColorjsArray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(fstyleJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(fweightJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(fsizeJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(ffamilyJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(bstyleJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(bwidthJsAray, "String_Node_Str")).append("String_Node_Str").append(toJsArrayString(bcolorJsAray, "String_Node_Str")).append("String_Node_Str").append(isListViewMode()).append("String_Node_Str");
                    } else {
                        sab.append("String_Node_Str").append(selectedId).append("String_Node_Str").append(selectedColor).append("String_Node_Str").append(selectedFgColor).append("String_Node_Str").append(fstyle).append("String_Node_Str").append(fweight).append("String_Node_Str").append(fsize).append("String_Node_Str").append(ffamily).append("String_Node_Str").append(bstyle).append("String_Node_Str").append(bwidth).append("String_Node_Str").append(bcolor).append("String_Node_Str").append(isListViewMode()).append("String_Node_Str");
                    }
                }
            }
        }
        String rowSelectionScript = sab.toString();
        if (rowSelectionScript.length() > 0)
            return rowSelectionScript;
    }
    return null;
}

Output:
                     }
-                    Object selectedColor = null, selectedFgColor = null, selectedFont = null, selectedBorder = null;
+                    String selectedColor = null, selectedFgColor = null, selectedFont = null, selectedBorder = null;
                     selectedColor = getListItemBgColor(selectedListItem, isSelected, true);


Input:
protected void internalRefreshAndFireEvent(IProgressMonitor monitor) throws CoreException {
    if (internalRefreshModule(monitor)) {
        ServerEventHandler.getDefault().fireServerRefreshed(getCloudFoundryServer());
    }
}

Output:
     if (internalRefreshModule(monitor)) {
-        ServerEventHandler.getDefault().fireServerRefreshed(getCloudFoundryServer());
+        try {
+            ServerEventHandler.getDefault().fireServerRefreshed(getCloudFoundryServer());
+        } catch (CoreException ce) {
+            CloudFoundryPlugin.logError("String_Node_Str" + ce.getMessage(), ce);
+        }
     }


Input:
public void onChange(BlockFromToEvent event) {
    Block from = event.getBlock();
    Block to = event.getToBlock();
    Location tLocation = BukkitUtil.getLocation(to.getLocation());
    PlotArea area = tLocation.getPlotArea();
    if (area == null) {
        return;
    }
    Plot plot = area.getOwnedPlot(tLocation);
    Location fLocation = BukkitUtil.getLocation(from.getLocation());
    if (plot != null) {
        if (plot.getFlag(Flags.DISABLE_PHYSICS).or(false)) {
            event.setCancelled(true);
        } else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
            event.setCancelled(true);
        }
    } else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
        event.setCancelled(true);
    }
}

Output:
     if (plot != null) {
-        if (plot.getFlag(Flags.DISABLE_PHYSICS).or(false)) {
-            event.setCancelled(true);
-        } else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
+        if (plot.getFlag(Flags.DISABLE_PHYSICS).or(false) || !area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
             event.setCancelled(true);


Input:
private void updateAllChildrenUserObject(DefaultTreeModel model, DefaultMutableTreeNode root, boolean isSelected) {
    java.util.Enumeration breadth = root.breadthFirstEnumeration();
    while (breadth.hasMoreElements()) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) breadth.nextElement();
        if (root == node) {
            continue;
        }
        CheckBoxNode check = (CheckBoxNode) node.getUserObject();
        node.setUserObject(new CheckBoxNode(check.str, isSelected));
        model.nodeChanged(node);
    }
}

Output:
         CheckBoxNode check = (CheckBoxNode) node.getUserObject();
-        node.setUserObject(new CheckBoxNode(check.str, isSelected));
-        model.nodeChanged(node);
+        node.setUserObject(new CheckBoxNode(check.label, status));
     }


Input:
public void widgetSelected(SelectionEvent e) {
    Tree currentTree = tree;
    Object[] selectItem = currentTree.getSelection();
    List<IRepositoryNode> columnList = setTreeViewer.getColumnSetMultiValueList();
    for (int i = 0; i < selectItem.length; i++) {
        Object removeElement = ((TreeItem) selectItem[i]).getData(AnalysisColumnNominalIntervalTreeViewer.COLUMN_INDICATOR_KEY);
        columnList.remove(removeElement);
    }
    masterPage.getTreeViewer().setInput(convertList(columnList).toArray());
    enabledButtons(false);
}

Output:
 public void widgetSelected(SelectionEvent e) {
-    Tree currentTree = tree;
-    Object[] selectItem = currentTree.getSelection();
-    List<IRepositoryNode> columnList = setTreeViewer.getColumnSetMultiValueList();
-    for (int i = 0; i < selectItem.length; i++) {
-        Object removeElement = ((TreeItem) selectItem[i]).getData(AnalysisColumnNominalIntervalTreeViewer.COLUMN_INDICATOR_KEY);
-        columnList.remove(removeElement);
+    TreeItem[] selection = tree.getSelection();
+    for (TreeItem treeItem : selection) {
+        ModelElementIndicator meIndicator = (ModelElementIndicator) treeItem.getData(MODELELEMENT_INDICATOR_KEY);
+        deleteColumnItems(meIndicator.getModelElementRepositoryNode());
+        removeItemBranch(treeItem);
     }


Input:
private void toNext() {
    final Iterator<? extends Identifier> it = identifiers;
    if (it != null) {
        while (it.hasNext()) {
            final Identifier identifier = it.next();
            if (identifier != null) {
                final Citation authority = identifier.getAuthority();
                final Boolean state = put(authority, Boolean.FALSE);
                if (state == null) {
                    if (identifier instanceof IdentifierMapEntry) {
                        next = (IdentifierMapEntry) identifier;
                    } else {
                        next = new IdentifierMapEntry.Immutable(authority, identifier.getCode());
                    }
                    this.authority = authority;
                    return;
                }
                if (state == Boolean.TRUE) {
                    it.remove();
                }
            }
        }
        identifiers = null;
    }
}

Output:
                 }
-                if (state == Boolean.TRUE) {
+                if (state) {
                     it.remove();


Input:
public static IMarker newObligationStatus(ObligationStatusMessage message) {
    Location location = message.getLocation();
    IResource module = ResourceHelper.getResourceByModuleName(location.source());
    if (module != null && module instanceof IFile && module.exists()) {
        FileEditorInput fileEditorInput = new FileEditorInput((IFile) module);
        FileDocumentProvider fileDocumentProvider = new FileDocumentProvider();
        try {
            IMarker[] markers = module.findMarkers(ProverHelper.OBLIGATION_MARKER, false, IResource.DEPTH_ZERO);
            for (int i = 0; i < markers.length; i++) {
                if (markers[i].getAttribute(ProverHelper.OBLIGATION_ID, -1) == message.getID()) {
                    markers[i].setAttribute(ProverHelper.OBLIGATION_STATUS, message.getStatus());
                    markers[i].setAttribute(ProverHelper.OBLIGATION_METHOD, message.getMethod());
                    return markers[i];
                }
            }
            IMarker marker = module.createMarker(ProverHelper.OBLIGATION_MARKER);
            marker.setAttribute(ProverHelper.OBLIGATION_ID, message.getID());
            marker.setAttribute(ProverHelper.OBLIGATION_METHOD, message.getMethod());
            marker.setAttribute(ProverHelper.OBLIGATION_STATUS, message.getStatus());
            marker.setAttribute(ProverHelper.OBLIGATION_STRING, message.getObString());
            fileDocumentProvider.connect(fileEditorInput);
            IDocument document = fileDocumentProvider.getDocument(fileEditorInput);
            IRegion obRegion = AdapterFactory.locationToRegion(document, location);
            marker.setAttribute(IMarker.CHAR_START, obRegion.getOffset());
            marker.setAttribute(IMarker.CHAR_END, obRegion.getOffset() + obRegion.getLength() - 1);
            return marker;
        } catch (CoreException e) {
            e.printStackTrace();
        } catch (BadLocationException e) {
            e.printStackTrace();
        } finally {
            fileDocumentProvider.disconnect(fileEditorInput);
        }
    }
    return null;
}

Output:
                 if (markers[i].getAttribute(ProverHelper.OBLIGATION_ID, -1) == message.getID()) {
-                    markers[i].setAttribute(ProverHelper.OBLIGATION_STATUS, message.getStatus());
-                    markers[i].setAttribute(ProverHelper.OBLIGATION_METHOD, message.getMethod());
-                    return markers[i];
+                    marker = markers[i];
+                    break;
                 }


Input:
public void _commandAction(Command c, Displayable d) {
    if (c == LoginForm.CMD_CANCEL_LOGIN) {
        transitions.exit();
    } else if (c == LoginForm.CMD_LOGIN_BUTTON) {
        if (this.view.validateUser()) {
            transitions.loggedIn(view.getLoggedInUser(), view.getPassWord());
            return;
        }
        performCustomUserValidation();
    } else if (c == LoginForm.CMD_TOOLS) {
        transitions.tools();
    } else if (c == LoginForm.CMD_DEMO_BUTTON) {
        try {
            Reference demoWarning = ReferenceManager._().DeriveReference(Localization.get("String_Node_Str"));
            if (demoWarning.doesBinaryExist()) {
                MediaUtils.playAudio(demoWarning.getURI());
            }
        } catch (Exception e) {
        }
        demoModeAlert = J2MEDisplay.showError(null, Localization.get("String_Node_Str"), null, null, this);
    } else if (d == demoModeAlert) {
        User u = User.FactoryDemoUser();
        transitions.loggedIn(u, null);
    }
}

Output:
         try {
-            Reference demoWarning = ReferenceManager._().DeriveReference(Localization.get("String_Node_Str"));
-            if (demoWarning.doesBinaryExist()) {
-                MediaUtils.playAudio(demoWarning.getURI());
-            }
-        } catch (Exception e) {
+            MediaUtils.playAudio(Localization.get("String_Node_Str"));
+        } catch (NoLocalizedTextException e) {
         }


Input:
public void handle(RoutingContext context) {
    User user = context.user();
    if (user != null) {
        authorise(user, context);
    } else {
        HttpServerRequest request = context.request();
        String authorization = request.headers().get(HttpHeaders.AUTHORIZATION);
        if (authorization == null) {
            handle401(context);
        } else {
            String suser;
            String spass;
            String sscheme;
            try {
                String[] parts = authorization.split("String_Node_Str");
                sscheme = parts[0];
                String[] credentials = new String(Base64.getDecoder().decode(parts[1])).split("String_Node_Str");
                suser = credentials[0];
                spass = credentials.length > 1 ? credentials[1] : null;
            } catch (ArrayIndexOutOfBoundsException e) {
                handle401(context);
                return;
            } catch (IllegalArgumentException | NullPointerException e) {
                context.fail(e);
                return;
            }
            if (!"String_Node_Str".equals(sscheme)) {
                context.fail(400);
            } else {
                JsonObject authInfo = new JsonObject().put("String_Node_Str", suser).put("String_Node_Str", spass);
                authProvider.authenticate(authInfo, res -> {
                    if (res.succeeded()) {
                        User authenticated = res.result();
                        context.setUser(authenticated);
                        authorise(authenticated, context);
                    } else {
                        handle401(context);
                    }
                });
            }
        }
    }
}

Output:
                 suser = credentials[0];
-                spass = credentials.length > 1 ? credentials[1] : null;
+                if (credentials.length == 2)
+                    spass = credentials[1];
+                else if (credentials.length > 2) {
+                    spass = joinCredentials(credentials);
+                } else {
+                    spass = null;
+                }
             } catch (ArrayIndexOutOfBoundsException e) {


Input:
static ObjectType join(ObjectType obj1, ObjectType obj2) {
    if (obj1.isTopObject() || obj2.isTopObject()) {
        return obj1.commonTypes.getTopObjectType();
    }
    if (obj1.equals(obj2)) {
        return obj1;
    }
    NominalType nt1 = obj1.nominalType;
    NominalType nt2 = obj2.nominalType;
    Preconditions.checkState(nt1.isRawSubtypeOf(nt2) || nt2.isRawSubtypeOf(nt1));
    JSTypes commonTypes = obj1.commonTypes;
    boolean isLoose = obj1.isLoose || obj2.isLoose;
    FunctionType fn = FunctionType.join(obj1.fn, obj2.fn);
    PersistentMap<String, Property> props;
    if (isLoose) {
        fn = fn == null ? null : fn.withLoose();
        props = joinPropsLoosely(commonTypes, obj1.props, obj2.props);
    } else {
        props = joinProps(obj1.props, obj2.props, nt1, nt2);
    }
    NominalType nominal = NominalType.pickSuperclass(nt1, nt2);
    if (nominal.isBuiltinObject() && fn != null) {
        if (isLoose) {
            nominal = obj1.commonTypes.getFunctionType();
        } else {
            fn = null;
        }
    }
    Namespace ns = Objects.equals(obj1.ns, obj2.ns) ? obj1.ns : null;
    return makeObjectType(commonTypes, nominal, props, fn, ns, isLoose, ObjectKind.join(obj1.objectKind, obj2.objectKind));
}

Output:
     }
-    NominalType nominal = NominalType.pickSuperclass(nt1, nt2);
+    NominalType nominal = NominalType.join(nt1, nt2);
     if (nominal.isBuiltinObject() && fn != null) {


Input:
void handleVolumeKey(int stream, int keycode) {
    IAudioService audioService = getAudioService();
    if (audioService == null) {
        return;
    }
    try {
        mBroadcastWakeLock.acquire();
        audioService.adjustStreamVolume(stream, keycode == KeyEvent.KEYCODE_VOLUME_UP ? AudioManager.ADJUST_RAISE : AudioManager.ADJUST_LOWER, 0, mContext.getBasePackageName());
    } catch (RemoteException e) {
        Log.w(TAG, "String_Node_Str" + e);
    } finally {
        mBroadcastWakeLock.release();
    }
}

Output:
         mBroadcastWakeLock.acquire();
-        audioService.adjustStreamVolume(stream, keycode == KeyEvent.KEYCODE_VOLUME_UP ? AudioManager.ADJUST_RAISE : AudioManager.ADJUST_LOWER, 0, mContext.getBasePackageName());
+        audioService.adjustStreamVolume(stream, keycode == KeyEvent.KEYCODE_VOLUME_UP ? AudioManager.ADJUST_RAISE : AudioManager.ADJUST_LOWER, 0, mContext.getOpPackageName());
     } catch (RemoteException e) {


Input:
private DB getMongoDb() {
    DB db = mongo.getDB(this.mongoDbConfiguration.getDatabaseName());
    if (this.mongoDbConfiguration.isAuthenticateParametersSet()) {
        boolean authenticated = db.authenticate(this.mongoDbConfiguration.getUsername(), this.mongoDbConfiguration.getPassword().toCharArray());
        if (!authenticated) {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
    return db;
}

Output:
     DB db = mongo.getDB(this.mongoDbConfiguration.getDatabaseName());
-    if (this.mongoDbConfiguration.isAuthenticateParametersSet()) {
+    if (this.mongoDbConfiguration.isAuthenticateParametersSet() && !db.isAuthenticated()) {
         boolean authenticated = db.authenticate(this.mongoDbConfiguration.getUsername(), this.mongoDbConfiguration.getPassword().toCharArray());


Input:
private void _constructDirectedGraph() {
    LinkedList portList = new LinkedList();
    _dag = new DirectedAcyclicGraph();
    CompositeActor container = ((CompositeActor) getContainer());
    if (container != null) {
        Enumeration allactors = container.deepGetEntities();
        while (allactors.hasMoreElements()) {
            Actor actor = (Actor) allactors.nextElement();
            Enumeration allports = actor.inputPorts();
            while (allports.hasMoreElements()) {
                IOPort port = (IOPort) allports.nextElement();
                _dag.add(port);
                portList.insertLast(port);
            }
        }
    }
    Enumeration copiedPorts = portList.elements();
    while (copiedPorts.hasMoreElements()) {
        IOPort ioPort = (IOPort) copiedPorts.nextElement();
        if (ioPort instanceof DEIOPort) {
            DEIOPort p = (DEIOPort) ioPort;
            Enumeration befores = p.beforePorts();
            while (befores.hasMoreElements()) {
                IOPort after = (IOPort) befores.nextElement();
                if (_dag.contains(after)) {
                    _dag.addEdge(p, after);
                } else {
                    throw new InternalErrorException("String_Node_Str");
                }
            }
            Enumeration triggers = p.triggersPorts();
            while (triggers.hasMoreElements()) {
                IOPort outPort = (IOPort) triggers.nextElement();
                Enumeration inPortEnum = outPort.deepConnectedInPorts();
                while (inPortEnum.hasMoreElements()) {
                    IOPort pp = (IOPort) inPortEnum.nextElement();
                    if (_dag.contains(pp)) {
                        _dag.addEdge(p, pp);
                    } else {
                        throw new InternalErrorException("String_Node_Str");
                    }
                }
            }
        } else {
            Enumeration triggers = ((Actor) ioPort.getContainer()).outputPorts();
            while (triggers.hasMoreElements()) {
                IOPort outPort = (IOPort) triggers.nextElement();
                Enumeration inPortEnum = outPort.deepConnectedInPorts();
                while (inPortEnum.hasMoreElements()) {
                    IOPort pp = (IOPort) inPortEnum.nextElement();
                    if (_dag.contains(pp)) {
                        _dag.addEdge(ioPort, pp);
                    } else {
                        throw new InternalErrorException("String_Node_Str");
                    }
                }
            }
        }
    }
}

Output:
     LinkedList portList = new LinkedList();
-    _dag = new DirectedAcyclicGraph();
+    DirectedAcyclicGraph dag = new DirectedAcyclicGraph();
     CompositeActor container = ((CompositeActor) getContainer());


Input:
protected List<String> toUnqualifiedVersionlessIdValues(IBundleProvider theFound) {
    List<String> retVal = new ArrayList<String>();
    int size = theFound.size();
    ourLog.info("String_Node_Str", size);
    List<IBaseResource> resources = theFound.getResources(0, size);
    for (IBaseResource next : resources) {
        retVal.add(next.getIdElement().toUnqualifiedVersionless().getValue());
    }
    return retVal;
}

Output:
     List<String> retVal = new ArrayList<String>();
-    int size = theFound.size();
+    Integer size = theFound.size();
     ourLog.info("String_Node_Str", size);


Input:
public static void logNoProxyWarning(Throwable e) {
    getDefault().log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, IStatus.ERROR, "String_Node_Str", e));
}

Output:
 public static void logNoProxyWarning(Throwable e) {
-    getDefault().log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, IStatus.ERROR, "String_Node_Str", e));
+    Activator a = getDefault();
+    if (a != null) {
+        a.log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, IStatus.ERROR, "String_Node_Str", e));
+    }
 }


Input:
private void setPropertiesFormEditable(boolean visible) {
    clearContextParams();
    EDBParamName sidOrDatabase = null;
    if (EDatabaseTypeName.ORACLEFORSID.getProduct().equals(getConnection().getProductId())) {
        if (EDatabaseConnTemplate.ORACLESN.getDBDisplayName().equals(getConnection().getDatabaseType())) {
            sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
            sidOrDatabaseText.setLabelWidth(65);
            sidOrDatabase = EDBParamName.ServiceName;
        } else if (EDatabaseConnTemplate.ORACLEFORSID.getDBDisplayName().equals(getConnection().getDatabaseType())) {
            sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
            sidOrDatabase = EDBParamName.Sid;
        } else if (EDatabaseConnTemplate.ORACLE_OCI.getDBDisplayName().equals(getConnection().getDatabaseType())) {
            sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
            sidOrDatabase = EDBParamName.Sid;
        }
    } else {
        sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
        sidOrDatabase = EDBParamName.Database;
        if (EDatabaseConnTemplate.INFORMIX.getDBDisplayName().equals(getConnection().getDatabaseType())) {
            sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
        }
    }
    if (EDatabaseTypeName.MSODBC.getDisplayName().equals(dbTypeCombo.getText())) {
        sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
    }
    if (EDatabaseTypeName.GODBC.getDisplayName().equals(dbTypeCombo.getText())) {
        sidOrDatabaseText.setLabelText(Messages.getString("String_Node_Str"));
    }
    if (EDatabaseConnTemplate.GENERAL_JDBC.getDBTypeName().equals(dbTypeCombo.getText())) {
        addContextParams(EDBParamName.JdbcUrl, visible);
        addContextParams(EDBParamName.DriverJar, visible);
        addContextParams(EDBParamName.MappingFile, visible);
        addContextParams(EDBParamName.ClassName, visible);
    }
    addContextParams(EDBParamName.Login, visible);
    addContextParams(EDBParamName.Password, visible);
    boolean isOracle = visible && oracleVersionEnable();
    boolean isAS400 = visible && as400VersionEnable();
    boolean isMySQL = visible && asMySQLVersionEnable();
    boolean isVertica = visible && asVerticaVersionEnable();
    boolean isSAS = visible && asSASVersionEnable();
    boolean isHbase = visible && asHbaseVersionEnable();
    dbVersionCombo.setEnabled(!isReadOnly() && (isOracle || isAS400 || isMySQL || isVertica || isSAS || EDatabaseConnTemplate.ACCESS.getDBTypeName().equals(dbTypeCombo.getText()) || EDatabaseConnTemplate.MSSQL05_08.getDBDisplayName().equals(dbTypeCombo.getText())));
    usernameText.setEditable(visible);
    passwordText.setEditable(visible);
    serverText.setEditable(false);
    portText.setEditable(false);
    sidOrDatabaseText.setEditable(false);
    datasourceText.setEditable(false);
    additionParamText.setEditable(false);
    schemaText.setEditable(false);
    fileField.setEditable(false);
    directoryField.setEditable(false);
    mappingFileText.setEditable(false);
    mappingSelectButton.setEnabled(false);
    if (EDatabaseConnTemplate.GODBC.getDBTypeName().equals(dbTypeCombo.getText()) || EDatabaseConnTemplate.GENERAL_JDBC.getDBTypeName().equals(dbTypeCombo.getText())) {
        addContextParams(EDBParamName.MappingFile, true);
        mappingFileText.show();
        mappingFileText.setEditable(true);
        mappingSelectButton.setVisible(true);
        mappingSelectButton.setEnabled(true);
    } else {
        addContextParams(EDBParamName.MappingFile, false);
        mappingFileText.hide();
        mappingFileText.setEditable(false);
        mappingSelectButton.setVisible(false);
        mappingSelectButton.setEnabled(false);
    }
    if (dbTypeCombo.getSelectionIndex() < 0) {
        urlConnectionStringText.setEditable(false);
    } else {
        EDatabaseConnTemplate template = EDatabaseConnTemplate.indexOfTemplate(dbTypeCombo.getText());
        String s = "String_Node_Str";
        if (template != null) {
            EDatabaseVersion4Drivers version = EDatabaseVersion4Drivers.indexOfByVersionDisplay(dbVersionCombo.getText());
            s = template.getUrlTemplate(version);
        }
        if (isHbase) {
            urlConnectionStringText.setVisible(false);
        }
        urlConnectionStringText.setEditable(!visible);
        boolean schemaTextIsShow = true;
        if (template == EDatabaseConnTemplate.MSSQL) {
            schemaText.show();
            schemaText.setEditable(true);
            addContextParams(EDBParamName.Schema, true);
        } else if (template == EDatabaseConnTemplate.VERTICA || template == EDatabaseConnTemplate.INFORMIX) {
            schemaText.show();
            schemaText.setEditable(true);
            addContextParams(EDBParamName.Schema, true);
        } else if (template == EDatabaseConnTemplate.GENERAL_JDBC) {
            String jdbcUrlString = "String_Node_Str";
            if (isContextMode()) {
                if (selectedContextType == null) {
                    selectedContextType = ConnectionContextHelper.getContextTypeForContextMode(getShell(), getConnection(), true);
                }
                if (selectedContextType != null) {
                    jdbcUrlString = ConnectionContextHelper.getOriginalValue(selectedContextType, getConnection().getURL());
                }
            } else {
                jdbcUrlString = generalJdbcUrlText.getText();
            }
            if (jdbcUrlString.contains("String_Node_Str")) {
                jDBCschemaText.setHideWidgets(false);
                addContextParams(EDBParamName.Schema, true);
            } else {
                jDBCschemaText.setHideWidgets(true);
                addContextParams(EDBParamName.Schema, false);
            }
        } else {
            schemaTextIsShow = false;
        }
        if (s.contains(EDatabaseConnVar.HOST.getVariable()) || isHbase) {
            if (!EDatabaseConnTemplate.GENERAL_JDBC.getDBTypeName().equals(dbTypeCombo.getText())) {
                serverText.show();
                serverText.setEditable(visible);
                if (isHbase) {
                    String serverName = getConnection().getServerName();
                    if (serverName == null || "String_Node_Str".equals(serverName)) {
                        serverText.setText(EDatabaseConnTemplate.HBASE.getUrlTemplate(EDatabaseVersion4Drivers.HBASE));
                    }
                }
                addContextParams(EDBParamName.Server, visible);
            }
        } else {
            serverText.hide();
            addContextParams(EDBParamName.Server, false);
        }
        if (s.contains(EDatabaseConnVar.PORT.getVariable()) || isHbase) {
            portText.show();
            portText.setEditable(visible);
            addContextParams(EDBParamName.Port, visible);
        } else {
            portText.hide();
            addContextParams(EDBParamName.Port, false);
        }
        if (s.contains(EDatabaseConnVar.SID.getVariable()) || s.contains(EDatabaseConnVar.SERVICE_NAME.getVariable())) {
            if (!EDatabaseConnTemplate.GENERAL_JDBC.getDBTypeName().equals(dbTypeCombo.getText())) {
                sidOrDatabaseText.show();
                sidOrDatabaseText.setEditable(visible);
                addContextParams(sidOrDatabase, visible);
            } else {
                sidOrDatabaseText.hide();
                addContextParams(sidOrDatabase, false);
            }
        } else {
            if (template.getDbType() != EDatabaseTypeName.JAVADB_EMBEDED) {
                sidOrDatabaseText.hide();
                addContextParams(sidOrDatabase, false);
            }
        }
        if (s.contains(EDatabaseConnVar.FILENAME.getVariable())) {
            fileField.show();
            fileField.setEditable(!isReadOnly() && visible);
            addContextParams(EDBParamName.File, visible);
            boolean isSqlLite = false;
            if (template.getDbType() == EDatabaseTypeName.SQLITE) {
                isSqlLite = true;
                usernameText.hide();
                passwordText.hide();
            } else {
                isSqlLite = false;
                usernameText.show();
                passwordText.show();
            }
            usernameText.setEditable(!isSqlLite);
            passwordText.setEditable(!isSqlLite);
            addContextParams(EDBParamName.Login, !isSqlLite);
            addContextParams(EDBParamName.Password, !isSqlLite);
        } else {
            fileField.hide();
            addContextParams(EDBParamName.File, false);
            usernameText.show();
            passwordText.show();
            if (isHbase) {
                usernameText.hide();
                passwordText.hide();
            }
            addContextParams(EDBParamName.Login, true);
            addContextParams(EDBParamName.Password, true);
        }
        if (s.contains(EDatabaseConnVar.DATASOURCE.getVariable())) {
            datasourceText.show();
            datasourceText.setEditable(visible);
            addContextParams(EDBParamName.Datasource, visible);
        } else {
            datasourceText.hide();
            addContextParams(EDBParamName.Datasource, false);
        }
        if (s.contains(EDatabaseConnVar.DBROOTPATH.getVariable())) {
            directoryField.show();
            directoryField.setEditable(visible);
            sidOrDatabaseText.setEditable(visible);
            addContextParams(EDBParamName.DBRootPath, visible);
            addContextParams(sidOrDatabase, visible);
        } else {
            directoryField.hide();
            addContextParams(EDBParamName.DBRootPath, false);
        }
        if (EDatabaseConnTemplate.isSchemaNeeded(getConnection().getDatabaseType())) {
            schemaText.show();
            schemaText.setEditable(visible);
            if (isHbase) {
                schemaText.setLabelText("String_Node_Str");
            }
            addContextParams(EDBParamName.Schema, visible);
        } else {
            if (!schemaTextIsShow) {
                schemaText.hide();
                addContextParams(EDBParamName.Schema, false);
            }
        }
        if (EDatabaseConnTemplate.isAddtionParamsNeeded(getConnection().getDatabaseType()) && !EDatabaseConnTemplate.GENERAL_JDBC.getDBTypeName().equals(dbTypeCombo.getText()) && visible) {
            additionParamText.show();
            additionParamText.setEditable(true);
            addContextParams(EDBParamName.AdditionalParams, true);
        } else {
            additionParamText.hide();
            addContextParams(EDBParamName.AdditionalParams, false);
        }
        if (EDatabaseConnTemplate.FIREBIRD.equals(template)) {
            portText.show();
            portText.setEditable(true);
            addContextParams(EDBParamName.Port, true);
        }
    }
    compositeDbSettings.layout();
    typeDbCompositeParent.layout();
    newParent.layout();
    databaseSettingGroup.layout();
    compositeGroupDbSettings.layout();
}

Output:
         }
-        if (isHbase) {
-            urlConnectionStringText.setVisible(false);
+        if (isHbase || isDBTypeSelected(EDatabaseConnTemplate.ORACLE_RAC)) {
+            urlConnectionStringText.hide();
+        } else {
+            urlConnectionStringText.show();
+        }
+        if (isDBTypeSelected(EDatabaseConnTemplate.ORACLE_RAC)) {
+            serverText.setLabelText(Messages.getString("String_Node_Str"));
+        } else {
+            serverText.setLabelText(Messages.getString("String_Node_Str"));
         }


Input:
private void createMemState(MemberStateImpl memberState, Collection<DistributedObject> distributedObjects) {
    int count = 0;
    final Config config = instance.getConfig();
    final Iterator<DistributedObject> iterator = distributedObjects.iterator();
    while (iterator.hasNext() && count < maxVisibleInstanceCount) {
        DistributedObject distributedObject = iterator.next();
        if (distributedObject instanceof IQueue) {
            count = handleQueue(memberState, count, config, (IQueue) distributedObject);
        } else if (distributedObject instanceof ITopic) {
            count = handleTopic(memberState, count, config, (ITopic) distributedObject);
        } else if (distributedObject instanceof MultiMap) {
            count = handleMultimap(memberState, count, config, (MultiMap) distributedObject);
        } else if (distributedObject instanceof IExecutorService) {
            count = handleExecutorService(memberState, count, config, (IExecutorService) distributedObject);
        } else {
            logger.finest("String_Node_Str" + distributedObject.getName());
        }
    }
    count = handleMap(memberState, count, config, getMapStats());
    if (cacheServiceEnabled) {
        final ICacheService cacheService = getCacheService();
        for (CacheConfig cacheConfig : cacheService.getCacheConfigs()) {
            if (cacheConfig.isStatisticsEnabled()) {
                CacheStatistics statistics = cacheService.getStatistics(cacheConfig.getNameWithPrefix());
                count = handleCache(memberState, count, cacheConfig, statistics);
            }
        }
    }
}

Output:
     }
-    count = handleMap(memberState, count, config, getMapStats());
+    count = handleMap(memberState, count, getMapStats());
     if (cacheServiceEnabled) {


Input:
static HdmiCecMessage buildCecVersion(int src, int dest, int version) {
    byte[] params = new byte[] { (byte) version };
    return buildCommand(src, dest, Constants.MESSAGE_CEC_VERSION, params);
}

Output:
 static HdmiCecMessage buildCecVersion(int src, int dest, int version) {
-    byte[] params = new byte[] { (byte) version };
+    byte[] params = new byte[] { (byte) (version & 0xFF) };
     return buildCommand(src, dest, Constants.MESSAGE_CEC_VERSION, params);


Input:
public GeoWaveMetadata apply(final Result result) {
    return new GeoWaveMetadata(result.getRow(), columnQualifier, null, getMergedStats(result, clientsideStatsMerge));
}

Output:
 public GeoWaveMetadata apply(final Result result) {
-    return new GeoWaveMetadata(result.getRow(), columnQualifier, null, getMergedStats(result, clientsideStatsMerge));
+    byte[] resultantCQ;
+    if (columnQualifier == null) {
+        NavigableMap<byte[], byte[]> familyMap = result.getFamilyMap(columnFamily);
+        if (familyMap != null && !familyMap.isEmpty()) {
+            resultantCQ = familyMap.firstKey();
+        } else {
+            resultantCQ = new byte[0];
+        }
+    } else {
+        resultantCQ = columnQualifier;
+    }
+    return new GeoWaveMetadata(result.getRow(), resultantCQ, null, getMergedStats(result, clientsideStatsMerge));
 }


Input:
public SolutionSet execute() throws JMetalException, ClassNotFoundException {
    createInitialPopulation();
    evaluatePopulation(population_);
    evaluations_ += population_.size();
    while (!stoppingCondition()) {
        offspringPopulation_ = new SolutionSet(populationSize_);
        for (int i = 0; i < (populationSize_ / 2); i++) {
            if (!stoppingCondition()) {
                Solution[] parents = new Solution[2];
                parents[0] = (Solution) selectionOperator_.execute(population_);
                parents[1] = (Solution) selectionOperator_.execute(population_);
                Solution[] offSpring = (Solution[]) crossoverOperator_.execute(parents);
                mutationOperator_.execute(offSpring[0]);
                mutationOperator_.execute(offSpring[1]);
                offspringPopulation_.add(offSpring[0]);
                offspringPopulation_.add(offSpring[1]);
            }
        }
        evaluatePopulation(offspringPopulation_);
        evaluations_ += offspringPopulation_.size();
        Ranking ranking = new Ranking(population_.union(offspringPopulation_));
        population_.clear();
        int rankingIndex = 0;
        while (populationIsNotFull()) {
            if (subfrontFillsIntoThePopulation(ranking, rankingIndex)) {
                addRankedSolutionsToPopulation(ranking, rankingIndex);
                rankingIndex++;
            } else {
                computeCrowdingDistance(ranking, rankingIndex);
                addLastRankedSolutions(ranking, rankingIndex);
            }
        }
    }
    tearDown();
    return getNonDominatedSolutions();
}

Output:
     createInitialPopulation();
-    evaluatePopulation(population_);
+    population_ = evaluatePopulation(population_);
     evaluations_ += population_.size();


Input:
private boolean allowInitializedConnection(Connection c) {
    if ((isShieldedLeaf() || !isSupernode()) && !c.isClientSupernodeConnection())
        return false;
    return allowConnection(c.headers());
}

Output:
         return false;
-    return allowConnection(c.headers());
+    List connections = getConnections();
+    int listenPort = c.getListeningPort();
+    String addr = c.getAddress();
+    for (int i = 0; i < connections.size(); i++) {
+        ManagedConnection mc = (ManagedConnection) connections.get(i);
+        if (mc == c)
+            continue;
+        if (addr.equals(mc.getAddress())) {
+            int mcLP = mc.getListeningPort();
+            if (listenPort == -1 || mcLP == -1 || mcLP == listenPort)
+                return false;
+        }
+    }
+    return allowConnection(c.headers()).isAcceptable();
 }


Input:
public IColumnAnalizeResult analize() throws IOException {
    boolean maybeSorted = true;
    Short currentSortCheckValue = Short.MIN_VALUE;
    int nullCount = 0;
    int rowCount = 0;
    Set<Short> dicSet = new HashSet<Short>();
    Short min = Short.MAX_VALUE;
    Short max = Short.MIN_VALUE;
    for (int i = 0; i < column.size(); i++) {
        ICell cell = column.get(i);
        if (cell.getType() == ColumnType.NULL) {
            nullCount++;
            continue;
        }
        Short target = Short.valueOf(((PrimitiveCell) cell).getRow().getShort());
        if (maybeSorted && 0 <= currentSortCheckValue.compareTo(target)) {
            currentSortCheckValue = target;
        } else {
            maybeSorted = false;
        }
        rowCount++;
        if (!dicSet.contains(target)) {
            dicSet.add(target);
            if (0 < min.compareTo(target)) {
                min = Short.valueOf(target);
            }
            if (max.compareTo(target) < 0) {
                max = Short.valueOf(target);
            }
        }
    }
    int uniqCount = dicSet.size();
    return new ShortColumnAnalizeResult(column.getColumnName(), column.size(), maybeSorted, nullCount, rowCount, uniqCount, min, max);
}

Output:
         Short target = Short.valueOf(((PrimitiveCell) cell).getRow().getShort());
-        if (maybeSorted && 0 <= currentSortCheckValue.compareTo(target)) {
+        if (maybeSorted && currentSortCheckValue.compareTo(target) <= 0) {
             currentSortCheckValue = target;


Input:
public Move getBestMove(MachineState state, Role role) throws MoveDefinitionException, GoalDefinitionException, TransitionDefinitionException {
    minStateScores.clear();
    maxStateScores.clear();
    List<Move> moves = stateMachine.getLegalMoves(state, role);
    if (moves.size() == 1) {
        return moves.get(0);
    } else {
        Move bestMove = null;
        int bestValue = Integer.MIN_VALUE;
        for (Move move : stateMachine.getLegalMoves(state, role)) {
            List<List<Move>> allJointMoves = stateMachine.getLegalJointMoves(state, role, move);
            for (List<Move> jointMove : allJointMoves) {
                MachineState newState = stateMachine.getNextState(state, jointMove);
                int newValue = minScore(role, newState);
                if (newValue > bestValue) {
                    bestValue = newValue;
                    bestMove = move;
                }
            }
        }
        System.out.println("String_Node_Str" + bestValue);
        return bestMove;
    }
}

Output:
         int bestValue = Integer.MIN_VALUE;
-        for (Move move : stateMachine.getLegalMoves(state, role)) {
-            List<List<Move>> allJointMoves = stateMachine.getLegalJointMoves(state, role, move);
-            for (List<Move> jointMove : allJointMoves) {
-                MachineState newState = stateMachine.getNextState(state, jointMove);
-                int newValue = minScore(role, newState);
-                if (newValue > bestValue) {
-                    bestValue = newValue;
-                    bestMove = move;
-                }
+        for (Move move : moves) {
+            int value = minScore(role, move, state);
+            if (value > bestValue) {
+                bestValue = value;
+                bestMove = move;
             }


Input:
protected String buildMeaningfulClassesQuery(OWLClassExpression index, SortedSet<OWLClassExpression> targetClasses) {
    String query = "String_Node_Str";
    query += converter.convert("String_Node_Str", index);
    query += "String_Node_Str";
    query += "String_Node_Str";
    query += "String_Node_Str" + Joiner.on("String_Node_Str").join(FluentIterable.from(targetClasses).transform(Functions.compose(TO_IRI_FUNCTION, OWLCLASS_TRANSFORM_FUNCTION))) + "String_Node_Str";
    return query;
}

Output:
     query += "String_Node_Str";
-    query += "String_Node_Str" + Joiner.on("String_Node_Str").join(FluentIterable.from(targetClasses).transform(Functions.compose(TO_IRI_FUNCTION, OWLCLASS_TRANSFORM_FUNCTION))) + "String_Node_Str";
+    query += "String_Node_Str" + targetClasses.stream().map(ce -> "String_Node_Str" + ce.asOWLClass().toStringID() + "String_Node_Str").collect(Collectors.joining("String_Node_Str")) + "String_Node_Str";
     return query;


Input:
public boolean onKeyUp(int keyCode, KeyEvent ev) {
    if (DEBUG)
        L("String_Node_Str", keyCode);
    switch(keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_DPAD_UP:
        case KeyEvent.KEYCODE_SPACE:
        case KeyEvent.KEYCODE_ENTER:
        case KeyEvent.KEYCODE_BUTTON_A:
            unpoke();
            return true;
    }
    return false;
}

Output:
 public boolean onKeyUp(int keyCode, KeyEvent ev) {
-    if (DEBUG)
-        L("String_Node_Str", keyCode);
+    L("String_Node_Str", keyCode);
     switch(keyCode) {


Input:
public void transform(SelectInfo info) {
    sizeTransformationVisitor.setOrderBySelectClause(orderByManager.getOrderBySelectAliases().contains(info.getAlias()));
    sizeTransformationVisitor.setClause(ClauseType.SELECT);
    boolean[] groupBySelectStatus = selectManager.containsGroupBySelect();
    sizeTransformationVisitor.setHasGroupBySelects(groupBySelectStatus[0]);
    sizeTransformationVisitor.setHasComplexGroupBySelects(groupBySelectStatus[1]);
    if (ExpressionUtils.isSizeFunction(info.getExpression())) {
        info.setExpression(info.getExpression().accept(sizeTransformationVisitor));
    } else {
        info.getExpression().accept(sizeTransformationVisitor);
    }
}

Output:
     sizeTransformationVisitor.setClause(ClauseType.SELECT);
-    boolean[] groupBySelectStatus = selectManager.containsGroupBySelect();
+    boolean[] groupBySelectStatus = selectManager.containsGroupBySelect(true);
     sizeTransformationVisitor.setHasGroupBySelects(groupBySelectStatus[0]);


Input:
public void got(Schema result) {
    view.setSchema(result);
    ListStore<Dimension> store = view.getUnsusedStore();
    CountryModel country = result.getCommonCountry();
    for (AdminLevelModel level : country.getAdminLevels()) {
        AdminDimension dimension = new AdminDimension(level.getId());
        dimension.set("String_Node_Str", level.getName());
        store.add(dimension);
    }
}

Output:
     ListStore<Dimension> store = view.getUnsusedStore();
-    CountryModel country = result.getCommonCountry();
-    for (AdminLevelModel level : country.getAdminLevels()) {
-        AdminDimension dimension = new AdminDimension(level.getId());
-        dimension.set("String_Node_Str", level.getName());
-        store.add(dimension);
+    for (CountryModel country : result.getCountries()) {
+        for (AdminLevelModel level : country.getAdminLevels()) {
+            AdminDimension dimension = new AdminDimension(level.getId());
+            dimension.set("String_Node_Str", level.getName());
+            store.add(dimension);
+        }
     }


Input:
public void initializeDefaultPreferences() {
    IPreferenceStore store = DesignerPlugin.getDefault().getPreferenceStore();
    String logPath = Platform.getLogFileLocation().toOSString();
    int lastIndex = logPath.lastIndexOf(File.separatorChar);
    logPath = TalendTextUtils.addQuotes(logPath.substring(0, lastIndex));
    store.setDefault(TalendDesignerPrefConstants.DEFAULT_LABEL, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.DEFAULT_HINT, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.DEFAULT_CONNECTION_FORMAT, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.DEFAULT_HINT_USED, false);
    store.setDefault(TalendDesignerPrefConstants.DEFAULT_DISPLAY, false);
    store.setDefault(TalendDesignerPrefConstants.USE_REPOSITORY_NAME, true);
    store.setDefault(TalendEditorPaletteFactory.PALETTE_STATE, FlyoutPaletteComposite.STATE_PINNED_OPEN);
    store.setDefault(TalendDesignerPrefConstants.COMP_DEFAULT_FILE_DIR, Platform.getLocation().toPortableString());
    store.setDefault(TalendDesignerPrefConstants.PRODUCT_ROOT_DIR, Platform.getLocation().removeLastSegments(1).toPortableString());
    if (ProjectManager.getInstance().getCurrentProject() != null) {
        store.setDefault(TalendDesignerPrefConstants.COMP_DEFAULT_PROJECT_DIR, Platform.getLocation().toPortableString() + "String_Node_Str" + ProjectManager.getInstance().getCurrentProject().getTechnicalLabel());
    }
    Bundle refBundle = Platform.getBundle("String_Node_Str");
    if (refBundle != null) {
        try {
            String dirPath = FileLocator.getBundleFile(refBundle).getPath();
            store.setDefault(TalendDesignerPrefConstants.DQ_REPORTING_BUNDLE_DIR, dirPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    store.setDefault(TalendDesignerPrefConstants.PROPERTY_CODE_CHECK, false);
    store.setDefault(TalendDesignerPrefConstants.LARGE_ICONS_SIZE, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.SCHEMA_OPTIONS, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.VIEW_OPTIONS, "String_Node_Str");
    store.setDefault(TalendDesignerPrefConstants.DISPLAY_SUBJOBS, true);
    store.setDefault(TalendDesignerPrefConstants.COMPONENT_ASSIST, true);
    store.setDefault(TalendDesignerPrefConstants.GENERATE_CODE_WHEN_OPEN_JOB, false);
    store.setDefault(TalendDesignerPrefConstants.CHECK_ONLY_LAST_VERSION, true);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.PROPERTY_TYPE.getName(), EmfComponent.BUILTIN);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.CATCH_REALTIME_STATS.getName(), false);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.CATCH_RUNTIME_ERRORS.getName(), true);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.CATCH_USER_ERRORS.getName(), true);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.CATCH_USER_WARNING.getName(), true);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.FILE_PATH.getName(), logPath);
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.FILENAME_LOGS.getName(), TalendTextUtils.addQuotes(DEFAULT_LOGS_FILE_NAME));
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.FILENAME_STATS.getName(), TalendTextUtils.addQuotes(DEFAULT_STATS_FILE_NAME));
    store.setDefault(ECodeLanguage.JAVA.toString() + "String_Node_Str" + EParameterName.FILENAME_METTER.getName(), TalendTextUtils.addQuotes(DEFAULT_METER_FILE_NAME));
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.PROPERTY_TYPE.getName(), EmfComponent.BUILTIN);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.CATCH_REALTIME_STATS.getName(), false);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.CATCH_RUNTIME_ERRORS.getName(), true);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.CATCH_USER_ERRORS.getName(), true);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.CATCH_USER_WARNING.getName(), true);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.FILE_PATH.getName(), logPath);
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.FILENAME_LOGS.getName(), TalendTextUtils.addQuotes(DEFAULT_LOGS_FILE_NAME));
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.FILENAME_STATS.getName(), TalendTextUtils.addQuotes(DEFAULT_STATS_FILE_NAME));
    store.setDefault(ECodeLanguage.PERL.toString() + "String_Node_Str" + EParameterName.FILENAME_METTER.getName(), TalendTextUtils.addQuotes(DEFAULT_METER_FILE_NAME));
    store.setDefault(IRepositoryPrefConstants.MANUALLY_REFRESH, false);
    store.setDefault(IRepositoryPrefConstants.CREATING_REFRESH, true);
    store.setDefault(IRepositoryPrefConstants.SAVING_REFRESH, true);
    store.setDefault(IRepositoryPrefConstants.DELETING_REFRESH, true);
    store.setDefault(ITalendCorePrefConstants.DB_CONNECTION_TIMEOUT_ACTIVED, true);
    store.setDefault(ITalendCorePrefConstants.DB_CONNECTION_TIMEOUT, 15);
    store.setDefault(ITalendCorePrefConstants.ADD_USER_ROUTINES, true);
    store.setDefault(ITalendCorePrefConstants.ADD_SYSTEM_ROUTINES, true);
    store.setDefault(IRepositoryPrefConstants.USE_EXPORT_SAVE, false);
    store.setDefault(IRepositoryPrefConstants.ADD_CLASSPATH_JAR, false);
    store.setDefault(TalendDesignerPrefConstants.NOT_SHOW_WARNING_WHEN_DELETE_LINK_WITH_JOBLETTRIGGERLINKCOMPONENT, false);
    if (!CommonUIPlugin.isFullyHeadless()) {
        Display display = Display.getDefault();
        if (display == null) {
            display = Display.getCurrent();
        }
        if (display != null) {
            display.syncExec(new Runnable() {
                public void run() {
                    IPreferenceStore store = CorePlugin.getDefault().getPreferenceStore();
                    Font font = new Font(null, "String_Node_Str", 10, SWT.NONE);
                    PreferenceConverter.setDefault(store, TalendDesignerPrefConstants.MEMO_TEXT_FONT, font.getFontData());
                    PreferenceConverter.setDefault(store, TalendDesignerPrefConstants.CONSOLT_TEXT_FONT, font.getFontData());
                }
            });
        }
        store.setDefault(TalendDesignerPrefConstants.EDITOR_ANTIALIASING, true);
        store.setDefault(TalendDesignerPrefConstants.EDITOR_LINESTYLE, true);
        DesignerColorUtils.initPreferenceDefault(store);
        ColorManager.initDefaultColors(store);
        store.setDefault(MetadataTypeLengthConstants.FIELD_DEFAULT_TYPE, JavaTypesManager.STRING.getId());
        store.setDefault(MetadataTypeLengthConstants.VALUE_DEFAULT_TYPE, JavaTypesManager.STRING.getId());
    }
}

Output:
         try {
-            String dirPath = FileLocator.getBundleFile(refBundle).getPath();
+            String dirPath = FileLocator.getBundleFile(refBundle).getPath().replace(File.separatorChar, '/');
             store.setDefault(TalendDesignerPrefConstants.DQ_REPORTING_BUNDLE_DIR, dirPath);


Input:
public void google_initialize(final int instance_id) {
    activity.runOnUiThread(new Runnable() {

        public void run() {
            googleAchievements.init(instance_id);
            googleAuthentication.init(instance_id);
            googlePlayer.init(instance_id);
            googleLeaderboard.init(instance_id);
            googleSnapshot.init(instance_id);
        }
    });
}

Output:
 public void google_initialize(final int instance_id) {
-    activity.runOnUiThread(new Runnable() {
+    AsyncTask<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() {


Input:
public void endDocument() throws SAXException {
    if (unmarshaller.getIDResolver() != null && parentRecord == null) {
        unmarshaller.getIDResolver().endDocument();
    }
    if (null != selfRecords) {
        for (int x = 0, selfRecordsSize = selfRecords.size(); x < selfRecordsSize; x++) {
            UnmarshalRecord selfRecord = selfRecords.get(x);
            if (selfRecord != null) {
                selfRecord.endDocument();
            }
        }
    }
    if (null != xPathNode.getSelfChildren()) {
        int selfChildrenSize = xPathNode.getSelfChildren().size();
        for (int x = 0; x < selfChildrenSize; x++) {
            XPathNode selfNode = xPathNode.getSelfChildren().get(x);
            if (null != selfNode.getNodeValue()) {
                selfNode.getNodeValue().endSelfNodeValue(this, selfRecords.get(x), attributes);
            }
        }
    }
    CoreDescriptor xmlDescriptor = (CoreDescriptor) treeObjectBuilder.getDescriptor();
    try {
        if (null != populatedContainerValues) {
            for (int populatedCVSize = populatedContainerValues.size(), i = populatedCVSize - 1; i >= 0; i--) {
                ContainerValue cv = ((ContainerValue) populatedContainerValues.get(i));
                cv.setContainerInstance(currentObject, getContainerInstance(cv, cv.isDefaultEmptyContainer()));
            }
        }
        if (null != defaultEmptyContainerValues) {
            for (int defaultEmptyCVSize = defaultEmptyContainerValues.size(), i = defaultEmptyCVSize - 1; i >= 0; i--) {
                ContainerValue cv = ((ContainerValue) defaultEmptyContainerValues.get(i));
                cv.setContainerInstance(currentObject, getContainerInstance(cv, cv.isDefaultEmptyContainer()));
            }
        }
        if (null != nullCapableValues) {
            for (int x = 0, nullValuesSize = nullCapableValues.size(); x < nullValuesSize; x++) {
                nullCapableValues.get(x).setNullValue(currentObject, session);
            }
        }
        List transformationMappings = treeObjectBuilder.getTransformationMappings();
        if (null != transformationMappings) {
            ReadObjectQuery query = new ReadObjectQuery();
            query.setSession((AbstractSession) session);
            for (int x = 0, transformationMappingsSize = transformationMappings.size(); x < transformationMappingsSize; x++) {
                AbstractTransformationMapping transformationMapping = (AbstractTransformationMapping) transformationMappings.get(x);
                transformationMapping.readFromRowIntoObject(transformationRecord, null, currentObject, null, query, (AbstractSession) session, true);
            }
        }
        XMLUnmarshalListener listener = unmarshaller.getUnmarshalListener();
        if (listener != null) {
            if (this.parentRecord != null) {
                listener.afterUnmarshal(currentObject, parentRecord.getCurrentObject());
            } else {
                listener.afterUnmarshal(currentObject, null);
            }
        }
        if (xmlDescriptor.hasEventManager()) {
            CoreDescriptorEventManager eventManager = xmlDescriptor.getEventManager();
            if (null != eventManager && eventManager.hasAnyEventListeners()) {
                DescriptorEvent event = new DescriptorEvent(currentObject);
                event.setSession((AbstractSession) session);
                event.setRecord(null);
                event.setEventCode(DescriptorEventManager.PostBuildEvent);
                eventManager.executeEvent(event);
            }
        }
    } catch (EclipseLinkException e) {
        if (null == xmlReader.getErrorHandler()) {
            throw e;
        } else {
            SAXParseException saxParseException = new SAXParseException(null, getDocumentLocator(), e);
            xmlReader.getErrorHandler().error(saxParseException);
        }
    }
    if (null != referenceResolver) {
        if (null != xmlDescriptor) {
            List primaryKeyFields = xmlDescriptor.getPrimaryKeyFields();
            if (null != primaryKeyFields) {
                int primaryKeyFieldsSize = primaryKeyFields.size();
                if (primaryKeyFieldsSize > 0) {
                    CacheId pk = (CacheId) treeObjectBuilder.extractPrimaryKeyFromObject(currentObject, session);
                    for (int x = 0; x < primaryKeyFieldsSize; x++) {
                        Object value = pk.getPrimaryKey()[x];
                        if (null == value) {
                            Field pkField = (Field) xmlDescriptor.getPrimaryKeyFields().get(x);
                            pk.set(x, unmarshaller.getContext().getValueByXPath(currentObject, pkField.getXPath(), pkField.getNamespaceResolver(), Object.class));
                        }
                    }
                    referenceResolver.putValue(xmlDescriptor.getJavaClass(), pk, currentObject);
                    if (unmarshaller.getIDResolver() != null) {
                        try {
                            if (primaryKeyFieldsSize > 1) {
                                Map<String, Object> idWrapper = new HashMap<String, Object>();
                                for (int x = 0; x < primaryKeyFieldsSize; x++) {
                                    String idName = (String) xmlDescriptor.getPrimaryKeyFieldNames().get(x);
                                    Object idValue = pk.getPrimaryKey()[x];
                                    idWrapper.put(idName, idValue);
                                }
                                unmarshaller.getIDResolver().bind(idWrapper, currentObject);
                            } else {
                                unmarshaller.getIDResolver().bind(pk.getPrimaryKey()[0], currentObject);
                            }
                        } catch (SAXException e) {
                            throw XMLMarshalException.unmarshalException(e);
                        }
                    }
                }
            }
        }
    }
    if (null != parentRecord) {
        reset();
    }
    if (xmlLocation != null && ((Descriptor) xmlDescriptor).getLocationAccessor() != null) {
        ((Descriptor) xmlDescriptor).getLocationAccessor().setAttributeValueInObject(getCurrentObject(), xmlLocation);
    }
}

Output:
         }
-        XMLUnmarshalListener listener = unmarshaller.getUnmarshalListener();
+        Unmarshaller.Listener listener = unmarshaller.getUnmarshalListener();
         if (listener != null) {


Input:
public <TElmt> void writeNodes(List list, ASTUtil.IProcessListElmt<TElmt> processList) {
    boolean first = true;
    for (Object elmtObject : list) {
        TElmt elmt = (TElmt) elmtObject;
        processList.process(elmt);
    }
}

Output:
         TElmt elmt = (TElmt) elmtObject;
-        processList.process(elmt);
+        consumer.accept(elmt);
     }


Input:
public int hashCode() {
    String c = this.value.currency;
    String v = this.value.value;
    return c != null && v != null ? (c + v).hashCode() : 0;
}

Output:
 public int hashCode() {
-    String c = this.value.currency;
-    String v = this.value.value;
+    String c = currency;
+    String v = value;
     return c != null && v != null ? (c + v).hashCode() : 0;