Input:
public static RelationalDescriptor descriptor() {
    RelationalDescriptor descriptor = new RelationalDescriptor();
    descriptor.setJavaClass(TimestampInAggregateObject.class);
    descriptor.setTableName("String_Node_Str");
    descriptor.setPrimaryKeyFieldName("String_Node_Str");
    descriptor.setSequenceNumberName("String_Node_Str");
    descriptor.setSequenceNumberFieldName("String_Node_Str");
    descriptor.useTimestampLocking("String_Node_Str", false);
    descriptor.addDirectMapping("String_Node_Str", "String_Node_Str");
    descriptor.addDirectMapping("String_Node_Str", "String_Node_Str");
    org.eclipse.persistence.mappings.AggregateObjectMapping aggregateobjectmapping = new org.eclipse.persistence.mappings.AggregateObjectMapping();
    aggregateobjectmapping.setAttributeName("String_Node_Str");
    aggregateobjectmapping.setIsReadOnly(false);
    aggregateobjectmapping.setReferenceClass(TimestampVersion.class);
    aggregateobjectmapping.setIsNullAllowed(false);
    descriptor.addMapping(aggregateobjectmapping);
    return descriptor;
}

Output:
     aggregateobjectmapping.setReferenceClass(TimestampVersion.class);
-    aggregateobjectmapping.setIsNullAllowed(false);
+    aggregateobjectmapping.setIsNullAllowed(true);
     descriptor.addMapping(aggregateobjectmapping);


Input:
public boolean createProjects() {
    final boolean created = super.createProjects();
    final Object[] selected = getProjectsList().getCheckedElements();
    XmiResourceManager xmiManager = new XmiResourceManager();
    try {
        for (Object element : selected) {
            final ProjectRecord record = (ProjectRecord) element;
            String projectName = record.getProjectName();
            final IWorkspace workspace = ResourcesPlugin.getWorkspace();
            final IProject project = workspace.getRoot().getProject(projectName);
            try {
                final Project loadProject = xmiManager.loadProject(project);
                loadProject.setLocal(true);
                loadProject.setId(0);
                loadProject.setUrl(null);
                loadProject.setCreationDate(null);
                loadProject.setType(null);
                xmiManager.saveResource(loadProject.eResource());
                if (ProjectManager.getInstance().enableSpecialTechnicalProjectName()) {
                    ChangeProjectTechinicalNameMigrationTask migrationTask = new ChangeProjectTechinicalNameMigrationTask();
                    migrationTask.migrateTalendProject(project, loadProject, xmiManager);
                }
            } catch (PersistenceException e) {
            }
        }
    } finally {
        xmiManager.unloadResources();
    }
    return created;
}

Output:
                 xmiManager.saveResource(loadProject.eResource());
-                if (ProjectManager.getInstance().enableSpecialTechnicalProjectName()) {
+                if (ProjectManager.enableSpecialTechnicalProjectName()) {
                     ChangeProjectTechinicalNameMigrationTask migrationTask = new ChangeProjectTechinicalNameMigrationTask();


Input:
public <T> T pullOptional(final Class<T> type) {
    final Iterator<Object> iterator = list.iterator();
    while (iterator.hasNext()) {
        final Object object = iterator.next();
        if (type.isInstance(object)) {
            iterator.remove();
            return (T) object;
        }
    }
    return null;
}

Output:
         final Object object = iterator.next();
-        if (type.isInstance(object)) {
+        if (type.isInstance(object) && !(object instanceof Element)) {
             iterator.remove();


Input:
public boolean containsValue(String value, String operator) {
    Integer[] indices = null;
    if (operator.equals(MatchUtil.NOT_EQUALS)) {
        indices = findIndicesOfValues(new String[] { value }, MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
        return indices.length == 0;
    }
    indices = findIndicesOfValues(new String[] { value }, operator, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
    return indices.length > 0;
}

Output:
     if (operator.equals(MatchUtil.NOT_EQUALS)) {
-        indices = findIndicesOfValues(new String[] { value }, MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
+        indices = findIndicesOfValue(value, MatchUtil.EQUALS, CompSystemConstants.SEARCH_TYPE_ABSOLUTE);
         return indices.length == 0;


Input:
public void testReadOnlyCssStyleHandle() throws Exception {
    openDesign("String_Node_Str");
    designHandle.addCss("String_Node_Str");
    List styles = designHandle.getAllStyles();
    SharedStyleHandle styleHandle = (SharedStyleHandle) styles.get(0);
    try {
        styleHandle.setFontStyle(DesignChoiceConstants.FONT_STYLE_ITALIC);
        fail();
    } catch (IllegalOperationException e) {
        assertEquals(CssException.DESIGN_EXCEPTION_READONLY, e.getMessage());
    }
    HighlightRule highlightRule = StructureFactory.createHighlightRule();
    PropertyHandle propHandle = styleHandle.getPropertyHandle(IStyleModel.HIGHLIGHT_RULES_PROP);
    try {
        propHandle.addItem(highlightRule);
        fail();
    } catch (IllegalOperationException e) {
        assertEquals(CssException.DESIGN_EXCEPTION_READONLY, e.getMessage());
    }
    DimensionHandle fontSize = styleHandle.getFontSize();
    try {
        fontSize.setStringValue("String_Node_Str");
        fail();
    } catch (IllegalOperationException e) {
        assertEquals(CssException.DESIGN_EXCEPTION_READONLY, e.getMessage());
    }
}

Output:
     openDesign("String_Node_Str");
-    designHandle.addCss("String_Node_Str");
+    CssStyleSheetHandle sheetHandle = designHandle.openCssStyleSheet(getResource("String_Node_Str").getFile());
+    designHandle.addCss(sheetHandle);
     List styles = designHandle.getAllStyles();


Input:
public void lock() throws IOException {
    if (thread == null)
        thread = new LockerThread(new Ticket());
    final Thread t = new Thread(thread);
    t.start();
    while (t.isAlive()) try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
}

Output:
     if (thread == null)
-        thread = new LockerThread(new Ticket());
+        thread = new LockerThread(new Ticket(this.description));
     final Thread t = new Thread(thread);


Input:
public void testMultiplePasv() throws Exception {
    for (int i = 0; i < 5; i++) {
        client.connect("String_Node_Str", port);
        client.login(ADMIN_USERNAME, ADMIN_PASSWORD);
        client.pasv();
        client.quit();
        client.disconnect();
    }
}

Output:
     for (int i = 0; i < 5; i++) {
-        client.connect("String_Node_Str", port);
+        client.connect("String_Node_Str", getListenerPort());
         client.login(ADMIN_USERNAME, ADMIN_PASSWORD);


Input:
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (!super.equals(obj))
        return false;
    if (getClass() != obj.getClass())
        return false;
    ComponentInstance other = (ComponentInstance) obj;
    if (definition == null) {
        if (other.definition != null)
            return false;
    } else if (!definition.equals(other.definition))
        return false;
    if (access != other.access)
        return false;
    return true;
}

Output:
             return false;
-    } else if (!definition.equals(other.definition))
-        return false;
+    } else if (!definition.equals(other.definition)) {
+        if (getDefinition() == null || other.getDefinition() == null || !getDefinition().equals(other.getDefinition())) {
+            return false;
+        }
+    }
     if (access != other.access)


Input:
private Object computInput() {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    return specifiedPath == null ? workspace.getRoot().getLocation().toFile() : workspace.getRoot().getFolder(new Path(specifiedPath)).getLocation().toFile();
}

Output:
     IWorkspace workspace = ResourcesPlugin.getWorkspace();
-    return specifiedPath == null ? workspace.getRoot().getLocation().toFile() : workspace.getRoot().getFolder(new Path(specifiedPath)).getLocation().toFile();
+    return specifiedPath == null ? ResourceManager.getRootProject().getLocation().toFile() : workspace.getRoot().getFolder(new Path(specifiedPath)).getLocation().toFile();
 }


Input:
protected String buildDrillAction(IAction action, IReportContext context) {
    if (action == null || context == null)
        return null;
    String baseURL = null;
    Object renderContext = getRenderContext(context);
    if (renderContext instanceof HTMLRenderContext) {
        baseURL = ((HTMLRenderContext) renderContext).getBaseURL();
    }
    if (renderContext instanceof PDFRenderContext) {
        baseURL = ((PDFRenderContext) renderContext).getBaseURL();
    }
    if (baseURL == null)
        baseURL = IBirtConstants.VIEWER_PREVIEW;
    StringBuffer link = new StringBuffer();
    String reportName = getReportName(context, action);
    if (reportName != null && !reportName.equals("String_Node_Str")) {
        link.append(baseURL);
        link.append(reportName.toLowerCase().endsWith("String_Node_Str") ? "String_Node_Str" : "String_Node_Str");
        try {
            link.append(URLEncoder.encode(reportName, ParameterAccessor.UTF_8_ENCODE));
        } catch (UnsupportedEncodingException e1) {
        }
        String format = action.getFormat();
        if (format == null || format.length() == 0)
            format = hostFormat;
        if (format != null && format.length() > 0) {
            link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_FORMAT, format));
        }
        if (action.getParameterBindings() != null) {
            Iterator paramsIte = action.getParameterBindings().entrySet().iterator();
            while (paramsIte.hasNext()) {
                Map.Entry entry = (Map.Entry) paramsIte.next();
                try {
                    String key = (String) entry.getKey();
                    Object valueObj = entry.getValue();
                    if (valueObj != null) {
                        String value = DataUtil.getDisplayValue(valueObj);
                        link.append(ParameterAccessor.getQueryParameterString(URLEncoder.encode(key, ParameterAccessor.UTF_8_ENCODE), URLEncoder.encode(value, ParameterAccessor.UTF_8_ENCODE)));
                    }
                } catch (UnsupportedEncodingException e) {
                }
            }
            if (!reportName.toLowerCase().endsWith(ParameterAccessor.SUFFIX_REPORT_DOCUMENT) && baseURL.lastIndexOf(IBirtConstants.SERVLET_PATH_FRAMESET) > 0) {
                link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_OVERWRITE, String.valueOf(true)));
            }
        }
        if (locale != null) {
            link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_LOCALE, locale.toString()));
        }
        if (isRtl) {
            link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_RTL, String.valueOf(isRtl)));
        }
        link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_MASTERPAGE, String.valueOf(this.isMasterPageContent)));
        try {
            if (resourceFolder != null) {
                String res = URLEncoder.encode(resourceFolder, ParameterAccessor.UTF_8_ENCODE);
                link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_RESOURCE_FOLDER, res));
            }
        } catch (UnsupportedEncodingException e) {
        }
        String bookmark = action.getBookmark();
        if (bookmark != null) {
            try {
                if (baseURL.lastIndexOf(IBirtConstants.SERVLET_PATH_PREVIEW) > 0 || IBirtConstants.PDF_RENDER_FORMAT.equalsIgnoreCase(format)) {
                    link.append("String_Node_Str");
                    if (!action.isBookmark() && reportName.toLowerCase().endsWith("String_Node_Str")) {
                        InputOptions options = new InputOptions();
                        options.setOption(InputOptions.OPT_LOCALE, locale);
                        bookmark = BirtReportServiceFactory.getReportService().findTocByName(reportName, bookmark, options);
                    }
                    link.append(URLEncoder.encode(bookmark, ParameterAccessor.UTF_8_ENCODE));
                } else {
                    bookmark = URLEncoder.encode(bookmark, ParameterAccessor.UTF_8_ENCODE);
                    link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_BOOKMARK, bookmark));
                    if (!action.isBookmark())
                        link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_ISTOC, "String_Node_Str"));
                }
            } catch (UnsupportedEncodingException e) {
            }
        }
    }
    return link.toString();
}

Output:
                     if (valueObj != null) {
-                        String value = DataUtil.getDisplayValue(valueObj);
-                        link.append(ParameterAccessor.getQueryParameterString(URLEncoder.encode(key, ParameterAccessor.UTF_8_ENCODE), URLEncoder.encode(value, ParameterAccessor.UTF_8_ENCODE)));
+                        Object[] values;
+                        if (valueObj instanceof Object[]) {
+                            values = (Object[]) valueObj;
+                        } else {
+                            values = new Object[1];
+                            values[0] = valueObj;
+                        }
+                        for (int i = 0; i < values.length; i++) {
+                            String value = DataUtil.getDisplayValue(values[i]);
+                            if (value != null) {
+                                link.append(ParameterAccessor.getQueryParameterString(URLEncoder.encode(key, ParameterAccessor.UTF_8_ENCODE), URLEncoder.encode(value, ParameterAccessor.UTF_8_ENCODE)));
+                            } else {
+                                link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_ISNULL, URLEncoder.encode(key, ParameterAccessor.UTF_8_ENCODE)));
+                            }
+                        }
                     }


Input:
public void doMsg(String channel, String sender, String message) {
    this.ircman.getJ2().chat.handleIRCChat(sender, message, false, channel);
}

Output:
 public void doMsg(String channel, String sender, String message) {
-    this.ircman.getJ2().chat.handleIRCChat(sender, message, false, channel);
+    this.irc.getJ2().chat.handleIRCChat(sender, message, false, channel);
 }


Input:
protected boolean _arriveAfterCondRec(CSPReceiver receiver, ConditionalBranchController controller) throws InterruptedException {
    if (controller._isBranchFirst(getID())) {
        ConditionalBranchController side2 = receiver._getOtherController();
        if (side2._isBranchFirst(getID())) {
            receiver.put(getToken());
            receiver._setConditionalReceive(false, null);
            controller._branchSucceeded(getID());
            return false;
        } else {
            controller._releaseFirst(getID());
            receiver.notifyAll();
        }
    }
    getController()._branchBlocked(this.getReceiver());
    getReceiver()._checkFlagsAndWait();
    getController()._branchUnblocked(this.getReceiver());
    return true;
}

Output:
         ConditionalBranchController side2 = receiver._getOtherController();
-        if (side2._isBranchFirst(getID())) {
+        if (side2._isBranchFirst(receiver.getOtherID())) {
             receiver.put(getToken());


Input:
public void optimizeUsingZhang() {
    ComputeZhangErrors.nonlinearUsingZhang(observations, target.points);
}

Output:
 public void optimizeUsingZhang() {
-    ComputeZhangErrors.nonlinearUsingZhang(observations, target.points);
+    ComputeZhangErrors.nonlinearUsingZhang(observations, target);
 }


Input:
public void testProbeIsTTL1Only() throws Exception {
    for (int i = 2; i < 5; i++) {
        drainAll();
        QueryRequest request = QueryRequest.createQuery("String_Node_Str");
        request.setTTL((byte) i);
        ULTRAPEER_2.send(request);
        ULTRAPEER_2.flush();
        QueryRequest reqRecvd = (QueryRequest) LEAF.receive(TIMEOUT);
        assertTrue(reqRecvd.getQuery().equals("String_Node_Str"));
        assertTrue(Arrays.equals(request.getGUID(), reqRecvd.getGUID()));
        reqRecvd = (QueryRequest) ULTRAPEER_1.receive(TIMEOUT);
        assertTrue(reqRecvd.getQuery().equals("String_Node_Str"));
        assertTrue(Arrays.equals(request.getGUID(), reqRecvd.getGUID()));
        assertEquals(reqRecvd.getHops(), (byte) 1);
        Thread.sleep(2 * 1000);
        request.setTTL((byte) (i + 1));
        ULTRAPEER_2.send(request);
        ULTRAPEER_2.flush();
        try {
            LEAF.receive(TIMEOUT);
            assertTrue(false);
        } catch (InterruptedIOException expected) {
        }
        try {
            ULTRAPEER_1.receive(TIMEOUT);
            assertTrue(false);
        } catch (InterruptedIOException expected) {
        }
    }
}

Output:
         assertTrue(Arrays.equals(request.getGUID(), reqRecvd.getGUID()));
-        reqRecvd = (QueryRequest) ULTRAPEER_1.receive(TIMEOUT);
+        reqRecvd = getFirstQueryRequest(ULTRAPEER_1);
+        assertTrue(reqRecvd != null);
         assertTrue(reqRecvd.getQuery().equals("String_Node_Str"));


Input:
public static <V> Collection<V> returnWithDeadline(Collection<Future> futures, long overallTimeout, TimeUnit overallTimeUnit, long perFutureTimeout, TimeUnit perFutureTimeUnit, ExceptionHandler exceptionHandler) throws TimeoutException {
    long overallTimeoutNanos = calculateTimeout(overallTimeout, overallTimeUnit);
    long perFutureTimeoutNanos = calculateTimeout(perFutureTimeout, perFutureTimeUnit);
    long deadline = System.nanoTime() + overallTimeoutNanos;
    List<V> results = new ArrayList<V>(futures.size());
    for (Future<V> future : futures) {
        try {
            long timeoutNanos = calculateFutureTimeout(perFutureTimeoutNanos, deadline);
            V value = executeWithDeadline(future, timeoutNanos, exceptionHandler);
            if (value != null) {
                results.add(value);
            }
        } catch (TimeoutException e) {
            if (deadline - System.nanoTime() <= 0) {
                cancelAllFutures(futures);
                throw (TimeoutException) e;
            }
        } catch (Exception e) {
            cancelAllFutures(futures);
            ExceptionUtil.sneakyThrow(e);
        }
    }
    return results;
}

Output:
         } catch (TimeoutException e) {
-            if (deadline - System.nanoTime() <= 0) {
-                cancelAllFutures(futures);
-                throw (TimeoutException) e;
-            }
+            cancelAllFutures(futures);
+            throw (TimeoutException) e;
+        } catch (RuntimeException e) {
+            cancelAllFutures(futures);
+            throw (RuntimeException) e;
         } catch (Exception e) {


Input:
void acceptConnection(Socket socket) {
    if (getNumInConnections() < _maxIncomingConnections) {
        ManagedConnection connection = new ManagedConnection(socket, _router, this);
        try {
            initializeExternallyGeneratedConnection(connection);
            _router.sendPingRequest(new PingRequest(SettingsManager.instance().getTTL()), connection);
            connection.loopForMessages();
        } catch (IOException e) {
        } catch (Exception e) {
            _callback.error(ActivityCallback.ERROR_20, e);
        }
    } else {
        if (_isWindows) {
            new RejectConnection(socket, _catcher);
        } else {
            try {
                socket.close();
            } catch (IOException ioe) {
            }
        }
    }
}

Output:
 void acceptConnection(Socket socket) {
-    if (getNumInConnections() < _maxIncomingConnections) {
+    boolean allowConnection = false;
+    synchronized (_incomingConnectionsLock) {
+        if (_incomingConnections < _keepAlive) {
+            _incomingConnections++;
+            allowConnection = true;
+        }
+    }
+    if (allowConnection) {
         ManagedConnection connection = new ManagedConnection(socket, _router, this);


Input:
private void generateWords(final int number, final Random random) {
    final Set<String> wordSet = CollectionUtils.newHashSet();
    while (wordSet.size() < number) {
        wordSet.add(generateWord(random.nextInt()));
    }
    sWords.addAll(wordSet);
}

Output:
     while (wordSet.size() < number) {
-        wordSet.add(generateWord(random.nextInt()));
+        wordSet.add(generateWord(random));
     }


Input:
public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    this.index = index;
    this.photoLabel.setIcon(null);
    ContactList contactList = (ContactList) list;
    ChatContact chatContact = (ChatContact) value;
    this.setPreferredSize(new Dimension(20, 30));
    String displayName = chatContact.getName();
    if (displayName == null || displayName.length() < 1) {
        displayName = GuiActivator.getResources().getI18NString("String_Node_Str");
    }
    this.nameLabel.setFont(this.getFont().deriveFont(Font.PLAIN));
    this.nameLabel.setText(displayName);
    if (contactForegroundColor != null)
        this.nameLabel.setForeground(contactForegroundColor);
    this.setBorder(BorderFactory.createEmptyBorder(1, 5, 1, 1));
    ImageIcon avatar = chatContact.getAvatar();
    if (avatar != null)
        this.photoLabel.setIcon(avatar);
    this.setBounds(0, 0, list.getWidth() - 2, 30);
    this.nameLabel.setBounds(0, 0, list.getWidth() - 28, 17);
    this.photoLabel.setBounds(list.getWidth() - 28, 0, 25, 30);
    this.isLeaf = true;
    this.isSelected = isSelected;
    return this;
}

Output:
     this.photoLabel.setIcon(null);
-    ContactList contactList = (ContactList) list;
+    DefaultContactList contactList = (DefaultContactList) list;
     ChatContact chatContact = (ChatContact) value;


Input:
public long readHeader() throws IOException {
    final byte HDRBYTE = (byte) ((IndexDataWriter.VERSION << 24) >> 24);
    if (HDRBYTE != dis.readByte()) {
        throw new IOException("String_Node_Str");
    }
    return dis.readLong();
}

Output:
 public long readHeader() throws IOException {
-    final byte HDRBYTE = (byte) ((IndexDataWriter.VERSION << 24) >> 24);
-    if (HDRBYTE != dis.readByte()) {
+    final byte hdrbyte = (byte) ((IndexDataWriter.VERSION << 24) >> 24);
+    if (hdrbyte != dis.readByte()) {
         throw new IOException("String_Node_Str");


Input:
public TabbableController createEditController(UserRequest ureq, WindowControl wControl, BreadcrumbPanel stackPanel, ICourse course, UserCourseEnvironment euce) {
    updateModuleConfigDefaults(false);
    STCourseNodeEditController childTabCntrllr = new STCourseNodeEditController(ureq, wControl, this, course.getCourseFolderContainer(), course.getCourseEnvironment().getCourseGroupManager(), course.getEditorTreeModel(), euce);
    CourseNode chosenNode = course.getEditorTreeModel().getCourseNode(euce.getCourseEditorEnv().getCurrentCourseNodeId());
    return new NodeEditController(ureq, wControl, course.getEditorTreeModel(), course, chosenNode, euce, childTabCntrllr);
}

Output:
     updateModuleConfigDefaults(false);
-    STCourseNodeEditController childTabCntrllr = new STCourseNodeEditController(ureq, wControl, this, course.getCourseFolderContainer(), course.getCourseEnvironment().getCourseGroupManager(), course.getEditorTreeModel(), euce);
+    STCourseNodeEditController childTabCntrllr = new STCourseNodeEditController(ureq, wControl, this, course.getCourseFolderContainer(), course.getEditorTreeModel(), euce);
     CourseNode chosenNode = course.getEditorTreeModel().getCourseNode(euce.getCourseEditorEnv().getCurrentCourseNodeId());


Input:
protected String chooseGroup() {
    System.out.println("String_Node_Str");
    if (this.getDataModel().getGroupId() == null)
        System.out.println("String_Node_Str" + this.getDataModel().getName() + "String_Node_Str");
    else
        System.out.println("String_Node_Str" + this.getDataModel().getName() + "String_Node_Str" + this.getDataModel().getEconomicBelief() + "String_Node_Str" + getConn().getGroupById(this.getDataModel().getGroupId()).getName());
    System.out.println("String_Node_Str" + getConn().availableGroups().size());
    String chosenGroup = "String_Node_Str";
    if (this.getDataModel().getGroupId() != null) {
        return this.getDataModel().getGroupId();
    } else if (this.invitationToGroup != null) {
        System.out.println("String_Node_Str");
        invitationHolders.remove(this.getId());
        String invitation = this.invitationToGroup;
        this.invitationToGroup = null;
        return invitation;
    } else {
        chosenGroup = agentGroupGrouping();
        if (chosenGroup.equals("String_Node_Str"))
            System.out.println("String_Node_Str" + this.getConn().getAgentById(this.getId()).getName() + "String_Node_Str");
        else
            System.out.println("String_Node_Str" + this.getConn().getAgentById(this.getId()).getName() + "String_Node_Str");
    }
    if (chosenGroup.equals("String_Node_Str")) {
        chosenGroup = freeAgentsGrouping();
        if ((chosenGroup == null))
            System.out.println("String_Node_Str" + this.getConn().getAgentById(this.getId()).getName() + "String_Node_Str");
        else
            System.out.println("String_Node_Str" + this.getConn().getAgentById(this.getId()).getName() + "String_Node_Str");
    }
    return chosenGroup;
}

Output:
     if (this.getDataModel().getGroupId() != null) {
-        return this.getDataModel().getGroupId();
+        return null;
     } else if (this.invitationToGroup != null) {


Input:
public static UUID getUUID(String username) {
    if (usernameToUUID.containsKey(username)) {
        return usernameToUUID.get(username);
    }
    String shortenedName = NameUtil.stripUsername(username);
    Account account = null;
    try {
        account = accounts.queryBuilder().selectColumns("String_Node_Str").where().eq("String_Node_Str", shortenedName).queryForFirst();
    } catch (SQLException e) {
        e.printStackTrace();
        return null;
    }
    if (account == null) {
        UUID uuid = Bukkit.getOfflinePlayer(username).getUniqueId();
        usernameToUUID.put(username, uuid);
        return uuid;
    }
    UUID uuid = account.getUuid();
    if (uuid != null) {
        usernameToUUID.put(account.getName(), uuid);
    }
    return uuid;
}

Output:
     UUID uuid = account.getUuid();
-    if (uuid != null) {
+    if (uuid != null && !usernameToUUID.containsValue(uuid)) {
         usernameToUUID.put(account.getName(), uuid);


Input:
public void findOrders() {
    PaginatedListTo<OrderCto> orders = this.helper.getService().findOrders(new MyUriInfo(null, null));
    assertThat(orders).isNotNull();
    assertThat(orders).isNotNull();
}

Output:
 public void findOrders() {
-    PaginatedListTo<OrderCto> orders = this.helper.getService().findOrders(new MyUriInfo(null, null));
+    PaginatedListTo<OrderCto> orders = this.helper.getService().findOrders(null);
     assertThat(orders).isNotNull();


Input:
public void run() {
    try {
        DoubleSolution solution;
        initialListSolution();
        int newSolutions = 0;
        while (evaluations < maxEvaluations) {
            referenceSetUpdate(true);
            newSolutions = subSetGeneration();
            while (newSolutions > 0 && evaluations < maxEvaluations) {
                referenceSetUpdate(false);
                newSolutions = subSetGeneration();
            }
            if (evaluations < maxEvaluations) {
                solutionSet.clear();
                for (int i = 0; i < refSet1.size(); i++) {
                    solution = refSet1.get(i);
                    marked.setAttribute(solution, false);
                    solution = (DoubleSolution) improvementOperator.execute(solution);
                    evaluations += improvementOperator.getEvaluations();
                    solutionSet.add(solution);
                }
                refSet1.clear();
                refSet2.clear();
                archive.computeDistance();
                Collections.sort(archive.getSolutionList(), crowdingDistanceComparator);
                int insert = solutionSetSize / 2;
                if (insert > archive.getMaxSize())
                    insert = archive.getMaxSize();
                if (insert > (solutionSetSize - solutionSet.size()))
                    insert = solutionSetSize - solutionSet.size();
                for (int i = 0; i < insert; i++) {
                    solution = archive.getSolutionList().get(i);
                    marked.setAttribute(solution, false);
                    solutionSet.add(solution);
                }
                while (solutionSet.size() < solutionSetSize) {
                    solution = diversificationGeneration();
                    if (problem instanceof ConstrainedProblem) {
                        ((ConstrainedProblem) problem).evaluateConstraints(solution);
                    }
                    problem.evaluate(solution);
                    evaluations++;
                    solution = (DoubleSolution) improvementOperator.execute(solution);
                    evaluations += improvementOperator.getEvaluations();
                    marked.setAttribute(solution, false);
                    solutionSet.add(solution);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
             newSolutions = subSetGeneration();
-            while (newSolutions > 0 && evaluations < maxEvaluations) {
+            while (newSolutions > 0) {
                 referenceSetUpdate(false);


Input:
protected void drawLegend() {
    if (!mDrawLegend || mLegend == null)
        return;
    String[] labels = mLegend.getLegendLabels();
    Typeface tf = mLegend.getTypeface();
    if (tf != null)
        mLegendLabelPaint.setTypeface(tf);
    mLegendLabelPaint.setTextSize(mLegend.getTextSize());
    float formSize = mLegend.getFormSize();
    float formToTextSpace = mLegend.getFormToTextSpace() + formSize;
    float xEntrySpace = mLegend.getXEntrySpace() + formSize;
    float yEntrySpace = mLegend.getYEntrySpace() + formSize;
    float textSize = mLegend.getTextSize();
    float textDrop = (Utils.calcTextHeight(mLegendLabelPaint, "String_Node_Str") + formSize) / 2f;
    float posX, posY;
    switch(mLegend.getPosition()) {
        case BELOW_CHART_LEFT:
            posX = mLegend.getOffsetLeft();
            posY = getHeight() - mLegend.getOffsetBottom() / 2f - formSize / 2f;
            for (int i = 0; i < labels.length; i++) {
                mLegend.drawForm(mDrawCanvas, posX, posY, mLegendFormPaint, i);
                if (labels[i] != null) {
                    if (mLegend.getColors()[i] != -1)
                        posX += formToTextSpace;
                    mLegend.drawLabel(mDrawCanvas, posX, posY + textDrop, mLegendLabelPaint, i);
                    posX += Utils.calcTextWidth(mLegendLabelPaint, labels[i]) + xEntrySpace;
                } else {
                    posX += xEntrySpace;
                }
            }
            break;
        case BELOW_CHART_RIGHT:
            posX = getWidth() - mLegend.getOffsetRight() - getOffsetRight();
            posY = getHeight() - mLegend.getOffsetBottom() / 2f - formSize / 2f;
            for (int i = labels.length - 1; i >= 0; i--) {
                if (labels[i] != null) {
                    posX -= Utils.calcTextWidth(mLegendLabelPaint, labels[i]);
                    mLegend.drawLabel(mDrawCanvas, posX, posY + textDrop, mLegendLabelPaint, i);
                    if (mLegend.getColors()[i] != -1)
                        posX -= formToTextSpace;
                }
                mLegend.drawForm(mDrawCanvas, posX, posY, mLegendFormPaint, i);
                posX -= xEntrySpace;
            }
            break;
        case RIGHT_OF_CHART:
            if (this instanceof BarLineChartBase) {
                posX = getWidth() - mLegend.getOffsetRight() + Utils.convertDpToPixel(9f);
                posY = mLegend.getOffsetTop();
            } else {
                posX = getWidth() - mLegend.getMaximumEntryLength(mLegendLabelPaint);
                posY = Utils.calcTextHeight(mLegendLabelPaint, "String_Node_Str") * 1.5f;
            }
            float stack = 0f;
            boolean wasStacked = false;
            for (int i = 0; i < labels.length; i++) {
                mLegend.drawForm(mDrawCanvas, posX + stack, posY, mLegendFormPaint, i);
                if (labels[i] != null) {
                    if (!wasStacked) {
                        float x = posX;
                        if (mLegend.getColors()[i] != -1)
                            x += formToTextSpace;
                        mLegend.drawLabel(mDrawCanvas, x, posY + textDrop, mLegendLabelPaint, i);
                    } else {
                        mLegend.drawLabel(mDrawCanvas, posX, posY + textSize + formSize + mLegend.getYEntrySpace(), mLegendLabelPaint, i);
                        posY += yEntrySpace;
                    }
                    posY += mLegend.getYEntrySpace() + textSize;
                    stack = 0f;
                } else {
                    stack += formSize + 4f;
                    wasStacked = true;
                }
            }
            break;
    }
}

Output:
     float formSize = mLegend.getFormSize();
-    float formToTextSpace = mLegend.getFormToTextSpace() + formSize;
-    float xEntrySpace = mLegend.getXEntrySpace() + formSize;
-    float yEntrySpace = mLegend.getYEntrySpace() + formSize;
+    float formTextSpaceAndForm = mLegend.getFormToTextSpace() + formSize;
+    float stackSpace = Utils.convertDpToPixel(3f);
     float textSize = mLegend.getTextSize();


Input:
public void run() {
    while ((simulationThread != null) || simulationThread.isAlive()) {
        double currentTime = _localDirector.getCurrentTime();
        _currentTimeLabel.setText("String_Node_Str" + nf.format(currentTime));
        try {
            sleep(100);
        } catch (InterruptedException e) {
        }
    }
}

Output:
 public void run() {
-    while ((simulationThread != null) || simulationThread.isAlive()) {
+    while (true) {
+        if (simulationThread == null) {
+            return;
+        } else if (!simulationThread.isAlive()) {
+            return;
+        }
         double currentTime = _localDirector.getCurrentTime();


Input:
public int compare(Viewer viewer, TreePath parentPath, Object e1, Object e2) {
    if (e1 instanceof RepositoryNode && e2 instanceof RepositoryNode) {
        final RepositoryNode node1 = (RepositoryNode) e1;
        final RepositoryNode node2 = (RepositoryNode) e2;
        if (node1.isBin()) {
            return 1;
        }
        if (node2.isBin()) {
            return -1;
        }
        if (node1.getType() == IRepositoryNode.ENodeType.SIMPLE_FOLDER || node2.getType() == IRepositoryNode.ENodeType.SIMPLE_FOLDER) {
            return e1.toString().compareTo(e2.toString());
        } else if (viewerSorter != null) {
            if (viewerSorter instanceof TreePathViewerSorter) {
                return ((TreePathViewerSorter) viewerSorter).compare(viewer, parentPath, e1, e2);
            } else {
                return viewerSorter.compare(viewer, e1, e2);
            }
        }
    }
    return super.compare(viewer, parentPath, e1, e2);
}

Output:
         final RepositoryNode node2 = (RepositoryNode) e2;
-        if (node1.isBin()) {
+        if (node1.isBin() || node1.getType().equals(ENodeType.REFERENCED_PROJECT)) {
             return 1;


Input:
public SpotDES initializeDesign() throws InPUTException {
    REXP designs = engine.eval("String_Node_Str");
    return new SpotDES(designs.asVector(), paramIds, inputROI);
}

Output:
 public SpotDES initializeDesign() throws InPUTException {
-    REXP designs = engine.eval("String_Node_Str");
+    REXP designs = runCommand("String_Node_Str", true);
     return new SpotDES(designs.asVector(), paramIds, inputROI);


Input:
private void handleNoGrailsNature(final IProject project, GrailsVersion grailsVersion) {
    debug("String_Node_Str" + project);
    final IGrailsInstall install = GrailsCoreActivator.getDefault().getInstallManager().getDefaultGrailsInstall();
    Assert.isTrue(install.getVersion().equals(grailsVersion));
    boolean convert = askConvertToGrailsProject(project, grailsVersion);
    if (convert) {
        debug("String_Node_Str");
        WorkspaceJob job = new WorkspaceJob("String_Node_Str" + project.getName() + "String_Node_Str") {
            public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
                monitor.beginTask("String_Node_Str", 2);
                try {
                    performLegacyConversion(project, new SubProgressMonitor(monitor, 1));
                    GrailsCommandUtils.eclipsifyProject(install, project);
                    monitor.worked(1);
                    return Status.OK_STATUS;
                } finally {
                    monitor.done();
                }
            }
        };
        job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
        job.setPriority(Job.INTERACTIVE);
        job.schedule();
    }
}

Output:
     debug("String_Node_Str" + project);
-    final IGrailsInstall install = GrailsCoreActivator.getDefault().getInstallManager().getDefaultGrailsInstall();
+    final IGrailsInstall install = GrailsCoreActivator.getDefault().getInstallManager().getGrailsInstall(project);
     Assert.isTrue(install.getVersion().equals(grailsVersion));


Input:
public static void main(String[] args) {
    try {
        address = args[0];
        port = Integer.parseInt(args[1]);
    } catch (Exception e) {
        System.out.println("String_Node_Str");
    }
    System.out.println("String_Node_Str" + port + "String_Node_Str" + "String_Node_Str" + address + "String_Node_Str" + file + "String_Node_Str" + index + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + callbackPort + "String_Node_Str");
    try {
        String output;
        output = downloadPush(file, null);
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = downloadPush(encodedFile, null);
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = downloadPush(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, null);
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        output = download(file, "String_Node_Str");
        test("String_Node_Str", output.equals("String_Node_Str"), output);
        Assert.that(URLDecoder.decode(encodedFile).equals(file), "String_Node_Str" + URLDecoder.decode(encodedFile));
        output = download(encodedFile, null);
        test("String_Node_Str", output.equals("String_Node_Str"), output);
    } catch (IOException e) {
        e.printStackTrace();
        Assert.that(false, "String_Node_Str");
    } catch (BadPacketException e) {
        e.printStackTrace();
        Assert.that(false, "String_Node_Str");
    }
}

Output:
     try {
-        String output;
-        output = downloadPush(file, null);
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = downloadPush(encodedFile, null);
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = downloadPush(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, null);
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
-        output = download(file, "String_Node_Str");
-        test("String_Node_Str", output.equals("String_Node_Str"), output);
+        boolean passed;
+        passed = downloadPush(file, null, "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = downloadPush(encodedFile, null, "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = downloadPush(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, null, "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
+        passed = download(file, "String_Node_Str", "String_Node_Str");
+        test("String_Node_Str", passed);
         Assert.that(URLDecoder.decode(encodedFile).equals(file), "String_Node_Str" + URLDecoder.decode(encodedFile));


Input:
public void postInvoke(Request request, Response response) throws IOException {
    if (!started || condition != null && null != request.getRequest().getAttribute(condition)) {
        return;
    }
    synchronized (lock) {
        if (charBuffer.position() == charBuffer.limit()) {
            charBuffer.limit(charBuffer.capacity());
        }
        int pos = charBuffer.position();
        for (int i = 0; i < 2; i++) {
            try {
                formatter.appendLogEntry(request, response, charBuffer);
                charBuffer.put("String_Node_Str");
                if (flushRealTime) {
                    log();
                }
                break;
            } catch (BufferOverflowException ex) {
                charBuffer.position(pos);
                log();
                if (i + 1 == 2) {
                    _logger.log(Level.SEVERE, ACCESS_LOG_UNABLE_TO_WRITE, new Object[] { ex });
                    return;
                }
            }
        }
    }
}

Output:
             try {
-                formatter.appendLogEntry(request, response, charBuffer);
-                charBuffer.put("String_Node_Str");
-                if (flushRealTime) {
-                    log();
+                if (formatter != null) {
+                    formatter.appendLogEntry(request, response, charBuffer);
+                    charBuffer.put("String_Node_Str");
+                    if (flushRealTime) {
+                        log();
+                    }
+                    break;
                 }


Input:
public int getCount() {
    return SettingUtility.enableGTask() ? 3 : 2;
}

Output:
 public int getCount() {
-    return SettingUtility.enableGTask() ? 3 : 2;
+    return 3;
 }


Input:
static void sendMessage(Player player, String message, String context) {
    PlayerData data = SRPG.playerDataManager.get(player);
    ArrayList<String> messageList = (ArrayList<String>) Settings.localization.get(SRPG.playerDataManager.get(player).locale).getStringList("String_Node_Str" + message, new ArrayList<String>());
    if (messageList.isEmpty()) {
        messageList.add(Settings.localization.get(SRPG.playerDataManager.get(player).locale).getString("String_Node_Str" + message, "String_Node_Str" + message + "String_Node_Str"));
    }
    if (Settings.localization.get(SRPG.playerDataManager.get(player).locale).getStringList("String_Node_Str", (new ArrayList<String>())).contains(message)) {
        String choice = messageList.get(SRPG.generator.nextInt(messageList.size()));
        messageList.clear();
        messageList.add(choice);
    }
    for (String line : messageList) {
        Pattern pattern = Pattern.compile("String_Node_Str");
        Matcher matcher = pattern.matcher(line);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            String match = matcher.group();
            if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, Integer.toString(data.free + data.spent));
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, data.xp.toString());
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, PlayerData.xpToLevel.toString());
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, data.free.toString());
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, Settings.nameReplacements.get(data.locale).get("String_Node_Str" + context));
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, data.skillpoints.get(context).toString());
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, context);
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, Settings.nameReplacements.get(data.locale).get("String_Node_Str" + context));
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                ArrayList<String> milestones = data.getMilestones(context);
                matcher.appendReplacement(sb, Settings.nameReplacements.get(data.locale).get("String_Node_Str" + milestones.get(milestones.size() - 1)));
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, data.charges.get(context).toString());
            } else if (match.equalsIgnoreCase("String_Node_Str")) {
                matcher.appendReplacement(sb, data.chargeProgress.get(context).toString());
            } else if (match.startsWith("String_Node_Str")) {
                matcher.appendReplacement(sb, Settings.advanced.getString(match.substring(2, match.length() - 1)));
            } else if (match.startsWith("String_Node_Str")) {
                double value = Settings.advanced.getDouble(match.substring(2, match.length() - 1), 0.0);
                String result = "String_Node_Str";
                if (value < 0.01) {
                    result = "String_Node_Str" + Integer.toString((int) (value * 1000));
                } else {
                    result = Integer.toString((int) (value * 100));
                }
                matcher.appendReplacement(sb, result + "String_Node_Str");
            } else if (Settings.nameReplacements.get(data.locale).containsKey(match.substring(1, match.length() - 1))) {
                matcher.appendReplacement(sb, Settings.nameReplacements.get(data.locale).get(match.substring(1, match.length() - 1)));
            }
        }
        matcher.appendTail(sb);
        pattern = Pattern.compile("String_Node_Str");
        matcher = pattern.matcher(sb.toString());
        sb = new StringBuffer();
        while (matcher.find()) {
            if (Settings.colorMap.containsKey(matcher.group())) {
                matcher.appendReplacement(sb, Settings.colorMap.get(matcher.group()));
            }
        }
        matcher.appendTail(sb);
        player.sendMessage(sb.toString());
    }
}

Output:
             } else if (match.equalsIgnoreCase("String_Node_Str")) {
-                matcher.appendReplacement(sb, data.xp.toString());
+                matcher.appendReplacement(sb, Integer.toString(data.xp % PlayerData.xpToLevel));
             } else if (match.equalsIgnoreCase("String_Node_Str")) {


Input:
private int lastRealMethod(int first) {
    int max = compiledMethods.length - 1;
    if (VM_Options.stackTraceFull) {
        return max;
    } else {
        for (int i = max; i >= first; i--) {
            if (compiledMethods[i] == INVISIBLE_METHOD_ID) {
                if (i - 1 >= 0) {
                    return i - 1;
                } else {
                    return max;
                }
            }
            VM_CompiledMethod compiledMethod = VM_CompiledMethods.getCompiledMethod(compiledMethods[i]);
            if (compiledMethod.getCompilerType() == VM_CompiledMethod.TRAP) {
                return max;
            }
            Class<?> frameClass = compiledMethod.getMethod().getDeclaringClass().getClassForType();
            if ((frameClass != org.jikesrvm.scheduler.VM_MainThread.class) && (frameClass != org.jikesrvm.scheduler.VM_Thread.class) && (frameClass != org.jikesrvm.runtime.VM_Reflection.class)) {
                return i;
            }
        }
        return max;
    }
}

Output:
             }
-            VM_CompiledMethod compiledMethod = VM_CompiledMethods.getCompiledMethod(compiledMethods[i]);
+            VM_CompiledMethod compiledMethod = getCompiledMethod(i);
             if (compiledMethod.getCompilerType() == VM_CompiledMethod.TRAP) {


Input:
public void onInitialized() {
    if (!isInitialized()) {
        try {
            File file = new File(filePath);
            this.queueFile = new QueueFile(file);
        } catch (IOException e) {
            if (log.isErrorEnabled()) {
                log.error(e.getLocalizedMessage());
            }
        }
        syncData();
    }
    super.onInitialized();
}

Output:
             File file = new File(filePath);
-            this.queueFile = new QueueFile(file);
+            this.queueFile = new TapeQueueFile(file);
         } catch (IOException e) {


Input:
private void resize(int newCapacity) {
    final int oldCapacity = m_vector.length;
    LValue[] newVector = new LValue[newCapacity];
    System.arraycopy(m_vector, 0, newVector, 0, Math.min(oldCapacity, newCapacity));
    if (newCapacity > oldCapacity) {
        if (m_hashKeys != null) {
            for (int i = oldCapacity; i < newCapacity; ++i) {
                int slot = findSlot(i + 1);
                if (m_hashKeys[slot] != null) {
                    newVector[i] = m_hashValues[slot];
                    m_hashKeys[slot] = null;
                    --m_hashEntries;
                } else {
                    newVector[i] = LNil.NIL;
                }
            }
            if (m_hashEntries == 0) {
                m_hashKeys = null;
                m_hashValues = null;
            }
        } else {
            for (int i = oldCapacity; i < newCapacity; ++i) {
                newVector[i] = LNil.NIL;
            }
        }
    } else {
        for (int i = newCapacity; i < oldCapacity; ++i) {
            LValue v = m_vector[i];
            if (v != LNil.NIL) {
                if (checkLoadFactor())
                    rehash();
                final int slot = findSlot(i + 1);
                m_hashKeys[slot] = LInteger.valueOf(i + 1);
                m_hashValues[slot] = v;
                ++m_hashEntries;
            }
        }
    }
    m_vector = newVector;
}

Output:
     if (newCapacity > oldCapacity) {
-        if (m_hashKeys != null) {
-            for (int i = oldCapacity; i < newCapacity; ++i) {
+        for (int i = oldCapacity; i < newCapacity; ++i) {
+            if (m_hashKeys != null) {
                 int slot = findSlot(i + 1);


Input:
void addCollection(Collection collection) throws SBOLValidationException {
    addTopLevel(collection, collections, "String_Node_Str", componentDefinitions, genericTopLevels, activities, plans, agents, models, moduleDefinitions, sequences, combinatorialDerivations);
}

Output:
 void addCollection(Collection collection) throws SBOLValidationException {
-    addTopLevel(collection, collections, "String_Node_Str", componentDefinitions, genericTopLevels, activities, plans, agents, models, moduleDefinitions, sequences, combinatorialDerivations);
+    addTopLevel(collection, collections, "String_Node_Str", componentDefinitions, genericTopLevels, activities, plans, agents, models, moduleDefinitions, sequences, combinatorialDerivations, implementations);
 }


Input:
protected float getGravityVelocity() {
    return pearlTypes.contains(EnderPearlEnhancements.NO_GRAVITY) ? 0F : (super.getGravityVelocity() * (pearlTypes.contains(EnderPearlEnhancements.INCREASED_RANGE) ? 0.75F : 1F));
}

Output:
 protected float getGravityVelocity() {
-    return pearlTypes.contains(EnderPearlEnhancements.NO_GRAVITY) ? 0F : (super.getGravityVelocity() * (pearlTypes.contains(EnderPearlEnhancements.INCREASED_RANGE) ? 0.75F : 1F));
+    return 1F;
 }


Input:
public static List<Map<String, Object>> getColumnMappingValue(Connection connection, IMetadataTable metaTable) {
    if (connection == null || metaTable == null) {
        return null;
    }
    List<Map<String, Object>> values = new ArrayList<Map<String, Object>>();
    List<IMetadataColumn> columns = metaTable.getListColumns();
    if (connection instanceof DatabaseConnection) {
        DatabaseConnection dbConn = (DatabaseConnection) connection;
        String databaseType = dbConn.getDatabaseType();
        if (EDatabaseTypeName.HBASE.getDisplayName().equals(databaseType)) {
            for (IMetadataColumn column : columns) {
                Map<String, Object> row = new HashMap<String, Object>();
                row.put("String_Node_Str", column.getLabel());
                row.put("String_Node_Str", TalendQuoteUtils.addQuotes(column.getAdditionalField().get("String_Node_Str")));
                values.add(row);
            }
        }
    }
    return values;
}

Output:
         String databaseType = dbConn.getDatabaseType();
-        if (EDatabaseTypeName.HBASE.getDisplayName().equals(databaseType)) {
+        if (EDatabaseTypeName.HBASE.getDisplayName().equals(databaseType) || EDatabaseTypeName.MAPRDB.getDisplayName().equals(databaseType)) {
             for (IMetadataColumn column : columns) {


Input:
private Pair<String, TtmlRegion> parseRegionAttributes(XmlPullParser xmlParser) {
    String regionId = ParserUtil.getAttributeValue(xmlParser, TtmlNode.ATTR_ID);
    String regionOrigin = ParserUtil.getAttributeValue(xmlParser, TtmlNode.ATTR_TTS_ORIGIN);
    String regionExtent = ParserUtil.getAttributeValue(xmlParser, TtmlNode.ATTR_TTS_EXTENT);
    if (regionOrigin == null || regionId == null) {
        return null;
    }
    float position = Cue.DIMEN_UNSET;
    float line = Cue.DIMEN_UNSET;
    Matcher originMatcher = PERCENTAGE_COORDINATES.matcher(regionOrigin);
    if (originMatcher.matches()) {
        try {
            position = Float.parseFloat(originMatcher.group(1)) / 100.f;
            line = Float.parseFloat(originMatcher.group(2)) / 100.f;
        } catch (NumberFormatException e) {
            Log.w(TAG, "String_Node_Str" + regionOrigin + "String_Node_Str", e);
            position = Cue.DIMEN_UNSET;
        }
    }
    float width = Cue.DIMEN_UNSET;
    if (regionExtent != null) {
        Matcher extentMatcher = PERCENTAGE_COORDINATES.matcher(regionExtent);
        if (extentMatcher.matches()) {
            try {
                width = Float.parseFloat(extentMatcher.group(1)) / 100.f;
            } catch (NumberFormatException e) {
                Log.w(TAG, "String_Node_Str" + regionExtent + "String_Node_Str", e);
            }
        }
    }
    return position != Cue.DIMEN_UNSET ? new Pair<>(regionId, new TtmlRegion(position, line, width)) : null;
}

Output:
     }
-    return position != Cue.DIMEN_UNSET ? new Pair<>(regionId, new TtmlRegion(position, line, width)) : null;
+    return position != Cue.DIMEN_UNSET ? new Pair<>(regionId, new TtmlRegion(position, line, Cue.LINE_TYPE_FRACTION, width)) : null;
 }


Input:
public void updateName(String key, String name, String version, Integer permission, String remoteAddr) {
    try {
        Server server = ServerManager.getAuthorizedServer(key, remoteAddr, name);
        server.setName(name);
        server.setPermission(permission);
        server.setUpdated(new Date());
        server.setPluginVersion(version);
        serverDAO.save(server);
    } catch (UnauthorizedUpdateException e) {
        try {
            MailManager.getInstance().sendAdminMail("String_Node_Str", e.getMessage(), null);
        } catch (Exception me) {
            log.error(me.getMessage());
        }
        log.error(e.getMessage());
    } catch (Exception e) {
        log.error(e.getMessage());
        StringWriter w = new StringWriter();
        e.printStackTrace(new PrintWriter(w));
        log.error(w.getBuffer().toString());
    }
}

Output:
         server.setName(name);
-        server.setPermission(permission);
+        server.setRemotePermission(permission);
         server.setUpdated(new Date());


Input:
public Set<Long> getPCRsForPath(final Path<QNm> path) throws PathException {
    Set<Long> pcrSet = mPathCache.get(path);
    if (pcrSet != null) {
        return pcrSet;
    }
    pcrSet = new HashSet<Long>();
    final boolean isAttributePattern = path.isAttribute();
    final int pathLength = path.getLength();
    final long nodeKey = mCurrentNode.getNodeKey();
    moveToDocumentRoot();
    for (final Axis axis = new DescendantAxis(this); axis.hasNext(); ) {
        axis.next();
        final PathNode node = this.getPathNode();
        if (node == null) {
            continue;
        }
        if (node.getLevel() < pathLength) {
            continue;
        }
        if (isAttributePattern ^ (node.getPathKind() == Kind.ATTRIBUTE)) {
            continue;
        }
        if (path.matches(node.getPath(this))) {
            pcrSet.add(node.getNodeKey());
        }
    }
    moveTo(nodeKey);
    mPathCache.put(path, pcrSet);
    return pcrSet;
}

Output:
     moveTo(nodeKey);
-    mPathCache.put(path, pcrSet);
+    if (useCache)
+        mPathCache.put(path, pcrSet);
     return pcrSet;


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object objectValue, AbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    if (objectValue == null) {
        return false;
    }
    String mimeType = this.xmlBinaryDataCollectionMapping.getMimeType(object);
    if (mimeType == null) {
        mimeType = XMLConstants.EMPTY_STRING;
    }
    XMLMarshaller marshaller = marshalRecord.getMarshaller();
    if (xmlBinaryDataCollectionMapping.getValueConverter() != null) {
        Converter converter = xmlBinaryDataCollectionMapping.getValueConverter();
        if (converter instanceof XMLConverter) {
            objectValue = ((XMLConverter) converter).convertObjectValueToDataValue(objectValue, session, marshaller);
        } else {
            objectValue = converter.convertObjectValueToDataValue(objectValue, session);
        }
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    marshalRecord.closeStartGroupingElements(groupingFragment);
    marshalRecord.openStartElement(xPathFragment, namespaceResolver);
    marshalRecord.closeStartElement();
    if (xmlBinaryDataCollectionMapping.isSwaRef() && marshaller.getAttachmentMarshaller() != null) {
        String c_id = null;
        byte[] bytes = null;
        if (xmlBinaryDataCollectionMapping.getAttributeElementClass() == XMLBinaryDataHelper.getXMLBinaryDataHelper().DATA_HANDLER) {
            c_id = marshaller.getAttachmentMarshaller().addSwaRefAttachment((DataHandler) objectValue);
        } else {
            XMLBinaryDataHelper.EncodedData data = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(objectValue, marshaller, xmlBinaryDataCollectionMapping.getMimeType(object));
            bytes = data.getData();
            c_id = marshaller.getAttachmentMarshaller().addSwaRefAttachment(bytes, 0, bytes.length);
        }
        if (c_id != null) {
            marshalRecord.characters(c_id);
        } else {
            marshalRecord.characters(((XMLField) xmlBinaryDataCollectionMapping.getField()).getSchemaType(), objectValue, mimeType, false);
        }
    } else {
        if (marshalRecord.isXOPPackage() && !xmlBinaryDataCollectionMapping.shouldInlineBinaryData()) {
            XPathFragment lastFrag = ((XMLField) xmlBinaryDataCollectionMapping.getField()).getLastXPathFragment();
            String c_id = XMLConstants.EMPTY_STRING;
            byte[] bytes = null;
            if (objectValue.getClass() == ClassConstants.APBYTE) {
                bytes = (byte[]) objectValue;
                c_id = marshaller.getAttachmentMarshaller().addMtomAttachment(bytes, 0, bytes.length, this.xmlBinaryDataCollectionMapping.getMimeType(object), lastFrag.getLocalName(), lastFrag.getNamespaceURI());
            } else if (xmlBinaryDataCollectionMapping.getAttributeElementClass() == XMLBinaryDataHelper.getXMLBinaryDataHelper().DATA_HANDLER) {
                c_id = marshaller.getAttachmentMarshaller().addMtomAttachment((DataHandler) objectValue, lastFrag.getLocalName(), lastFrag.getNamespaceURI());
            } else {
                XMLBinaryDataHelper.EncodedData data = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(objectValue, marshaller, xmlBinaryDataCollectionMapping.getMimeTypePolicy().getMimeType(object));
                bytes = data.getData();
                c_id = marshaller.getAttachmentMarshaller().addMtomAttachment(bytes, 0, bytes.length, data.getMimeType(), lastFrag.getLocalName(), lastFrag.getNamespaceURI());
            }
            if (c_id == null) {
                marshalRecord.characters(((XMLField) xmlBinaryDataCollectionMapping.getField()).getSchemaType(), objectValue, mimeType, false);
            } else {
                boolean addDeclaration = false;
                String xopPrefix = null;
                if (marshalRecord.getNamespaceResolver() != null) {
                    xopPrefix = marshalRecord.getNamespaceResolver().resolveNamespaceURI(XMLConstants.XOP_URL);
                }
                if (xopPrefix == null) {
                    addDeclaration = true;
                    xopPrefix = marshalRecord.getNamespaceResolver().generatePrefix(XMLConstants.XOP_PREFIX);
                    marshalRecord.getNamespaceResolver().put(xopPrefix, XMLConstants.XOP_URL);
                    namespaceResolver = marshalRecord.getNamespaceResolver();
                }
                XPathFragment xopInclude = new XPathFragment(xopPrefix + "String_Node_Str");
                xopInclude.setNamespaceURI(XMLConstants.XOP_URL);
                marshalRecord.openStartElement(xopInclude, namespaceResolver);
                marshalRecord.attribute(XMLConstants.EMPTY_STRING, "String_Node_Str", "String_Node_Str", c_id);
                if (addDeclaration) {
                    marshalRecord.attribute(XMLConstants.XMLNS_URL, xopPrefix, XMLConstants.XMLNS + XMLConstants.COLON + xopPrefix, XMLConstants.XOP_URL);
                }
                marshalRecord.closeStartElement();
                marshalRecord.endElement(xPathFragment, namespaceResolver);
                if (addDeclaration) {
                    marshalRecord.getNamespaceResolver().removeNamespace(XMLConstants.XOP_PREFIX);
                }
            }
        } else {
            marshalRecord.characters(((XMLField) xmlBinaryDataCollectionMapping.getField()).getSchemaType(), objectValue, mimeType, false);
        }
    }
    marshalRecord.endElement(xPathFragment, namespaceResolver);
    return true;
}

Output:
                 if (addDeclaration) {
-                    marshalRecord.attribute(XMLConstants.XMLNS_URL, xopPrefix, XMLConstants.XMLNS + XMLConstants.COLON + xopPrefix, XMLConstants.XOP_URL);
+                    marshalRecord.namespaceDeclaration(xopPrefix, XMLConstants.XOP_URL);
                 }


Input:
public void mapCertificate_noCN() throws Exception {
    final X509Certificate cert = mock.mock(X509Certificate.class);
    final X500Principal principal = new X500Principal("String_Node_Str");
    mock.checking(new Expectations() {
        {
            allowing(cert).getSubjectX500Principal();
            will(returnValue(principal));
        }
    });
    reg.mapCertificate(cert);
}

Output:
     });
-    reg.mapCertificate(cert);
+    reg.mapCertificate(new X509Certificate[] { cert });
 }


Input:
public void generateAnyAttributeMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
    XMLAnyAttributeMapping mapping = new XMLAnyAttributeMapping();
    mapping.setAttributeName(property.getPropertyName());
    if (property.isMethodProperty()) {
        mapping.setGetMethodName(property.getGetMethodName());
        mapping.setSetMethodName(property.getSetMethodName());
    }
    mapping.setSchemaInstanceIncluded(false);
    mapping.setNamespaceDeclarationIncluded(false);
    descriptor.addMapping(mapping);
}

Output:
     if (property.isMethodProperty()) {
-        mapping.setGetMethodName(property.getGetMethodName());
-        mapping.setSetMethodName(property.getSetMethodName());
+        if (property.getSetMethodName() != null) {
+            mapping.setSetMethodName(property.getSetMethodName());
+            mapping.setGetMethodName(property.getGetMethodName());
+        } else {
+            mapping.setGetMethodName(property.getGetMethodName());
+        }
     }


Input:
public void info(Player p, NPC n) {
    if (plugin.spoutcraft && plugin.spoutconnect.enabled(p)) {
        plugin.spoutconnect.showNPCScreen(p, n);
    } else {
        p.sendMessage(ChatColor.GRAY + "String_Node_Str" + n.getID());
        if (n instanceof BankerNPC) {
            p.sendMessage(ChatColor.GRAY + "String_Node_Str");
        } else if (n instanceof BankManagerNPC) {
            p.sendMessage(ChatColor.GRAY + "String_Node_Str");
        } else if (n instanceof BlacksmithNPC) {
            p.sendMessage(ChatColor.GRAY + "String_Node_Str");
        } else if (n instanceof StaticNPC) {
            p.sendMessage(ChatColor.GRAY + "String_Node_Str");
        } else {
            p.sendMessage(ChatColor.GRAY + "String_Node_Str");
        }
        p.sendMessage(ChatColor.GRAY + "String_Node_Str" + n.getName());
        p.sendMessage(ChatColor.GRAY + "String_Node_Str" + ((StaticNPC) n).getSkinURL());
    }
}

Output:
         p.sendMessage(ChatColor.GRAY + "String_Node_Str" + n.getName());
-        p.sendMessage(ChatColor.GRAY + "String_Node_Str" + ((StaticNPC) n).getSkinURL());
+        p.sendMessage(ChatColor.GRAY + "String_Node_Str" + n.getSkinURL());
     }


Input:
public void setSubtitleSize(float subtitleSize) {
    mTitleSize = subtitleSize;
    invalidate();
}

Output:
 public void setSubtitleSize(float subtitleSize) {
-    mTitleSize = subtitleSize;
-    invalidate();
+    mSubtitleSize = subtitleSize;
+    invalidateTextPaints();
 }


Input:
public Boolean getBooleanValue() {
    if (getType() == null || !"String_Node_Str".equals(getType())) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    return (Boolean) value;
}

Output:
     }
-    return (Boolean) value;
+    Boolean res;
+    if (values == null && values.isEmpty()) {
+        res = null;
+    } else {
+        res = (Boolean) values.iterator().next();
+    }
+    return res;
 }


Input:
public void layout() {
    if (type == Type.CHECKBOX || type == Type.RADIO) {
        AbstractButton oldButton = button;
        button = new JToggleButton();
        button.setText(oldButton.getText());
        button.setIcon(oldButton.getIcon());
        button.setEnabled(oldButton.isEnabled());
        button.setSelected(this.selected);
        if (this.getOnclick() != null) {
            this.setOnclick(this.getOnclick());
        }
        managedObject = button;
        if (this.group != null) {
            button.addComponentListener(new ComponentListener() {
                public void componentHidden(ComponentEvent arg0) {
                }
                public void componentMoved(ComponentEvent arg0) {
                }
                public void componentShown(ComponentEvent arg0) {
                }
                public void componentResized(ComponentEvent arg0) {
                    buttonGroup = ((SwingWindow) SwingButton.this.getDocument().getRootElement()).getButtonGroup(group);
                    buttonGroup.add(button);
                    if (buttonGroup.getButtonCount() == 1) {
                        button.setSelected(true);
                    }
                    button.removeComponentListener(this);
                }
            });
        }
    }
    if (this.orientation == Orient.VERTICAL) {
        this.button.setHorizontalTextPosition(JButton.CENTER);
        if (this.dir == Direction.FORWARD) {
            this.button.setVerticalTextPosition(JButton.BOTTOM);
        } else {
            this.button.setVerticalTextPosition(JButton.TOP);
        }
    } else {
        this.button.setVerticalTextPosition(JButton.CENTER);
        if (this.dir == Direction.FORWARD) {
            this.button.setHorizontalTextPosition(JButton.RIGHT);
        } else {
            this.button.setHorizontalTextPosition(JButton.LEFT);
        }
    }
    if (button.getText().equals("String_Node_Str") && button.getIcon().getIconHeight() == button.getIcon().getIconWidth()) {
        Dimension dim = button.getPreferredSize();
        button.setMinimumSize(new Dimension(dim.height, dim.height));
        button.setPreferredSize(new Dimension(dim.height, dim.height));
    }
    super.layout();
}

Output:
     }
-    if (button.getText().equals("String_Node_Str") && button.getIcon().getIconHeight() == button.getIcon().getIconWidth()) {
+    if (button.getText().equals("String_Node_Str") && button.getIcon() != null && button.getIcon().getIconHeight() == button.getIcon().getIconWidth()) {
         Dimension dim = button.getPreferredSize();


Input:
public void burn() {
    currentOutput = 0;
    LiquidStack fuel = this.fuelTank.getLiquid();
    IronEngineFuel currentFuel = IronEngineFuel.getFuelForLiquid(fuel);
    if (currentFuel == null) {
        return;
    }
    if (penaltyCooling <= 0 && tile.isRedstonePowered) {
        lastPowered = true;
        if (burnTime > 0 || fuel.amount > 0) {
            if (burnTime > 0) {
                burnTime--;
            } else {
                fuel.amount--;
                burnTime = currentFuel.totalBurningTime / LiquidContainerRegistry.BUCKET_VOLUME;
            }
            currentOutput = currentFuel.powerPerCycle;
            addEnergy(currentFuel.powerPerCycle);
            heat += currentFuel.powerPerCycle;
        }
    } else if (penaltyCooling <= 0) {
        if (lastPowered) {
            lastPowered = false;
            penaltyCooling = 30 * 20;
        }
    }
}

Output:
             } else {
-                fuel.amount--;
+                if (--fuel.amount <= 0)
+                    fuelTank.setLiquid(null);
                 burnTime = currentFuel.totalBurningTime / LiquidContainerRegistry.BUCKET_VOLUME;


Input:
protected void onPostExecute(APIResponse.CODE code) {
    View view = fragment.getView();
    if (view != null && activity != null) {
        ExpandableListAdapter adapter = new ExpandableListAdapter(activity, groups);
        ExpandableListView listView = (ExpandableListView) view.findViewById(R.id.team_media_list);
        TextView noDataText = (TextView) view.findViewById(R.id.no_media);
        if (code == APIResponse.CODE.NODATA || adapter.groups.isEmpty()) {
            noDataText.setVisibility(View.VISIBLE);
        } else {
            listView.setAdapter(adapter);
            for (int i = 0; i < groups.size(); i++) {
                listView.expandGroup(i);
            }
        }
        if (code == APIResponse.CODE.OFFLINECACHE) {
            activity.showWarningMessage(activity.getString(R.string.warning_using_cached_data));
        }
        view.findViewById(R.id.progress).setVisibility(View.GONE);
        view.findViewById(R.id.team_media_list).setVisibility(View.VISIBLE);
        if (code == APIResponse.CODE.LOCAL && !isCancelled()) {
            PopulateTeamMedia secondLoad = new PopulateTeamMedia(fragment, false);
            fragment.updateTask(secondLoad);
            secondLoad.execute(team, year);
        } else {
            if (fragment instanceof RefreshListener) {
                activity.notifyRefreshComplete(fragment);
            }
        }
    }
}

Output:
         ExpandableListAdapter adapter = new ExpandableListAdapter(activity, groups);
-        ExpandableListView listView = (ExpandableListView) view.findViewById(R.id.team_media_list);
+        ExpandableListView media = (ExpandableListView) view.findViewById(R.id.team_media_list);
         TextView noDataText = (TextView) view.findViewById(R.id.no_media);


Input:
private SpvBalanceFetcher getSpvBchFetcher() {
    SpvBalanceFetcher result = null;
    if (CommunicationManager.getInstance(_applicationContext).getPairedModules().contains(GooglePlayModuleCollection.INSTANCE.getModules(_applicationContext).get("String_Node_Str"))) {
        result = new SpvBchFetcher(_applicationContext);
    }
    return result;
}

Output:
     SpvBalanceFetcher result = null;
-    if (CommunicationManager.getInstance(_applicationContext).getPairedModules().contains(GooglePlayModuleCollection.INSTANCE.getModules(_applicationContext).get("String_Node_Str"))) {
+    if (CommunicationManager.getInstance(_applicationContext).getPairedModules().contains(GooglePlayModuleCollection.getModules(_applicationContext).get("String_Node_Str"))) {
         result = new SpvBchFetcher(_applicationContext);


Input:
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
    String kernelId = determineKernelId(bootSet);
    LOG.debug("String_Node_Str" + kernelId + "String_Node_Str" + bootSet.toString());
    try {
        KernelImageInfo kernel = RestrictedTypes.doPrivileged(kernelId, LookupKernel.INSTANCE, true);
        return new NoRamdiskBootableSet(bootSet.getMachine(), kernel);
    } catch (Exception ex) {
        throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str" + ex.getMessage(), ex);
    }
}

Output:
     try {
-        KernelImageInfo kernel = RestrictedTypes.doPrivileged(kernelId, LookupKernel.INSTANCE, true);
+        KernelImageInfo kernel = RestrictedTypes.doPrivilegedWithoutOwner(kernelId, LookupKernel.INSTANCE);
         return new NoRamdiskBootableSet(bootSet.getMachine(), kernel);


Input:
private void dumpService(String prefix, FileDescriptor fd, PrintWriter pw, final ServiceRecord r, String[] args, boolean dumpAll) {
    String innerPrefix = prefix + "String_Node_Str";
    synchronized (this) {
        pw.print(prefix);
        pw.print("String_Node_Str");
        pw.print(r.shortName);
        pw.print("String_Node_Str");
        pw.print(Integer.toHexString(System.identityHashCode(r)));
        pw.print("String_Node_Str");
        if (r.app != null)
            pw.println(r.app.pid);
        else
            pw.println("String_Node_Str");
        if (dumpAll) {
            r.dump(pw, innerPrefix);
        }
    }
    if (r.app != null && r.app.thread != null) {
        pw.print(prefix);
        pw.println("String_Node_Str");
        pw.flush();
        try {
            TransferPipe tp = new TransferPipe();
            try {
                r.app.thread.dumpService(tp.getWriteFd().getFileDescriptor(), r, args);
                tp.setBufferPrefix(prefix + "String_Node_Str");
                tp.go(fd);
            } finally {
                tp.kill();
            }
        } catch (IOException e) {
            pw.println(prefix + "String_Node_Str" + e);
        } catch (RemoteException e) {
            pw.println(prefix + "String_Node_Str");
        }
    }
}

Output:
     String innerPrefix = prefix + "String_Node_Str";
-    synchronized (this) {
+    synchronized (mAm) {
         pw.print(prefix);


Input:
private boolean waitForStatus(String volumeId, Volume.Status expectedStatus, int timeoutInMins) throws TimeoutException {
    long timeout = 1000 * 60 * timeoutInMins;
    long timout = System.currentTimeMillis() + timeout;
    IaasProvider iaasInfo = getIaasProvider();
    String region = ComputeServiceBuilderUtil.extractRegion(iaasInfo);
    ComputeServiceContext context = iaasInfo.getComputeService().getContext();
    ;
    NovaApi novaApi = context.unwrapApi(NovaApi.class);
    VolumeApi volumeApi = novaApi.getVolumeExtensionForZone(region).get();
    Volume.Status volumeStatus = this.getVolumeStatus(volumeApi, volumeId);
    while (volumeStatus != expectedStatus) {
        try {
            if (log.isDebugEnabled()) {
                log.debug(String.format("String_Node_Str", volumeId, expectedStatus, volumeStatus));
            }
            if (volumeStatus == Volume.Status.ERROR) {
                log.error("String_Node_Str" + volumeId + "String_Node_Str");
                return false;
            }
            Thread.sleep(1000);
            volumeStatus = this.getVolumeStatus(volumeApi, volumeId);
            if (System.currentTimeMillis() > timout) {
                throw new TimeoutException();
            }
        } catch (InterruptedException e) {
        }
    }
    if (log.isDebugEnabled()) {
        log.debug(String.format("String_Node_Str", volumeId, expectedStatus));
    }
    return true;
}

Output:
 private boolean waitForStatus(String volumeId, Volume.Status expectedStatus, int timeoutInMins) throws TimeoutException {
-    long timeout = 1000 * 60 * timeoutInMins;
+    int timeout = 1000 * 60 * timeoutInMins;
     long timout = System.currentTimeMillis() + timeout;


Input:
private GraphTargetItem type(List<VariableActionItem> variables) throws IOException, ActionParseException {
    GraphTargetItem ret = null;
    ParsedSymbol s = lex();
    expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.STRING_OP);
    ret = new VariableActionItem(s.value.toString(), null, false);
    variables.add((VariableActionItem) ret);
    s = lex();
    while (s.type == SymbolType.DOT) {
        s = lex();
        expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.STRING_OP);
        ret = new GetMemberActionItem(null, ret, pushConst(s.value.toString()));
        s = lex();
    }
    lexer.pushback(s);
    return ret;
}

Output:
         s = lex();
-        expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.STRING_OP);
+        expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.STRING_OP, SymbolGroup.GLOBALFUNC);
         ret = new GetMemberActionItem(null, ret, pushConst(s.value.toString()));


Input:
public static void main(String[] args) throws Exception {
    test4();
}

Output:
 public static void main(String[] args) throws Exception {
-    test4();
+    test6();
 }


Input:
public void populate(Event event) {
    eventSource = event.getEventSource();
    userAgent = event.getUserAgent();
    if (event.getUserIdentity() != null) {
        userIdentityPrincipalId = event.getUserIdentity().getPrincipalId();
        userIdentityArn = event.getUserIdentity().getArn();
        userIdentityUsername = event.getUserIdentity().getUserName();
        userIdentityInvokedBy = event.getUserIdentity().getInvokedBy();
        if (event.getUserIdentity().getSessionContext() != null && event.getUserIdentity().getSessionContext().getSessionIssuer() != null) {
            sessionContextPrincipalId = event.getUserIdentity().getSessionContext().getSessionIssuer().getPrincipalId();
            sessionContextArn = event.getUserIdentity().getSessionContext().getSessionIssuer().getArn();
            sessionContextUsername = event.getUserIdentity().getSessionContext().getSessionIssuer().getUserName();
        }
    }
}

Output:
 public void populate(Event event) {
-    eventSource = event.getEventSource();
-    userAgent = event.getUserAgent();
+    eventSource.add(event.getEventSource());
+    userAgent.add(event.getUserAgent());
     if (event.getUserIdentity() != null) {


Input:
public void testAgressiveFiltering() {
    BasicEventList source = new BasicEventList();
    IntArrayFilterList filterList = new IntArrayFilterList(source);
    SortedList sorted = new SortedList(filterList, new IntArrayComparator(0));
    for (int i = 0; i < 20; i++) {
        int value = random.nextInt(10);
        int[] array = new int[] { value, random.nextInt(2), random.nextInt(2), random.nextInt(2) };
        source.add(array);
    }
    for (int i = 0; i < 100; i++) {
        int filterColumn = random.nextInt(3);
        filterList.setFilter(filterColumn + 1, 1);
        ArrayList controlList = new ArrayList();
        controlList.addAll(filterList);
        Collections.sort(controlList, new IntArrayComparator(0));
        System.out.println("String_Node_Str" + sorted.size() + "String_Node_Str" + controlList.size());
        System.out.print("String_Node_Str");
        for (int j = 0; j < controlList.size(); j++) {
            System.out.print(((int[]) controlList.get(j))[0] + "String_Node_Str");
        }
        System.out.println("String_Node_Str");
        System.out.print("String_Node_Str");
        for (int j = 0; j < filterList.size(); j++) {
            System.out.print(((int[]) filterList.get(j))[0] + "String_Node_Str");
        }
        System.out.println("String_Node_Str");
        System.out.print("String_Node_Str");
        for (int j = 0; j < sorted.size(); j++) {
            System.out.print(((int[]) sorted.get(j))[0] + "String_Node_Str");
        }
        System.out.println("String_Node_Str");
        assertEquals(sorted.size(), controlList.size());
        for (int j = 0; j < sorted.size(); j++) {
            assertEquals(((int[]) sorted.get(j))[0], ((int[]) controlList.get(j))[0]);
        }
    }
}

Output:
     SortedList sorted = new SortedList(filterList, new IntArrayComparator(0));
-    for (int i = 0; i < 20; i++) {
-        int value = random.nextInt(10);
+    for (int i = 0; i < 1000; i++) {
+        int value = random.nextInt(1000);
         int[] array = new int[] { value, random.nextInt(2), random.nextInt(2), random.nextInt(2) };


Input:
public void listChanged(ListEvent listChanges) {
    swtSource.getReadWriteLock().readLock().lock();
    try {
        while (listChanges.next()) {
            int changeIndex = listChanges.getIndex();
            int changeType = listChanges.getType();
            if (changeType == ListEvent.INSERT) {
                addRow(changeIndex, swtSource.get(changeIndex));
            } else if (changeType == ListEvent.UPDATE) {
                updateRow(changeIndex, swtSource.get(changeIndex));
            } else if (changeType == ListEvent.DELETE) {
                deleteRow(changeIndex);
            }
        }
    } finally {
        swtSource.getReadWriteLock().readLock().unlock();
    }
}

Output:
 public void listChanged(ListEvent listChanges) {
-    swtSource.getReadWriteLock().readLock().lock();
-    try {
-        while (listChanges.next()) {
-            int changeIndex = listChanges.getIndex();
-            int changeType = listChanges.getType();
-            if (changeType == ListEvent.INSERT) {
-                addRow(changeIndex, swtSource.get(changeIndex));
-            } else if (changeType == ListEvent.UPDATE) {
-                updateRow(changeIndex, swtSource.get(changeIndex));
-            } else if (changeType == ListEvent.DELETE) {
-                deleteRow(changeIndex);
-            }
+    while (listChanges.next()) {
+        int changeIndex = listChanges.getIndex();
+        int changeType = listChanges.getType();
+        if (changeType == ListEvent.INSERT) {
+            addRow(changeIndex, swtSource.get(changeIndex));
+        } else if (changeType == ListEvent.UPDATE) {
+            updateRow(changeIndex, swtSource.get(changeIndex));
+        } else if (changeType == ListEvent.DELETE) {
+            deleteRow(changeIndex);
         }


Input:
public int horizontalOr_EWAH32(BenchmarkState benchmarkState) {
    EWAHCompressedBitmap32 bitmapor = benchmarkState.ewah32.get(0);
    for (int j = 1; j < benchmarkState.ewah32.size(); ++j) {
        bitmapor = bitmapor.or(benchmarkState.ewah32.get(j));
    }
    int answer = bitmapor.cardinality();
    return answer;
}

Output:
 public int horizontalOr_EWAH32(BenchmarkState benchmarkState) {
-    EWAHCompressedBitmap32 bitmapor = benchmarkState.ewah32.get(0);
-    for (int j = 1; j < benchmarkState.ewah32.size(); ++j) {
-        bitmapor = bitmapor.or(benchmarkState.ewah32.get(j));
-    }
+    EWAHCompressedBitmap32[] a = new EWAHCompressedBitmap32[benchmarkState.ewah32.size()];
+    EWAHCompressedBitmap32 bitmapor = EWAHCompressedBitmap32.or(benchmarkState.ewah32.toArray(a));
     int answer = bitmapor.cardinality();


Input:
public double[][] learn(double[] x, double[] y) {
    double[][] data = dataset[datasetIndex].toArray(new double[dataset[datasetIndex].size()][]);
    int[] label = dataset[datasetIndex].toArray(new int[dataset[datasetIndex].size()]);
    try {
        k = Integer.parseInt(kField.getText().trim());
        if (k < 2 || k > data.length) {
            JOptionPane.showMessageDialog(this, "String_Node_Str" + k, "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            return null;
        }
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(this, "String_Node_Str" + kField.getText(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        return null;
    }
    double[][] centers = new double[k][];
    RadialBasisFunction basis = SmileUtils.learnGaussianRadialBasis(data, centers);
    RBFNetwork<double[]> rbf = new RBFNetwork<>(data, label, new EuclideanDistance(), basis, centers);
    for (int i = 0; i < label.length; i++) {
        label[i] = rbf.predict(data[i]);
    }
    double trainError = error(label, label);
    System.out.format("String_Node_Str", 100 * trainError);
    double[][] z = new double[y.length][x.length];
    for (int i = 0; i < y.length; i++) {
        for (int j = 0; j < x.length; j++) {
            double[] p = { x[j], y[i] };
            z[i][j] = rbf.predict(p);
        }
    }
    return z;
}

Output:
     for (int i = 0; i < label.length; i++) {
-        label[i] = rbf.predict(data[i]);
+        pred[i] = rbf.predict(data[i]);
     }


Input:
private void getPrecontinues(String path, BaseLocalData localData, GraphPart parent, GraphPart part, List<GraphPart> allParts, List<Loop> loops, List<GraphPart> stopPart) throws InterruptedException {
    try {
        markLevels(path, localData, part, allParts, loops);
    } catch (InterruptedException iex) {
        throw iex;
    } catch (Throwable ex) {
    }
    looploops: for (Loop l : loops) {
        if (l.loopContinue != null) {
            Set<GraphPart> uniqueRefs = new HashSet<>();
            uniqueRefs.addAll(l.loopContinue.refs);
            if (uniqueRefs.size() == 2) {
                List<GraphPart> uniqueRefsList = new ArrayList<>(uniqueRefs);
                if (uniqueRefsList.get(0).discoveredTime > uniqueRefsList.get(1).discoveredTime) {
                    part = uniqueRefsList.get(0);
                } else {
                    part = uniqueRefsList.get(1);
                }
                if (part == l.loopContinue) {
                    continue looploops;
                }
                while (part.refs.size() == 1) {
                    if (part.refs.get(0).nextParts.size() != 1) {
                        continue looploops;
                    }
                    part = part.refs.get(0);
                    if (part == l.loopContinue) {
                        break;
                    }
                }
                if (part.level == 0 && part != l.loopContinue) {
                    l.loopPreContinue = part;
                }
            }
        }
    }
}

Output:
         markLevels(path, localData, part, allParts, loops);
-    } catch (InterruptedException iex) {
+    } catch (ThreadDeath | InterruptedException iex) {
         throw iex;


Input:
public boolean leave(UUID playerId) {
    MatchPlayer mPlayer = getPlayer(playerId);
    if (mPlayer != null) {
        boolean result = players.remove(mPlayer);
        synchronized (this) {
            this.notifyAll();
        }
        return result;
    }
    return false;
}

Output:
     if (mPlayer != null) {
-        boolean result = players.remove(mPlayer);
+        mPlayer.setQuit(true);
         synchronized (this) {


Input:
private void loadConfiguration(FMLPreInitializationEvent e) {
    Configuration cfg = new Configuration(e.getSuggestedConfigurationFile());
    try {
        cfg.load();
        cfg.addCustomCategoryComment(CATEGORY_CRAFTER, "String_Node_Str");
        cfg.addCustomCategoryComment(CATEGORY_STORAGE_MONITOR, "String_Node_Str");
        cfg.addCustomCategoryComment(CATEGORY_NETWORK_MONITOR, "String_Node_Str");
        CrafterBlockTileEntity3.rfPerOperation = cfg.get(CATEGORY_CRAFTER, "String_Node_Str", CrafterBlockTileEntity3.rfPerOperation, "String_Node_Str").getInt();
        CrafterBlockTileEntity3.speedOperations = cfg.get(CATEGORY_CRAFTER, "String_Node_Str", CrafterBlockTileEntity3.speedOperations, "String_Node_Str").getInt();
        StorageScannerTileEntity.rfPerOperation = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", StorageScannerTileEntity.rfPerOperation, "String_Node_Str").getInt();
        StorageScannerTileEntity.scansPerOperation = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", StorageScannerTileEntity.scansPerOperation, "String_Node_Str").getInt();
        GuiStorageScanner.hilightTime = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", GuiStorageScanner.hilightTime, "String_Node_Str").getInt();
        GuiNetworkMonitor.hilightTime = cfg.get(CATEGORY_NETWORK_MONITOR, "String_Node_Str", GuiNetworkMonitor.hilightTime, "String_Node_Str").getInt();
    } catch (Exception e1) {
        FMLLog.log(Level.ERROR, e1, "String_Node_Str");
    } finally {
        if (cfg.hasChanged()) {
            cfg.save();
        }
    }
}

Output:
         StorageScannerTileEntity.scansPerOperation = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", StorageScannerTileEntity.scansPerOperation, "String_Node_Str").getInt();
-        GuiStorageScanner.hilightTime = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", GuiStorageScanner.hilightTime, "String_Node_Str").getInt();
-        GuiNetworkMonitor.hilightTime = cfg.get(CATEGORY_NETWORK_MONITOR, "String_Node_Str", GuiNetworkMonitor.hilightTime, "String_Node_Str").getInt();
+        StorageScannerTileEntity.hilightTime = cfg.get(CATEGORY_STORAGE_MONITOR, "String_Node_Str", StorageScannerTileEntity.hilightTime, "String_Node_Str").getInt();
+        NetworkMonitorItem.hilightTime = cfg.get(CATEGORY_NETWORK_MONITOR, "String_Node_Str", NetworkMonitorItem.hilightTime, "String_Node_Str").getInt();
     } catch (Exception e1) {


Input:
private void storeAuthCredential(String testAuth1) throws IOException, InterruptedException {
    Process process = Runtime.getRuntime().exec(reader.getCredsStore() + "String_Node_Str");
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
    writer.write(testAuth1 + "String_Node_Str");
    writer.flush();
    writer.close();
    process.waitFor();
}

Output:
 private void storeAuthCredential(String testAuth1) throws IOException, InterruptedException {
-    Process process = Runtime.getRuntime().exec(reader.getCredsStore() + "String_Node_Str");
+    Process process = Runtime.getRuntime().exec(credStore + "String_Node_Str");
     BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));


Input:
public void dateDifferenceFunctionExtension() throws InterruptedException {
    log.info("String_Node_Str");
    SiddhiManager siddhiManager = new SiddhiManager();
    String inStreamDefinition = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    String query = ("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    ExecutionPlanRuntime executionPlanRuntime = siddhiManager.createExecutionPlanRuntime(inStreamDefinition + query);
    executionPlanRuntime.addCallback("String_Node_Str", new QueryCallback() {
        public void receive(long timeStamp, Event[] inEvents, Event[] removeEvents) {
            EventPrinter.print(timeStamp, inEvents, removeEvents);
            eventArrived = true;
            for (int cnt = 0; cnt < inEvents.length; cnt++) {
                count++;
                log.info("String_Node_Str" + count + "String_Node_Str" + inEvents[cnt].getData(1) + "String_Node_Str" + "String_Node_Str" + inEvents[cnt].getData(2));
            }
        }
    });
    InputHandler inputHandler = executionPlanRuntime.getInputHandler("String_Node_Str");
    executionPlanRuntime.start();
    inputHandler.send(new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", 1415692424000L, 1415519624000L });
    inputHandler.send(new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", 1415692424000L, 1412841224000L });
    inputHandler.send(new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", 1415692424000L, 1384156424000L });
    Thread.sleep(100);
    Assert.assertEquals(3, count);
    Assert.assertTrue(eventArrived);
    executionPlanRuntime.shutdown();
}

Output:
     inputHandler.send(new Object[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", 1415692424000L, 1384156424000L });
-    Thread.sleep(100);
+    Thread.sleep(1000);
     Assert.assertEquals(3, count);


Input:
public void registerIcons(IconRegister par1IconRegister) {
    this.blockIcon = par1IconRegister.registerIcon(this.getUnlocalizedName2());
}

Output:
 public void registerIcons(IconRegister par1IconRegister) {
-    this.blockIcon = par1IconRegister.registerIcon(this.getUnlocalizedName2());
+    this.blockIcon = par1IconRegister.registerIcon(this.getUnlocalizedName().replace("String_Node_Str", "String_Node_Str"));
 }


Input:
public IValue resolve(MarkerList markers, IContext context) {
    this.type.resolve(markers, context);
    this.value = this.value.resolve(markers, context);
    if (this.type == Types.VOID) {
        markers.add(MarkerMessages.createMarker(this.position, "String_Node_Str"));
        return this;
    }
    if (!this.type.isResolved()) {
        return this;
    }
    IType prevType = this.value.getType();
    IValue value1 = this.value.withType(this.type, this.type, markers, context);
    if (value1 != null) {
        this.value = value1;
        IType valueType = value1.getType();
        if (!prevType.isSameType(valueType) && this.type.isSuperClassOf(valueType) && valueType.isPrimitive() == this.type.isPrimitive()) {
            this.typeHint = true;
            this.type = valueType;
            return this;
        }
        prevType = valueType;
    }
    boolean primitiveType = this.type.isPrimitive();
    boolean primitiveValue = this.value.isPrimitive();
    if (value1 == null && !(primitiveType && primitiveValue) && !prevType.isSuperClassOf(this.type)) {
        markers.add(MarkerMessages.createMarker(this.position, "String_Node_Str", prevType, this.type));
        return this;
    }
    if (!this.typeHint && this.type.isSameType(prevType) && primitiveType == primitiveValue) {
        markers.add(MarkerMessages.createMarker(this.position, "String_Node_Str"));
        this.typeHint = true;
    }
    return this;
}

Output:
     }
-    IType prevType = this.value.getType();
-    IValue value1 = this.value.withType(this.type, this.type, markers, context);
-    if (value1 != null) {
-        this.value = value1;
-        IType valueType = value1.getType();
-        if (!prevType.isSameType(valueType) && this.type.isSuperClassOf(valueType) && valueType.isPrimitive() == this.type.isPrimitive()) {
+    IType valueType = this.value.getType();
+    final IValue typedValue = this.value.withType(this.type, this.type, markers, context);
+    if (typedValue != null) {
+        this.value = typedValue;
+        final IType newType = typedValue.getType();
+        if (!valueType.isSameType(newType) && this.type.isSuperClassOf(newType) && newType.isPrimitive() == this.type.isPrimitive()) {
             this.typeHint = true;