Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object objectValue, CoreAbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    objectValue = xmlCompositeObjectMapping.convertObjectValueToDataValue(objectValue, session, marshalRecord.getMarshaller());
    if (null == objectValue) {
        return xmlCompositeObjectMapping.getNullPolicy().compositeObjectMarshal(xPathFragment, marshalRecord, object, session, namespaceResolver);
    }
    XPathFragment groupingFragment = marshalRecord.openStartGroupingElements(namespaceResolver);
    if (xPathFragment.hasAttribute) {
        TreeObjectBuilder tob = (TreeObjectBuilder) xmlCompositeObjectMapping.getReferenceDescriptor().getObjectBuilder();
        MappingNodeValue textMappingNodeValue = (MappingNodeValue) tob.getRootXPathNode().getTextNode().getMarshalNodeValue();
        Mapping textMapping = textMappingNodeValue.getMapping();
        if (textMapping.isAbstractDirectMapping()) {
            DirectMapping xmlDirectMapping = (DirectMapping) textMapping;
            Object fieldValue = xmlDirectMapping.getFieldValue(xmlDirectMapping.valueFromObject(objectValue, xmlDirectMapping.getField(), session), session, marshalRecord);
            QName schemaType = ((Field) xmlDirectMapping.getField()).getSchemaTypeForValue(fieldValue, session);
            marshalRecord.attribute(xPathFragment, namespaceResolver, fieldValue, schemaType);
            marshalRecord.closeStartGroupingElements(groupingFragment);
            return true;
        } else {
            return textMappingNodeValue.marshalSingleValue(xPathFragment, marshalRecord, objectValue, textMapping.getAttributeValueFromObject(objectValue), session, namespaceResolver, marshalContext);
        }
    }
    boolean isSelfFragment = xPathFragment.isSelfFragment;
    marshalRecord.closeStartGroupingElements(groupingFragment);
    UnmarshalKeepAsElementPolicy keepAsElementPolicy = xmlCompositeObjectMapping.getKeepAsElementPolicy();
    if (null != keepAsElementPolicy && (keepAsElementPolicy.isKeepUnknownAsElement() || keepAsElementPolicy.isKeepAllAsElement()) && objectValue instanceof Node) {
        if (isSelfFragment) {
            NodeList children = ((org.w3c.dom.Element) objectValue).getChildNodes();
            for (int i = 0, childrenLength = children.getLength(); i < childrenLength; i++) {
                Node next = children.item(i);
                short nodeType = next.getNodeType();
                if (nodeType == Node.ELEMENT_NODE) {
                    marshalRecord.node(next, marshalRecord.getNamespaceResolver());
                    return true;
                } else if (nodeType == Node.TEXT_NODE) {
                    marshalRecord.characters(((Text) next).getNodeValue());
                    return true;
                }
            }
            return false;
        } else {
            marshalRecord.node((Node) objectValue, marshalRecord.getNamespaceResolver());
            return true;
        }
    }
    Descriptor descriptor = (Descriptor) xmlCompositeObjectMapping.getReferenceDescriptor();
    if (descriptor == null) {
        descriptor = (Descriptor) session.getDescriptor(objectValue.getClass());
    } else if (descriptor.hasInheritance()) {
        Class objectValueClass = objectValue.getClass();
        if (!(objectValueClass == descriptor.getJavaClass())) {
            descriptor = (Descriptor) session.getDescriptor(objectValueClass);
        }
    }
    if (descriptor != null) {
        marshalRecord.beforeContainmentMarshal(objectValue);
        TreeObjectBuilder objectBuilder = (TreeObjectBuilder) descriptor.getObjectBuilder();
        if (!(isSelfFragment || xPathFragment.nameIsText)) {
            xPathNode.startElement(marshalRecord, xPathFragment, object, session, namespaceResolver, objectBuilder, objectValue);
        }
        List extraNamespaces = null;
        if (!marshalRecord.hasEqualNamespaceResolvers()) {
            extraNamespaces = objectBuilder.addExtraNamespacesToNamespaceResolver(descriptor, marshalRecord, session, true, false);
            writeExtraNamespaces(extraNamespaces, marshalRecord, session);
        }
        if (!isSelfFragment) {
            objectBuilder.addXsiTypeAndClassIndicatorIfRequired(marshalRecord, descriptor, (Descriptor) xmlCompositeObjectMapping.getReferenceDescriptor(), (Field) xmlCompositeObjectMapping.getField(), false);
        }
        objectBuilder.buildRow(marshalRecord, objectValue, session, marshalRecord.getMarshaller(), xPathFragment, WriteType.UNDEFINED);
        marshalRecord.afterContainmentMarshal(object, objectValue);
        if (!(isSelfFragment || xPathFragment.nameIsText())) {
            marshalRecord.endElement(xPathFragment, namespaceResolver);
        }
        objectBuilder.removeExtraNamespacesFromNamespaceResolver(marshalRecord, extraNamespaces, session);
    } else {
        if (XMLConstants.UNKNOWN_OR_TRANSIENT_CLASS.equals(xmlCompositeObjectMapping.getReferenceClassName())) {
            throw XMLMarshalException.descriptorNotFoundInProject(objectValue.getClass().getName());
        }
        if (!(isSelfFragment || xPathFragment.nameIsText())) {
            xPathNode.startElement(marshalRecord, xPathFragment, object, session, namespaceResolver, null, objectValue);
        }
        QName schemaType = ((Field) xmlCompositeObjectMapping.getField()).getSchemaTypeForValue(objectValue, session);
        updateNamespaces(schemaType, marshalRecord, ((Field) xmlCompositeObjectMapping.getField()));
        marshalRecord.characters(schemaType, objectValue, null, false);
        if (!(isSelfFragment || xPathFragment.nameIsText())) {
            marshalRecord.endElement(xPathFragment, namespaceResolver);
        }
    }
    return true;
}

Output:
     if (xPathFragment.hasAttribute) {
-        TreeObjectBuilder tob = (TreeObjectBuilder) xmlCompositeObjectMapping.getReferenceDescriptor().getObjectBuilder();
+        ObjectBuilder tob = (ObjectBuilder) xmlCompositeObjectMapping.getReferenceDescriptor().getObjectBuilder();
         MappingNodeValue textMappingNodeValue = (MappingNodeValue) tob.getRootXPathNode().getTextNode().getMarshalNodeValue();


Input:
public void onSuccess(Object response) {
    final String instanceId = "String_Node_Str";
    String[] mediaElements = mimeType.split("String_Node_Str");
    String mediaType = mediaElements[0];
    String mediaFormat = mediaElements[1];
    if (mediaType == null || mediaType.length() == 0 || mediaFormat == null || mediaFormat.length() == 0) {
        Util.postError(listener, new ServiceCommandError(0, "String_Node_Str", null));
        return;
    }
    mediaFormat = "String_Node_Str".equals(mediaFormat) ? "String_Node_Str" : mediaFormat;
    String mMimeType = String.format("String_Node_Str", mediaType, mediaFormat);
    ResponseListener<Object> responseListener = new ResponseListener<Object>() {
        public void onSuccess(Object response) {
            String method = "String_Node_Str";
            Map<String, String> parameters = new HashMap<String, String>();
            parameters.put("String_Node_Str", "String_Node_Str");
            JSONObject payload = getMethodBody(instanceId, method, parameters);
            ResponseListener<Object> playResponseListener = new ResponseListener<Object>() {
                public void onSuccess(Object response) {
                    LaunchSession launchSession = new LaunchSession();
                    launchSession.setService(DLNAService.this);
                    launchSession.setSessionType(LaunchSessionType.Media);
                    Util.postSuccess(listener, new MediaLaunchObject(launchSession, DLNAService.this));
                }
                public void onError(ServiceCommandError error) {
                    if (listener != null) {
                        listener.onError(error);
                    }
                }
            };
            ServiceCommand<ResponseListener<Object>> request = new ServiceCommand<ResponseListener<Object>>(DLNAService.this, method, payload, playResponseListener);
            request.send();
        }
        public void onError(ServiceCommandError error) {
            if (listener != null) {
                listener.onError(error);
            }
        }
    };
    String method = "String_Node_Str";
    JSONObject httpMessage = getSetAVTransportURIBody(method, instanceId, url, mMimeType, title);
    ServiceCommand<ResponseListener<Object>> request = new ServiceCommand<ResponseListener<Object>>(DLNAService.this, method, httpMessage, responseListener);
    request.send();
}

Output:
     };
-    String method = "String_Node_Str";
-    JSONObject httpMessage = getSetAVTransportURIBody(method, instanceId, url, mMimeType, title);
-    ServiceCommand<ResponseListener<Object>> request = new ServiceCommand<ResponseListener<Object>>(DLNAService.this, method, httpMessage, responseListener);
+    ServiceCommand<ResponseListener<Object>> request = new ServiceCommand<ResponseListener<Object>>(DLNAService.this, method, payload, playResponseListener);
     request.send();


Input:
public IContent execute() {
    TableItemDesign tableDesign = (TableItemDesign) getDesign();
    ITableContent tableContent = report.createTableContent();
    setContent(tableContent);
    executeQuery();
    initializeContent(tableDesign, tableContent);
    processStyle(tableDesign, tableContent);
    processVisibility(tableDesign, tableContent);
    processBookmark(tableDesign, tableContent);
    processAction(tableDesign, tableContent);
    for (int i = 0; i < tableDesign.getColumnCount(); i++) {
        ColumnDesign columnDesign = tableDesign.getColumn(i);
        Column column = new Column(report);
        column.setGenerateBy(columnDesign);
        InstanceID iid = new InstanceID(null, columnDesign.getID(), null);
        column.setInstanceID(iid);
        processColumnVisibility(columnDesign, column);
        tableContent.addColumn(column);
    }
    if (context.isInFactory()) {
        handleOnCreate(tableContent);
    }
    startTOCEntry(tableContent);
    if (rsetEmpty) {
        processEmptyQuery();
    }
    prepareToExecuteChildren();
    return tableContent;
}

Output:
     startTOCEntry(tableContent);
-    if (rsetEmpty) {
-        processEmptyQuery();
+    boolean showIfBlank = "String_Node_Str".equalsIgnoreCase(content.getStyle().getShowIfBlank());
+    if (showIfBlank && rsetEmpty) {
+        createQueryForShowIfBlank();
     }


Input:
public String toString() {
    if (getErrorCode() == FINAL_EXCEPTION) {
        StringBuffer buffer = new StringBuffer();
        buffer.append(getMessage());
        buffer.append(cr());
        Iterator<Throwable> exceptionList = getExceptionList().iterator();
        while (exceptionList.hasNext()) {
            buffer.append("String_Node_Str");
            buffer.append(cr());
            buffer.append(exceptionList.next().toString());
            buffer.append(cr());
        }
        return buffer.toString();
    } else {
        return super.toString();
    }
}

Output:
         buffer.append(cr());
-        Iterator<Throwable> exceptionList = getExceptionList().iterator();
+        Iterator exceptionList = getExceptionList().iterator();
         while (exceptionList.hasNext()) {


Input:
public Object convertValueBasedOnSchemaType(Field xmlField, Object value, ConversionManager conversionManager, AbstractUnmarshalRecord record) {
    if (xmlField.getSchemaType() != null) {
        if (Constants.QNAME_QNAME.equals(xmlField.getSchemaType())) {
            String stringValue = (String) value;
            int indexOpen = stringValue.indexOf('{');
            int indexClose = stringValue.indexOf('}');
            String uri = null;
            String localName = null;
            if (indexOpen > -1 && indexClose > -1) {
                uri = stringValue.substring(indexOpen + 1, indexClose);
                localName = stringValue.substring(indexClose + 1);
            } else {
                localName = stringValue;
            }
            if (uri != null) {
                return new QName(uri, localName);
            } else {
                return new QName(localName);
            }
        } else {
            Class fieldType = xmlField.getType();
            if (fieldType == null) {
                fieldType = xmlField.getJavaClass(xmlField.getSchemaType());
            }
            return conversionManager.convertObject(value, fieldType, xmlField.getSchemaType());
        }
    }
    return value;
}

Output:
             } else {
-                localName = stringValue;
+                QName obj = (QName) xmlField.convertValueBasedOnSchemaType(stringValue, conversionManager, record);
+                localName = obj.getLocalPart();
+                uri = obj.getNamespaceURI();
             }


Input:
public void deleteFolder() throws IOException, URISyntaxException {
    OlatNamedContainerImpl folder = BCCourseNode.getNodeFolderContainer((BCCourseNode) bcNode, course1.getCourseEnvironment());
    VFSItem item = folder.resolve("String_Node_Str");
    if (item == null) {
        folder.createChildContainer("String_Node_Str");
    }
    assertTrue(conn.login("String_Node_Str", "String_Node_Str"));
    URI uri = UriBuilder.fromUri(getNodeURI()).path("String_Node_Str").path("String_Node_Str").build();
    HttpDelete method = conn.createDelete(uri, MediaType.APPLICATION_JSON, true);
    HttpResponse response = conn.execute(method);
    assertEquals(200, response.getStatusLine().getStatusCode());
    VFSItem deletedItem = folder.resolve("String_Node_Str");
    assertNull(deletedItem);
}

Output:
     URI uri = UriBuilder.fromUri(getNodeURI()).path("String_Node_Str").path("String_Node_Str").build();
-    HttpDelete method = conn.createDelete(uri, MediaType.APPLICATION_JSON, true);
+    HttpDelete method = conn.createDelete(uri, MediaType.APPLICATION_JSON);
     HttpResponse response = conn.execute(method);


Input:
private JComponent addBoolPropertyEditor(JPanel parent, String label, String propertyName, Boolean value, int line) {
    parent.add(new JLabel(label), getConstraints(line, 1, 1));
    PropertyDescriptor propertyDescriptor = container.getDescriptor(propertyName);
    CheckBoxEditor boolEditor = new CheckBoxEditor();
    JComponent editorComponent = boolEditor.createEditorComponent(propertyDescriptor, context);
    ((JCheckBox) editorComponent).setSelected(value);
    editorComponent.setPreferredSize(new Dimension(30, 30));
    GridBagConstraints constraints = getConstraints(line, 0, 1);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.LINE_END;
    parent.add(editorComponent, constraints);
    return editorComponent;
}

Output:
     CheckBoxEditor boolEditor = new CheckBoxEditor();
-    JComponent editorComponent = boolEditor.createEditorComponent(propertyDescriptor, context);
+    JComponent editorComponent = boolEditor.createEditorComponent(propertyDescriptor, valuesContext);
     ((JCheckBox) editorComponent).setSelected(value);


Input:
public static void main(String[] args) throws Exception {
    Properties config = SimpleAccumuloConfig.loadConfig();
    SimpleAccumuloConfig saConf = SimpleAccumuloConfig.fromConfig(config);
    int nt = Integer.parseInt(config.getProperty("String_Node_Str", "String_Node_Str"));
    int port = Integer.parseInt(config.getProperty("String_Node_Str", "String_Node_Str"));
    logger.info("String_Node_Str" + port);
    logger.info("String_Node_Str" + nt);
    logger.info("String_Node_Str" + saConf);
    try (SimpleAccumuloFetch serv = new SimpleAccumuloFetch(saConf, nt)) {
        serv.connect(config.getProperty("String_Node_Str"), new PasswordToken(config.getProperty("String_Node_Str")));
        TServerTransport serverTransport = new TServerSocket(port);
        TServer server = new TSimpleServer(new Args(serverTransport).processor(new FetchCommunicationService.Processor<>(serv)));
        logger.info("String_Node_Str");
        server.serve();
    }
}

Output:
         serv.connect(config.getProperty("String_Node_Str"), new PasswordToken(config.getProperty("String_Node_Str")));
-        TServerTransport serverTransport = new TServerSocket(port);
-        TServer server = new TSimpleServer(new Args(serverTransport).processor(new FetchCommunicationService.Processor<>(serv)));
+        Processor<SimpleAccumuloFetch> proc = new FetchCommunicationService.Processor<>(serv);
+        TNonblockingServerTransport transport = new TNonblockingServerSocket(port);
+        TNonblockingServer.Args serverArgs = new TNonblockingServer.Args(transport);
+        serverArgs = serverArgs.processorFactory(new TProcessorFactory(proc));
+        serverArgs = serverArgs.protocolFactory(new TCompactProtocol.Factory());
+        serverArgs = serverArgs.transportFactory(new TFramedTransport.Factory(Integer.MAX_VALUE));
+        serverArgs.maxReadBufferBytes = Long.MAX_VALUE;
+        TNonblockingServer server = new TNonblockingServer(serverArgs);
         logger.info("String_Node_Str");


Input:
public void convert(Trait parent, String path, List<ABCContainerTag> abcTags, ABC abc, boolean isStatic, ExportMode exportMode, int scriptIndex, int classIndex, NulWriter writer, List<String> fullyQualifiedNames, boolean parallel) throws InterruptedException {
    fullyQualifiedNames = new ArrayList<>();
    int bodyIndex = abc.findBodyIndex(abc.class_info[class_info].cinit_index);
    if (bodyIndex != -1) {
        writer.mark();
        abc.bodies[bodyIndex].convert(path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames) + "String_Node_Str", exportMode, true, scriptIndex, class_info, abc, this, abc.constants, abc.method_info, new Stack<GraphTargetItem>(), true, fullyQualifiedNames, abc.class_info[class_info].static_traits, true);
        classInitializerIsEmpty = !writer.getMark();
    }
    if (!abc.instance_info[class_info].isInterface()) {
        bodyIndex = abc.findBodyIndex(abc.instance_info[class_info].iinit_index);
        if (bodyIndex != -1) {
            abc.bodies[bodyIndex].convert(path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames) + "String_Node_Str", exportMode, false, scriptIndex, class_info, abc, this, abc.constants, abc.method_info, new Stack<GraphTargetItem>(), false, fullyQualifiedNames, abc.instance_info[class_info].instance_traits, true);
        }
    }
    abc.class_info[class_info].static_traits.convert(this, path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames), abcTags, abc, true, exportMode, false, scriptIndex, class_info, writer, fullyQualifiedNames, parallel);
    abc.instance_info[class_info].instance_traits.convert(this, path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames), abcTags, abc, false, exportMode, false, scriptIndex, class_info, writer, fullyQualifiedNames, parallel);
}

Output:
         writer.mark();
-        abc.bodies[bodyIndex].convert(path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames) + "String_Node_Str", exportMode, true, scriptIndex, class_info, abc, this, abc.constants, abc.method_info, new Stack<GraphTargetItem>(), true, fullyQualifiedNames, abc.class_info[class_info].static_traits, true);
+        abc.bodies[bodyIndex].convert(path + "String_Node_Str" + abc.instance_info[class_info].getName(abc.constants).getName(abc.constants, fullyQualifiedNames) + "String_Node_Str", exportMode, true, scriptIndex, class_info, abc, this, abc.constants, abc.method_info, new Stack<GraphTargetItem>(), true, writer, fullyQualifiedNames, abc.class_info[class_info].static_traits, true);
         classInitializerIsEmpty = !writer.getMark();


Input:
public Result isDirty() throws OseeCoreException {
    if (isEditable()) {
        for (XStackedWidgetPage page : stackedControl.getPages()) {
            if (page.getObjectId() == null) {
                return new Result(true, String.format("String_Node_Str" + getAttributeType() + "String_Node_Str"));
            } else if (page instanceof XStackedWidgetAttrPage) {
                XStackedWidgetAttrPage attrPage = (XStackedWidgetAttrPage) page;
                if (attrPage.getAttribute().isDirty()) {
                    return new Result(true, String.format("String_Node_Str" + getAttributeType() + "String_Node_Str"));
                }
            } else if (artifact.isDirty()) {
                for (Attribute<?> attr : artifact.getAttributes(attributeType)) {
                    if (attr.isDeleted()) {
                        return new Result(true, String.format("String_Node_Str" + getAttributeType() + "String_Node_Str"));
                    }
                }
            }
        }
    }
    return Result.FalseResult;
}

Output:
                 XStackedWidgetAttrPage attrPage = (XStackedWidgetAttrPage) page;
-                if (attrPage.getAttribute().isDirty()) {
+                Object enteredValue = attrPage.getWidget().getData();
+                Object storedValue = attrPage.getValue();
+                if (!enteredValue.equals(storedValue)) {
                     return new Result(true, String.format("String_Node_Str" + getAttributeType() + "String_Node_Str"));


Input:
public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
    try {
        flushText();
        int len = atts.getLength();
        serializer.startElement(namespaceURI, localName, getPrefix(qName), null);
        for (int i = 0; i < prefixMap.size(); i += 2) {
            serializer.getNamespaceContext().force(prefixMap.get(i + 1), prefixMap.get(i));
        }
        for (int i = 0; i < len; i++) {
            String qname = atts.getQName(i);
            if (qname.startsWith("String_Node_Str"))
                continue;
            String prefix = getPrefix(qname);
            serializer.getNamespaceContext().declareNamespace(atts.getURI(i), prefix, true);
        }
        serializer.endNamespaceDecls(null);
        for (int i = 0; i < len; i++) {
            if (atts.getQName(i).startsWith("String_Node_Str"))
                continue;
            serializer.attribute(atts.getURI(i), atts.getLocalName(i), atts.getValue(i));
        }
        prefixMap.clear();
        serializer.endAttributes();
    } catch (IOException e) {
        throw new SAXException2(e);
    } catch (XMLStreamException e) {
        throw new SAXException2(e);
    }
}

Output:
         int len = atts.getLength();
-        serializer.startElement(namespaceURI, localName, getPrefix(qName), null);
+        String p = getPrefix(qName);
+        if (containsPrefixMapping(p, namespaceURI))
+            serializer.startElementForce(namespaceURI, localName, p, null);
+        else
+            serializer.startElement(namespaceURI, localName, p, null);
         for (int i = 0; i < prefixMap.size(); i += 2) {


Input:
public static Piece createBishop(boolean isBlack, Square square, Board board) throws IOException {
    Map<Character, Integer> bishopMovement = Maps.newHashMap();
    bishopMovement.put('R', -1);
    bishopMovement.put('r', -1);
    bishopMovement.put('L', -1);
    bishopMovement.put('l', -1);
    return new Piece(Messages.getString("String_Node_Str"), isBlack, square, board, bishopMovement);
}

Output:
     Map<Character, Integer> bishopMovement = Maps.newHashMap();
-    bishopMovement.put('R', -1);
-    bishopMovement.put('r', -1);
-    bishopMovement.put('L', -1);
-    bishopMovement.put('l', -1);
+    bishopMovement.put(PieceBuilder.NORTHEAST, -1);
+    bishopMovement.put(PieceBuilder.SOUTHEAST, -1);
+    bishopMovement.put(PieceBuilder.NORTHWEST, -1);
+    bishopMovement.put(PieceBuilder.SOUTHWEST, -1);
     return new Piece(Messages.getString("String_Node_Str"), isBlack, square, board, bishopMovement);


Input:
private void waitForAllPlayersStartFinished(INetworkConnector networkConnector) {
    while (!networkConnector.haveAllPlayersStartFinished()) {
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
        }
    }
}

Output:
         try {
-            Thread.sleep(5);
+            Thread.sleep(5L);
         } catch (InterruptedException e) {


Input:
public void close() throws IOException {
    if (!_isClosed) {
        _isClosed = true;
        if (_idleLogTimerTask != null) {
            _idleLogTimerTask.cancel();
        }
        if (_oldFileCleanerTimerTask != null) {
            _oldFileCleanerTimerTask.cancel();
        }
        if (_hdfsKeyValueTimer != null) {
            _hdfsKeyValueTimer.purge();
        }
        _writeLock.lock();
        try {
            if (isOpenForWriting()) {
                syncInternal();
                _output.close();
                _output = null;
            }
        } finally {
            _writeLock.unlock();
        }
    }
}

Output:
             if (isOpenForWriting()) {
-                syncInternal();
-                _output.close();
-                _output = null;
+                try {
+                    syncInternal();
+                } finally {
+                    IOUtils.closeQuietly(_output);
+                    _output = null;
+                }
             }


Input:
public void actionMenuFileExportHierarchy() {
    if (model == null) {
        main.showInfoDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        return;
    } else if (!(model.isQuasiIdentifierSelected() || model.isSensitiveAttributeSelected())) {
        main.showInfoDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        return;
    }
    String file = main.showSaveFileDialog("String_Node_Str");
    if (file == null) {
        return;
    }
    if (!file.endsWith("String_Node_Str")) {
        file = file + "String_Node_Str";
    }
    try {
        final CSVDataOutput out = new CSVDataOutput(file, model.getSeparator());
        Hierarchy h = model.getInputConfig().getHierarchy(model.getSelectedAttribute());
        if (h == null) {
            main.showInfoDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"));
        } else {
            out.write(h.getHierarchy());
        }
    } catch (final Exception e) {
        main.showErrorDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str") + e.getMessage());
    }
}

Output:
     } catch (final Exception e) {
-        main.showErrorDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str") + e.getMessage());
+        main.showErrorDialog(Resources.getMessage("String_Node_Str"), Resources.getMessage("String_Node_Str"), e);
     }


Input:
private QueryResultSet find(Date startDate, Date endDate, String[] keywords, String field, boolean caseSensitive) {
    TreeSet result = new TreeSet(new HistoryRecordComparator());
    Vector filelist = filterFilesByDate(this.historyImpl.getFileList(), startDate, endDate);
    ProgressEvent progressEvent = new ProgressEvent(this, startDate, endDate, keywords);
    int currentProgress = HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE;
    int fileProgressStep = HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE;
    if (filelist.size() != 0)
        fileProgressStep = HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE / filelist.size();
    fireProgressStateChanged(progressEvent, HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE);
    Iterator fileIterator = filelist.iterator();
    while (fileIterator.hasNext()) {
        String filename = (String) fileIterator.next();
        Document doc = this.historyImpl.getDocumentForFile(filename);
        NodeList nodes = doc.getElementsByTagName("String_Node_Str");
        int nodesProgressStep = fileProgressStep;
        if (nodes.getLength() != 0)
            nodesProgressStep = fileProgressStep / nodes.getLength();
        Node node;
        for (int i = 0; i < nodes.getLength(); i++) {
            node = nodes.item(i);
            String ts = node.getAttributes().getNamedItem("String_Node_Str").getNodeValue();
            Date timestamp = new Date(Long.parseLong(ts));
            if (isInPeriod(timestamp, startDate, endDate)) {
                NodeList propertyNodes = node.getChildNodes();
                HistoryRecord record = filterByKeyword(propertyNodes, timestamp, keywords, field, caseSensitive);
                if (record != null) {
                    result.add(record);
                }
            }
            currentProgress += nodesProgressStep;
            fireProgressStateChanged(progressEvent, currentProgress);
        }
    }
    fireProgressStateChanged(progressEvent, HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE);
    return new OrderedQueryResultSet(result);
}

Output:
         fileProgressStep = HistorySearchProgressListener.PROGRESS_MAXIMUM_VALUE / filelist.size();
-    fireProgressStateChanged(progressEvent, HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE);
+    fireProgressStateChanged(startDate, endDate, keywords, HistorySearchProgressListener.PROGRESS_MINIMUM_VALUE);
     Iterator fileIterator = filelist.iterator();


Input:
private void insertAndTest(Uploader uploader, String host) {
    insertIntoMap(host);
    if ((!testPerHostLimit(host)) || (!testTotalUploadLimit()))
        uploader.setState(Uploader.LIMIT_REACHED);
    _callback.addUpload(uploader);
}

Output:
     insertIntoMap(host);
-    if ((!testPerHostLimit(host)) || (!testTotalUploadLimit()))
+    if (!testPerHostLimit(host))
+        uploader.setState(Uploader.LIMIT_REACHED);
+    if (!testTotalUploadLimit())
         uploader.setState(Uploader.LIMIT_REACHED);


Input:
private void pushElement(TemplateElement element) {
    elementStack.add(element);
}

Output:
 private void pushElement(TemplateElement element) {
-    elementStack.add(element);
+    instructionStack.add(element);
 }


Input:
public Job createJob(JobScheduleRequest scheduleRequest) throws IOException, SchedulerException, IllegalAccessException {
    boolean runInBackground = scheduleRequest.getSimpleJobTrigger() == null && scheduleRequest.getComplexJobTrigger() == null && scheduleRequest.getCronJobTrigger() == null;
    if (!runInBackground && !policy.isAllowed(SchedulerAction.NAME)) {
        throw new SecurityException();
    }
    boolean hasInputFile = !StringUtils.isEmpty(scheduleRequest.getInputFile());
    RepositoryFile file = null;
    if (hasInputFile) {
        try {
            file = getRepository().getFile(scheduleRequest.getInputFile());
        } catch (UnifiedRepositoryException ure) {
            hasInputFile = false;
            logger.warn(ure.getMessage(), ure);
        }
    }
    if (hasInputFile && StringUtils.isEmpty(scheduleRequest.getJobName())) {
        scheduleRequest.setJobName(file.getName().substring(0, file.getName().lastIndexOf("String_Node_Str")));
    } else if (!StringUtils.isEmpty(scheduleRequest.getActionClass())) {
        String actionClass = scheduleRequest.getActionClass().substring(scheduleRequest.getActionClass().lastIndexOf("String_Node_Str") + 1);
        scheduleRequest.setJobName(actionClass);
    } else if (!hasInputFile && StringUtils.isEmpty(scheduleRequest.getJobName())) {
        scheduleRequest.setJobName("String_Node_Str" + System.currentTimeMillis());
    }
    if (hasInputFile) {
        Map<String, Serializable> metadata = getRepository().getFileMetadata(file.getId());
        if (metadata.containsKey("String_Node_Str")) {
            boolean schedulable = Boolean.parseBoolean((String) metadata.get("String_Node_Str"));
            if (!schedulable) {
                throw new IllegalAccessException();
            }
        }
    }
    Job job = null;
    IJobTrigger jobTrigger = SchedulerResourceUtil.convertScheduleRequestToJobTrigger(scheduleRequest);
    HashMap<String, Serializable> parameterMap = new HashMap<String, Serializable>();
    for (JobScheduleParam param : scheduleRequest.getJobParameters()) {
        parameterMap.put(param.getName(), param.getValue());
    }
    if (isPdiFile(file)) {
        parameterMap = handlePDIScheduling(file, parameterMap);
    }
    parameterMap.put(LocaleHelper.USER_LOCALE_PARAM, LocaleHelper.getLocale());
    if (hasInputFile) {
        SchedulerOutputPathResolver outputPathResolver = getSchedulerOutputPathResolver(scheduleRequest);
        String outputFile = outputPathResolver.resolveOutputFilePath();
        String actionId = getExtension(scheduleRequest.getInputFile()) + "String_Node_Str";
        job = getScheduler().createJob(scheduleRequest.getJobName(), actionId, parameterMap, jobTrigger, new RepositoryFileStreamProvider(scheduleRequest.getInputFile(), outputFile, getAutoCreateUniqueFilename(scheduleRequest)));
    } else {
        String actionClass = scheduleRequest.getActionClass();
        try {
            Class<IAction> iaction = getAction(actionClass);
            job = getScheduler().createJob(scheduleRequest.getJobName(), iaction, parameterMap, jobTrigger);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
    return job;
}

Output:
     boolean runInBackground = scheduleRequest.getSimpleJobTrigger() == null && scheduleRequest.getComplexJobTrigger() == null && scheduleRequest.getCronJobTrigger() == null;
-    if (!runInBackground && !policy.isAllowed(SchedulerAction.NAME)) {
+    if (!runInBackground && !getPolicy().isAllowed(SchedulerAction.NAME)) {
         throw new SecurityException();


Input:
public Iterable<Pair<String, Integer>> commonPrefixSearchWithTermId(String query) {
    List<Pair<String, Integer>> ret = new ArrayList<Pair<String, Integer>>();
    char[] chars = query.toCharArray();
    int charsLen = chars.length;
    int nodeId = 0;
    TailCharIterator tci = tailArray.newIterator();
    Range r = new Range();
    for (int charsIndex = 0; charsIndex < charsLen; charsIndex++) {
        int child = getChildNode(nodeId, chars[charsIndex], r);
        if (child == -1)
            return ret;
        tci.setOffset(tailArray.getIteratorOffset(child));
        while (tci.hasNext()) {
            charsIndex++;
            if (charsLen <= charsIndex)
                return ret;
            if (chars[charsIndex] != tci.next())
                return ret;
        }
        if (term.get(child)) {
            ret.add(Pair.create(new String(chars, 0, charsIndex + 1), child));
        }
        nodeId = child;
    }
    return ret;
}

Output:
         if (term.get(child)) {
-            ret.add(Pair.create(new String(chars, 0, charsIndex + 1), child));
+            ret.add(Pair.create(new String(chars, 0, charsIndex + 1), term.rank1(child) - 1));
         }


Input:
public String ownsHere(Player player, Location location) {
    boolean inLot = false;
    for (String LotID : lots.keySet()) {
        if (getLot(LotID).withinLot(location)) {
            inLot = true;
            PermissionUser user = PermissionUser.matchUser(player.getName());
            if (user == null) {
                return "String_Node_Str";
            }
            if (getLot(LotID).isOwner(player) || user.hasPerm("String_Node_Str")) {
                return getLot(LotID).getLotID();
            }
        }
    }
    if (inLot) {
        return "String_Node_Str";
    } else {
        return "String_Node_Str";
    }
}

Output:
             inLot = true;
-            PermissionUser user = PermissionUser.matchUser(player.getName());
+            PermissionUser user = PermissionUser.matchUserIgnoreCase(player.getName());
             if (user == null) {


Input:
public String coordinateJob(final JobRequest jobRequest, final JobMetadata jobMetadata) throws GenieException {
    final long coordinationStart = System.nanoTime();
    final String jobId = jobRequest.getId().orElseThrow(() -> new GenieServerException("String_Node_Str"));
    JobStatus jobStatus = JobStatus.FAILED;
    try {
        log.info("String_Node_Str", jobId);
        final Job.Builder jobBuilder = new Job.Builder(jobRequest.getName(), jobRequest.getUser(), jobRequest.getVersion(), jobRequest.getCommandArgs()).withId(jobId).withTags(jobRequest.getTags()).withStatus(JobStatus.INIT).withStatusMsg("String_Node_Str");
        jobRequest.getDescription().ifPresent(jobBuilder::withDescription);
        if (!jobRequest.isDisableLogArchival()) {
            jobBuilder.withArchiveLocation(this.jobsProperties.getLocations().getArchives() + JobConstants.FILE_PATH_DELIMITER + jobId + "String_Node_Str");
        }
        final JobExecution jobExecution = new JobExecution.Builder(this.hostName).withId(jobId).build();
        this.jobPersistenceService.createJob(jobRequest, jobMetadata, jobBuilder.build(), jobExecution);
        jobStateService.init(jobId);
        final Cluster cluster = this.getCluster(jobRequest);
        final Command command = this.getCommand(jobRequest, cluster);
        final List<Application> applications = this.getApplications(jobRequest, command);
        final int memory = jobRequest.getMemory().orElse(command.getMemory().orElse(this.jobsProperties.getMemory().getDefaultJobMemory()));
        this.setRuntimeEnvironment(jobId, cluster, command, applications, memory);
        final int maxJobMemory = this.jobsProperties.getMemory().getMaxJobMemory();
        if (memory > maxJobMemory) {
            jobStatus = JobStatus.INVALID;
            throw new GeniePreconditionException("String_Node_Str" + memory + "String_Node_Str" + maxJobMemory + "String_Node_Str");
        }
        log.info("String_Node_Str", jobRequest.getId(), jobRequest.getUser());
        final JobsUsersActiveLimitProperties activeLimit = this.jobsProperties.getUsers().getActiveLimit();
        if (activeLimit.isEnabled()) {
            final long activeJobsLimit = activeLimit.getCount();
            final long activeJobsCount = this.jobSearchService.getActiveJobCountForUser(jobRequest.getUser());
            if (activeJobsCount >= activeJobsLimit) {
                throw GenieUserLimitExceededException.createForActiveJobsLimit(jobRequest.getUser(), activeJobsCount, activeJobsLimit);
            }
        }
        synchronized (this) {
            log.info("String_Node_Str", jobRequest.getId());
            final int maxSystemMemory = this.jobsProperties.getMemory().getMaxSystemMemory();
            final int usedMemory = this.jobStateService.getUsedMemory();
            if (usedMemory + memory <= maxSystemMemory) {
                log.info("String_Node_Str", jobId, usedMemory, maxSystemMemory, memory);
                log.info("String_Node_Str", jobId);
                jobStateService.schedule(jobId, jobRequest, cluster, command, applications, memory);
                return jobId;
            } else {
                throw new GenieServerUnavailableException("String_Node_Str" + jobId + "String_Node_Str" + usedMemory + "String_Node_Str" + maxSystemMemory + "String_Node_Str" + memory + "String_Node_Str");
            }
        }
    } catch (GenieConflictException e) {
        throw e;
    } catch (GenieException e) {
        if (jobStateService.jobExists(jobId)) {
            jobStateService.done(jobId);
            jobPersistenceService.updateJobStatus(jobId, jobStatus, e.getMessage());
        }
        throw e;
    } catch (Exception e) {
        if (jobStateService.jobExists(jobId)) {
            jobStateService.done(jobId);
            jobPersistenceService.updateJobStatus(jobId, jobStatus, e.getMessage());
        }
        throw new GenieServerException(e);
    } finally {
        this.coordinationTimer.record(System.nanoTime() - coordinationStart, TimeUnit.MILLISECONDS);
    }
}

Output:
     } finally {
-        this.coordinationTimer.record(System.nanoTime() - coordinationStart, TimeUnit.MILLISECONDS);
+        this.coordinationTimer.record(System.nanoTime() - coordinationStart, TimeUnit.NANOSECONDS);
     }


Input:
public TileEntityCoffin getPrimaryTileEntity() {
    if ((this.worldObj.getBlockMetadata(this.otherX, this.yCoord, this.zCoord) & -8) != 0)
        return (TileEntityCoffin) worldObj.getTileEntity(otherX, otherY, otherZ);
    return this;
}

Output:
 public TileEntityCoffin getPrimaryTileEntity() {
-    if ((this.worldObj.getBlockMetadata(this.otherX, this.yCoord, this.zCoord) & -8) != 0)
+    if ((this.worldObj.getBlockMetadata(this.otherX, this.yCoord, this.zCoord) & -8) == 0)
         return (TileEntityCoffin) worldObj.getTileEntity(otherX, otherY, otherZ);


Input:
public void run() {
    try {
        socketChannel = SocketChannel.open();
        final Address thisAddress = Node.get().getThisAddress();
        final int addition = (thisAddress.getPort() - Config.get().port);
        localPort = 10000 + addition;
        boolean bindOk = false;
        while (!bindOk) {
            try {
                localPort += 20;
                if (boundPorts.size() > 2000 || localPort > 60000) {
                    boundPorts.clear();
                    final Connection[] conns = ConnectionManager.get().getConnections();
                    for (final Connection conn : conns) {
                        boundPorts.add(conn.localPort);
                    }
                }
                if (boundPorts.add(localPort)) {
                    socketChannel.socket().bind(new InetSocketAddress(thisAddress.getInetAddress(), localPort));
                    bindOk = true;
                    socketChannel.configureBlocking(false);
                    if (DEBUG)
                        logger.log(Level.INFO, "String_Node_Str" + address);
                    socketChannel.connect(new InetSocketAddress(address.getInetAddress(), address.getPort()));
                }
            } catch (final Exception e) {
            }
        }
        socketChannel.register(selector, SelectionKey.OP_CONNECT, Connector.this);
    } catch (final Exception e) {
        try {
            socketChannel.close();
        } catch (final IOException ignored) {
        }
        if (numberOfConnectionError++ < 5) {
            if (DEBUG) {
                logger.log(Level.INFO, "String_Node_Str" + e.getMessage());
            }
            run();
        } else {
            ConnectionManager.get().failedConnection(address);
        }
    }
}

Output:
                     if (DEBUG)
-                        logger.log(Level.INFO, "String_Node_Str" + address);
-                    socketChannel.connect(new InetSocketAddress(address.getInetAddress(), address.getPort()));
+                        logger.log(Level.FINEST, "String_Node_Str" + address + "String_Node_Str" + localPort);
+                    boolean connected = socketChannel.connect(new InetSocketAddress(address.getInetAddress(), address.getPort()));
+                    if (DEBUG)
+                        logger.log(Level.FINEST, "String_Node_Str" + connected + "String_Node_Str" + address + "String_Node_Str" + localPort);
+                    if (connected) {
+                        handle();
+                        return;
+                    }
                 }


Input:
protected void initData(Composite dataComposite) {
    grpValues = new Group(dataComposite, SWT.NONE);
    grpValues.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 4, 1));
    grpValues.setText(RedisClient.i18nFile.getText(I18nFile.VALUES));
    grpValues.setLayout(new GridLayout(4, false));
    table = new Table(grpValues, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI | SWT.VIRTUAL);
    table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 3, 3));
    table.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            tableItemSelected();
        }
    });
    table.setLinesVisible(true);
    table.addListener(SWT.MouseDown, new EditListener(table, false));
    pageListener = new PagingListener(table, new SetPage(id, db, key));
    table.addListener(SWT.SetData, pageListener);
    TableColumn tblclmnNewColumn = new TableColumn(table, SWT.NONE);
    tblclmnNewColumn.setWidth(200);
    btnAdd = new Button(grpValues, SWT.NONE);
    btnAdd.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1));
    btnAdd.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            InputDialog inputDialog = new InputDialog(shell.getParent().getShell(), RedisClient.i18nFile.getText(I18nFile.INPUTVALUES), RedisClient.i18nFile.getText(I18nFile.LISTINPUTFORMAT), "String_Node_Str", null);
            if (inputDialog.open() == InputDialog.OK) {
                String values = inputDialog.getValue();
                String[] setValues = values.split("String_Node_Str");
                long size = service.addValues(id, db, key, setValues);
                if (size == 0)
                    MessageDialog.openInformation(shell.getParent().getShell(), RedisClient.i18nFile.getText(I18nFile.INPUTVALUES), RedisClient.i18nFile.getText(I18nFile.ADDSETVALUES));
                refresh();
            }
        }
    });
    btnAdd.setText(RedisClient.i18nFile.getText(I18nFile.ADD));
    btnDelete = new Button(grpValues, SWT.NONE);
    btnDelete.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1));
    btnDelete.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            Set<String> values = new HashSet<String>();
            TableItem[] items = table.getSelection();
            for (TableItem item : items) {
                values.add(item.getText());
            }
            service.remove(id, db, key, values);
            for (TableItem item : items) {
                item.dispose();
            }
            tableItemSelected();
        }
    });
    btnDelete.setEnabled(false);
    btnDelete.setText(RedisClient.i18nFile.getText(I18nFile.DELETE));
    btnRefresh = new Button(grpValues, SWT.NONE);
    btnRefresh.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            refresh();
        }
    });
    btnRefresh.setLayoutData(new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1));
    btnRefresh.setText(RedisClient.i18nFile.getText(I18nFile.REFRESH));
}

Output:
     table.addListener(SWT.SetData, pageListener);
-    TableColumn tblclmnNewColumn = new TableColumn(table, SWT.NONE);
+    tblclmnNewColumn = new TableColumn(table, SWT.NONE);
+    tblclmnNewColumn.setText(RedisClient.i18nFile.getText(I18nFile.VALUE));
     tblclmnNewColumn.setWidth(200);


Input:
public void createVob(String vobname, boolean UCMProject, String path, String comment) throws UCMException {
    String cmd = "String_Node_Str" + vobname + (UCMProject ? "String_Node_Str" : "String_Node_Str") + (comment != null ? "String_Node_Str" + comment : "String_Node_Str") + "String_Node_Str" + (path != null ? path : "String_Node_Str");
    try {
        Cleartool.run(cmd);
    } catch (Exception e) {
        throw new UCMException(e.getMessage(), UCMType.CREATION_FAILED);
    }
}

Output:
 public void createVob(String vobname, boolean UCMProject, String path, String comment) throws UCMException {
-    String cmd = "String_Node_Str" + vobname + (UCMProject ? "String_Node_Str" : "String_Node_Str") + (comment != null ? "String_Node_Str" + comment : "String_Node_Str") + "String_Node_Str" + (path != null ? path : "String_Node_Str");
+    logger.info("String_Node_Str" + vobname);
+    String cmd = "String_Node_Str" + vobname + (UCMProject ? "String_Node_Str" : "String_Node_Str") + (comment != null ? "String_Node_Str" + comment + "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + (path != null ? path : "String_Node_Str");
     try {


Input:
public Node getSample() {
    if (!onService.get()) {
        cameraTransform = new CameraTransformer();
        camera = new PerspectiveCamera(true);
        camera.setNearClip(0.1);
        camera.setFarClip(100000.0);
        camera.setTranslateZ(-50);
        camera.setVerticalFieldOfView(false);
        camera.setFieldOfView(42);
        cameraTransform.setTranslate(0, 0, 0);
        cameraTransform.getChildren().add(camera);
        cameraTransform.ry.setAngle(-45.0);
        cameraTransform.rx.setAngle(-10.0);
        PointLight light = new PointLight(Color.GAINSBORO);
        AmbientLight amb = new AmbientLight(Color.WHITE);
        amb.getScope().add(cameraTransform);
        cameraTransform.getChildren().addAll(light);
        light.translateXProperty().bind(camera.translateXProperty());
        light.translateYProperty().bind(camera.translateYProperty());
        light.translateZProperty().bind(camera.translateZProperty());
        sceneLight1 = new PointLight();
        sceneLight1.setTranslateX(500);
        sceneLight2 = new PointLight();
        sceneLight2.setTranslateX(-500);
        light1Group = new Group(sceneLight1);
        light2Group = new Group(sceneLight2);
        lightingGroup = new Group(light1Group, light2Group);
        root = new Group(lightingGroup);
        sceneLight1.getScope().add(root);
        sceneLight2.getScope().add(root);
        subScene = new SubScene(root, sceneWidth, sceneHeight, true, SceneAntialiasing.BALANCED);
        subScene.setFill(Color.TRANSPARENT);
        subScene.setCamera(camera);
        subScene.setFocusTraversable(false);
        rotateY = new Rotate(0, 0, 0, 0, Rotate.Y_AXIS);
        mainPane = new StackPane();
        mainPane.setPrefSize(sceneWidth, sceneHeight);
        mainPane.setMaxSize(StackPane.USE_COMPUTED_SIZE, StackPane.USE_COMPUTED_SIZE);
        mainPane.setMinSize(sceneWidth, sceneHeight);
        mainPane.getChildren().add(subScene);
        mainPane.setPickOnBounds(false);
        service = new Service<Void>() {
            protected Task<Void> createTask() {
                return new Task<Void>() {
                    protected Void call() throws Exception {
                        createMesh();
                        return null;
                    }
                };
            }
            protected void failed() {
                super.failed();
                getException().printStackTrace(System.err);
            }
        };
        progressBar = new ProgressBar();
        progressBar.prefWidthProperty().bind(mainPane.widthProperty().divide(2d));
        progressBar.setProgress(-1);
        mainPane.getChildren().add(progressBar);
        group = new Group();
        group.getChildren().add(cameraTransform);
        root.getChildren().add(group);
        service.setOnSucceeded(e -> {
            onService.set(false);
            System.out.println("String_Node_Str" + (System.currentTimeMillis() - time));
            addMeshAndListeners();
            mainPane.getChildren().remove(progressBar);
            if (model != null && model instanceof Shape3D) {
                material = (PhongMaterial) ((Shape3D) model).getMaterial();
            } else {
                if (model != null && model instanceof Group) {
                    material = (PhongMaterial) ((Shape3D) ((Group) model).getChildren().filtered(t -> t instanceof Shape3D).get(0)).getMaterial();
                }
            }
            if (model != null) {
                group.getChildren().add(model);
            } else {
                throw new UnsupportedOperationException("String_Node_Str");
            }
            if (controlPanel != null && ((ControlPanel) controlPanel).getPanes().filtered(t -> t.getText().contains("String_Node_Str")).isEmpty()) {
                ((ControlPanel) controlPanel).getPanes().add(0, ControlFactory.buildSceneAndLightCategory(mainPane.visibleProperty(), sceneLight1.lightOnProperty(), sceneLight2.lightOnProperty(), sceneLight1.colorProperty(), sceneLight2.colorProperty(), sceneLight1.translateXProperty(), sceneLight2.translateXProperty(), light1Group.rotateProperty(), light2Group.rotateProperty(), light1Group.rotationAxisProperty(), light1Group.rotationAxisProperty()));
            }
        });
        subScene.widthProperty().bind(mainPane.widthProperty());
        subScene.heightProperty().bind(mainPane.heightProperty());
        subScene.setOnKeyPressed(event -> {
            double change = 10.0;
            if (event.isShiftDown()) {
                change = 50.0;
            }
            KeyCode keycode = event.getCode();
            if (keycode == KeyCode.W) {
                camera.setTranslateZ(camera.getTranslateZ() + change);
            }
            if (keycode == KeyCode.S) {
                camera.setTranslateZ(camera.getTranslateZ() - change);
            }
            if (keycode == KeyCode.A) {
                camera.setTranslateX(camera.getTranslateX() - change);
            }
            if (keycode == KeyCode.D) {
                camera.setTranslateX(camera.getTranslateX() + change);
            }
        });
        subScene.setOnMousePressed((MouseEvent me) -> {
            mousePosX = me.getSceneX();
            mousePosY = me.getSceneY();
            mouseOldX = me.getSceneX();
            mouseOldY = me.getSceneY();
            PickResult pr = me.getPickResult();
            if (pr != null && pr.getIntersectedNode() != null && pr.getIntersectedNode() instanceof Sphere && pr.getIntersectedNode().getId().equals("String_Node_Str")) {
                distance = pr.getIntersectedDistance();
                s = (Sphere) pr.getIntersectedNode();
                isPicking.set(true);
                vecIni = unProjectDirection(mousePosX, mousePosY, subScene.getWidth(), subScene.getHeight());
            }
        });
        subScene.setOnMouseDragged((MouseEvent me) -> {
            mouseOldX = mousePosX;
            mouseOldY = mousePosY;
            mousePosX = me.getSceneX();
            mousePosY = me.getSceneY();
            mouseDeltaX = (mousePosX - mouseOldX);
            mouseDeltaY = (mousePosY - mouseOldY);
            if (isPicking.get()) {
                double modifier = (me.isControlDown() ? 0.01 : me.isAltDown() ? 1.0 : 0.1) * (30d / camera.getFieldOfView());
                modifier *= (30d / camera.getFieldOfView());
                vecPos = unProjectDirection(mousePosX, mousePosY, subScene.getWidth(), subScene.getHeight());
                Point3D p = new Point3D(distance * (vecPos.x - vecIni.x), distance * (vecPos.y - vecIni.y), distance * (vecPos.z - vecIni.z));
                s.getTransforms().add(new Translate(modifier * p.getX(), modifier * p.getY(), modifier * p.getZ()));
                vecIni = vecPos;
            } else {
                double modifier = 10.0;
                double modifierFactor = 0.1;
                if (me.isControlDown()) {
                    modifier = 0.1;
                }
                if (me.isShiftDown()) {
                    modifier = 50.0;
                }
                if (me.isPrimaryButtonDown()) {
                    cameraTransform.ry.setAngle(((cameraTransform.ry.getAngle() + mouseDeltaX * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180);
                    cameraTransform.rx.setAngle(((cameraTransform.rx.getAngle() - mouseDeltaY * modifierFactor * modifier * 2.0) % 360 + 540) % 360 - 180);
                } else if (me.isSecondaryButtonDown()) {
                    double z = camera.getTranslateZ();
                    double newZ = z + mouseDeltaX * modifierFactor * modifier;
                    camera.setTranslateZ(newZ);
                } else if (me.isMiddleButtonDown()) {
                    cameraTransform.t.setX(cameraTransform.t.getX() + mouseDeltaX * modifierFactor * modifier * 0.3);
                    cameraTransform.t.setY(cameraTransform.t.getY() + mouseDeltaY * modifierFactor * modifier * 0.3);
                }
            }
        });
        subScene.setOnMouseReleased((MouseEvent me) -> {
            if (isPicking.get()) {
                isPicking.set(false);
            }
        });
        onService.set(true);
        System.out.println("String_Node_Str");
        time = System.currentTimeMillis();
        service.start();
    }
    mainPane.sceneProperty().addListener(i -> {
        if (mainPane.getScene() != null) {
            mainPane.getScene().addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
                if (e.getPickResult() != null) {
                    System.out.println(e.getPickResult().getIntersectedNode() + "String_Node_Str" + e.getPickResult().getIntersectedNode().getTypeSelector());
                }
            });
        }
    });
    return mainPane;
}

Output:
                 if (model != null && model instanceof Group) {
-                    material = (PhongMaterial) ((Shape3D) ((Group) model).getChildren().filtered(t -> t instanceof Shape3D).get(0)).getMaterial();
+                    if (!((Group) model).getChildren().filtered(isShape -> isShape instanceof Shape3D).isEmpty()) {
+                        material = (PhongMaterial) ((Shape3D) ((Group) model).getChildren().filtered(t -> t instanceof Shape3D).get(0)).getMaterial();
+                    }
                 }


Input:
public void actionPerformed(ActionEvent actionEvent) {
    final Product product = virtualBand.getProduct();
    if (product != null && product.isMultiSize()) {
        virtualBand = null;
        final Product resampledProduct = MultiSizeIssue0.maybeResample(product);
        if (resampledProduct != null) {
            final Band band = resampledProduct.getBand(virtualBand.getName());
            if (band instanceof VirtualBand) {
                virtualBand = (VirtualBand) band;
            }
        }
    }
    if (virtualBand != null) {
        PropagateUncertaintyDialog dialog = new PropagateUncertaintyDialog(virtualBand);
        dialog.show();
    }
}

Output:
         virtualBand = null;
-        final Product resampledProduct = MultiSizeIssue0.maybeResample(product);
+        final Product resampledProduct = _MultiSizeIssue.maybeResample(product);
         if (resampledProduct != null) {


Input:
protected void onDetachedFromWindow() {
    super.onDetachedFromWindow();
    if (mPreDrawState != PREDRAW_NOT_REGISTERED) {
        final ViewTreeObserver observer = getViewTreeObserver();
        if (observer != null) {
            observer.removeOnPreDrawListener(this);
            mPreDrawState = PREDRAW_NOT_REGISTERED;
        }
    }
    if (mError != null) {
        hideError();
    }
    hideControllers();
}

Output:
     super.onDetachedFromWindow();
-    if (mPreDrawState != PREDRAW_NOT_REGISTERED) {
-        final ViewTreeObserver observer = getViewTreeObserver();
-        if (observer != null) {
+    final ViewTreeObserver observer = getViewTreeObserver();
+    if (observer != null) {
+        if (mPreDrawState != PREDRAW_NOT_REGISTERED) {
             observer.removeOnPreDrawListener(this);


Input:
public void removeWindow(String windowId, Continuation<Void> cont) {
    Map<String, MediaParam> params = new HashMap<String, MediaParam>(4);
    StringMediaParam param = new StringMediaParam();
    param.setString(windowId);
    params.put(REMOVE_WINDOW_PARAM_WINDOW_ID, param);
    invoke(REMOVE_WINDOW, params, new VoidContinuationWrapper(cont));
}

Output:
 public void removeWindow(String windowId, Continuation<Void> cont) {
-    Map<String, MediaParam> params = new HashMap<String, MediaParam>(4);
+    Map<String, MediaParam> params = newHashMapWithExpectedSize(1);
     StringMediaParam param = new StringMediaParam();


Input:
public void end() {
    flushUnStartedChildren();
    ContentEmitterUtil.endContent(content, emitter);
}

Output:
     flushUnStartedChildren();
-    ContentEmitterUtil.endContent(content, emitter);
+    if (isVisible) {
+        ContentEmitterUtil.endContent(content, emitter);
+    }
 }


Input:
public void giveItemName(String item, String amount, Player player) {
    ItemStack itemstack;
    String clone = item;
    PlayerInventory inventory = player.getInventory();
    if (item.contains("String_Node_Str")) {
        String[] split = clone.split("String_Node_Str");
        itemstack = new ItemStack(items.get(strip(split[0]).toLowerCase()));
        itemstack.setDurability(Short.parseShort(split[1]));
        player.sendMessage("String_Node_Str");
        itemstack.setAmount(Integer.parseInt(amount));
        inventory.addItem(itemstack);
    } else {
        itemstack = new ItemStack(items.get(item.toLowerCase()));
        itemstack.setAmount(Integer.parseInt(amount));
        player.sendMessage("String_Node_Str");
        inventory.addItem(itemstack);
    }
}

Output:
         String[] split = clone.split("String_Node_Str");
-        itemstack = new ItemStack(items.get(strip(split[0]).toLowerCase()));
+        itemstack = new ItemStack(items.get(split[0].toLowerCase()));
         itemstack.setDurability(Short.parseShort(split[1]));


Input:
public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
    this.addPositionalNodes(xPathFragment, namespaceResolver);
    try {
        if (isStartElementOpen) {
            getOutputStream().write(CLOSE_ELEMENT);
        }
        if (!isLastEventText) {
            if (numberOfTabs > 0) {
                getOutputStream().write(CR);
            }
            for (int x = 0; x < numberOfTabs; x++) {
                getOutputStream().write(TAB);
            }
        }
        isStartElementOpen = true;
        getOutputStream().write(OPEN_START_ELEMENT);
        getOutputStream().write(xPathFragment.getShortNameBytes());
        numberOfTabs++;
        isLastEventText = false;
    } catch (IOException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
         if (isStartElementOpen) {
-            getOutputStream().write(CLOSE_ELEMENT);
+            outputStream.write(CLOSE_ELEMENT);
         }


Input:
private IType resolveType(final ITypeName recType) {
    ensureIsNotNull(recType);
    if (recType.isNestedType()) {
        final ITypeName declaringType = recType.getDeclaringType();
        final IType parent = resolveType(declaringType);
        if (parent != null) {
            try {
                for (final IType nested : parent.getTypes()) {
                    System.out.println(nested);
                }
                for (final IMethod m : parent.getMethods()) {
                    for (final IJavaElement children : m.getChildren()) {
                        if (children instanceof IType) {
                            final IType nested = (IType) children;
                            final String key = nested.getKey();
                            if (key.equals(recType.getIdentifier() + "String_Node_Str")) {
                                return nested;
                            }
                        }
                    }
                }
            } catch (final Exception x) {
                System.out.println(parent);
                return null;
            }
        }
        return null;
    }
    final IType[] res = new IType[1];
    final IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    final SearchEngine search = new SearchEngine();
    final String srcTypeName = Names.vm2srcTypeName(recType.getIdentifier());
    final SearchPattern pattern = SearchPattern.createPattern(srcTypeName, IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);
    try {
        search.search(pattern, SearchUtils.getDefaultSearchParticipants(), scope, new SearchRequestor() {
            public void acceptSearchMatch(final SearchMatch match) throws CoreException {
                res[0] = (IType) match.getElement();
            }
        }, null);
    } catch (final CoreException e) {
        throwUnhandledException(e);
    }
    return res[0];
}

Output:
                 for (final IType nested : parent.getTypes()) {
-                    System.out.println(nested);
+                    final String key = nested.getKey();
+                    if (key.equals(recType.getIdentifier() + "String_Node_Str")) {
+                        return nested;
+                    }
                 }


Input:
public void onGestureTypingInputDone() {
    InputConnection ic = getCurrentInputConnection();
    if (mGestureTypingEnabled && ic != null) {
        ArrayList<String> gestureTypingPossibilities = gestureTypingDetector.getCandidates();
        final boolean isShifted = mShiftKeyState.isActive();
        final boolean isCapsLocked = mShiftKeyState.isLocked();
        if (gestureTypingPossibilities.size() > 0) {
            ic.beginBatchEdit();
            final boolean alsoAddSpace = TextEntryState.getState() == TextEntryState.State.PERFORMED_GESTURE;
            abortCorrectionAndResetPredictionState(false);
            if (alsoAddSpace) {
                ic.commitText("String_Node_Str", 1);
            }
            CharSequence word = gestureTypingPossibilities.get(0);
            mWord.reset();
            mWord.setAutoCapitalized(isShifted || isCapsLocked);
            mWord.simulateTypedWord(word);
            commitWordToInput(mWord.getTypedWord(), false);
            TextEntryState.performedGesture();
            if (gestureTypingPossibilities.size() > 1) {
                setCandidatesViewShown(true);
                setSuggestions(gestureTypingPossibilities, false, true, true);
            } else {
                setSuggestions(Collections.<CharSequence>emptyList(), false, false, false);
            }
            ic.endBatchEdit();
        }
        gestureTypingDetector.clearGesture();
    }
}

Output:
     if (mGestureTypingEnabled && ic != null) {
-        ArrayList<String> gestureTypingPossibilities = gestureTypingDetector.getCandidates();
+        ArrayList<String> gestureTypingPossibilities = mGestureTypingDetector.getCandidates();
         final boolean isShifted = mShiftKeyState.isActive();


Input:
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
    widgetIDs = appWidgetIds;
    final int N = appWidgetIds.length;
    this.appWidgetManager = appWidgetManager;
    for (int i = 0; i < N; i++) {
        Intent intent = new Intent(context, MVVWidgetService.class);
        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetIds[i]);
        intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));
        rv = new RemoteViews(context.getPackageName(), R.layout.mvv_widget);
        Calendar c = Calendar.getInstance();
        String headerMVVWidget = "String_Node_Str" + c.get(Calendar.DAY_OF_MONTH) + "String_Node_Str" + c.get(Calendar.MONTH) + "String_Node_Str" + c.get(Calendar.YEAR);
        rv.setTextViewText(R.id.mvv_widget_header, headerMVVWidget);
        rv.setRemoteAdapter(appWidgetIds[i], R.id.mvv_widget_item, intent);
        rv.setEmptyView(R.id.empty_view, R.id.empty_view);
        rv.setOnClickPendingIntent(R.id.mvv_refresh, getPendingSelfIntent(context, SYNC_CLICKED));
        appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
    }
    super.onUpdate(context, appWidgetManager, appWidgetIds);
}

Output:
         rv.setEmptyView(R.id.empty_view, R.id.empty_view);
-        rv.setOnClickPendingIntent(R.id.mvv_refresh, getPendingSelfIntent(context, SYNC_CLICKED));
+        rv.setOnClickPendingIntent(R.id.mvv_refresh, getPendingSelfIntent(context, Const.SYNC_CLICKED));
         appWidgetManager.updateAppWidget(appWidgetIds[i], rv);


Input:
public boolean hasNext() {
    return in.hasNext();
}

Output:
 public boolean hasNext() {
-    return in.hasNext();
+    return (nextEvent != null) || in.hasNext();
 }


Input:
public OverlayEdgeWrapper<V, E> getObject(final int index, final OverlayEdgeWrapper<V, E> e) {
    e.we = idmap.getEdge(index, e.we);
    return e;
}

Output:
 public OverlayEdgeWrapper<V, E> getObject(final int index, final OverlayEdgeWrapper<V, E> e) {
-    e.we = idmap.getEdge(index, e.we);
+    e.we = idmap.getEdge(index, e.ref);
     return e;


Input:
public void execute(Collection<Annotation> annos) {
    SessionManager.getInstance().createSession("String_Node_Str");
    Collection<Annotation> toremove = new HashSet<Annotation>();
    try {
        for (Annotation anno : annos) {
            Element e = (Element) anno.getTarget();
            if (!e.isEditable()) {
                Application.getInstance().getGUILog().log("String_Node_Str" + element.getHumanName() + "String_Node_Str");
                continue;
            }
            PropertyValueType valueType = PropertyValueType.valueOf((String) ((JSONObject) ((JSONObject) result.get("String_Node_Str")).get(e.getID())).get("String_Node_Str"));
            JSONArray vals = (JSONArray) ((JSONObject) ((JSONObject) result.get("String_Node_Str")).get(e.getID())).get("String_Node_Str");
            if (e instanceof Property) {
                if (vals == null || vals.isEmpty()) {
                    ((Property) e).setDefaultValue(null);
                } else {
                    update((Property) e, valueType, vals.get(0));
                }
            } else if (e instanceof Slot) {
                if (values == null || values.isEmpty()) {
                    ((Slot) element).getValue().clear();
                } else {
                    update((Slot) e, type, values);
                }
            }
            toremove.add(anno);
        }
        SessionManager.getInstance().closeSession();
        saySuccess();
        this.removeViolationsAndUpdateWindow(toremove);
    } catch (Exception ex) {
        SessionManager.getInstance().cancelSession();
        Utils.printException(ex);
    }
}

Output:
             }
-            PropertyValueType valueType = PropertyValueType.valueOf((String) ((JSONObject) ((JSONObject) result.get("String_Node_Str")).get(e.getID())).get("String_Node_Str"));
-            JSONArray vals = (JSONArray) ((JSONObject) ((JSONObject) result.get("String_Node_Str")).get(e.getID())).get("String_Node_Str");
+            PropertyValueType valueType = PropertyValueType.valueOf((String) ((Map<String, JSONObject>) result.get("String_Node_Str")).get(e.getID()).get("String_Node_Str"));
+            JSONArray vals = (JSONArray) ((Map<String, JSONObject>) result.get("String_Node_Str")).get(e.getID()).get("String_Node_Str");
             if (e instanceof Property) {


Input:
protected ResourceScaling fromValue(String value) {
    if (value.equals(SIZE))
        return ResourceScaling.SIZE;
    if (value.equals(TILE))
        return ResourceScaling.TILE;
    return ResourceScaling.DEFAULT;
}

Output:
 protected ResourceScaling fromValue(String value) {
-    if (value.equals(SIZE))
+    if (value.equals(SIZE)) {
         return ResourceScaling.SIZE;


Input:
private void showProblems(ProblemSet moveProblems) {
    StringBuilder sb = new StringBuilder();
    for (MoveProblem moveProblem : moveProblems.getProblems()) {
        sb.append(moveProblem.getCause().getName());
        sb.append(StringConstants.NEWLINE);
    }
    ErrorHandlingUtil.createMessageDialog(MessageIDs.I_CANNOT_MOVE_TC, null, new String[] { NLS.bind(Messages.InfoDetailCannotMoveTc, sb.toString()) });
}

Output:
     StringBuilder sb = new StringBuilder();
-    for (MoveProblem moveProblem : moveProblems.getProblems()) {
-        sb.append(moveProblem.getCause().getName());
+    for (INodePO moveProblem : moveProblems.getProblems()) {
+        sb.append(moveProblem.getName());
         sb.append(StringConstants.NEWLINE);


Input:
public boolean isDateValid() {
    Date sd = getStartDate();
    Date ed = getEndDate();
    if ((sd == null) && (ed == null)) {
        return true;
    }
    Date now = new Date();
    if (sd != null) {
        if (now.before(sd)) {
            return false;
        }
    }
    if (ed != null) {
        if (now.after(sd)) {
            return false;
        }
    }
    return true;
}

Output:
     if (ed != null) {
-        if (now.after(sd)) {
+        if (now.after(ed)) {
             return false;


Input:
protected boolean testXOverlap(Object3D near) {
    return !(this.getXMin() > near.getXMax() || near.getXMin() > this.getXMax());
}

Output:
 protected boolean testXOverlap(Object3D near) {
-    return !(this.getXMin() > near.getXMax() || near.getXMin() > this.getXMax());
+    return !(this.getXMin() >= near.getXMax() || near.getXMin() >= this.getXMax());
 }


Input:
private void build() {
    color = new Color4();
    faces = new Rectangle[6];
    Rectangle north = new Rectangle(size, size, quality, quality, color);
    Rectangle east = new Rectangle(size, size, quality, quality, color);
    Rectangle south = new Rectangle(size, size, quality, quality, color);
    Rectangle west = new Rectangle(size, size, quality, quality, color);
    Rectangle up = new Rectangle(size, size, quality, quality, color);
    Rectangle down = new Rectangle(size, size, quality, quality, color);
    north.position().z = halfSize;
    north.lightingEnabled(false);
    east.rotation().y = -90;
    east.position().x = -halfSize;
    east.lightingEnabled(false);
    south.rotation().y = 180;
    south.position().z = -halfSize;
    south.lightingEnabled(false);
    west.rotation().y = 90;
    west.position().x = halfSize;
    west.lightingEnabled(false);
    up.rotation().x = -90;
    up.position().y = halfSize;
    up.lightingEnabled(false);
    down.rotation().x = 90;
    down.position().y = -halfSize;
    down.lightingEnabled(false);
    faces[Face.North.ordinal()] = north;
    faces[Face.East.ordinal()] = east;
    faces[Face.South.ordinal()] = south;
    faces[Face.West.ordinal()] = west;
    faces[Face.Up.ordinal()] = up;
    faces[Face.Down.ordinal()] = down;
    addChild(north);
    addChild(east);
    addChild(south);
    addChild(west);
    addChild(up);
    addChild(down);
}

Output:
     east.rotation().y = -90;
-    east.position().x = -halfSize;
+    east.position().x = halfSize;
+    east.doubleSidedEnabled(true);
     east.lightingEnabled(false);


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (savedInstanceState != null) {
        convertListener = (ViewConvertListener) savedInstanceState.getSerializable("String_Node_Str");
    }
}

Output:
     if (savedInstanceState != null) {
-        convertListener = (ViewConvertListener) savedInstanceState.getSerializable("String_Node_Str");
+        convertListener = savedInstanceState.getParcelable("String_Node_Str");
     }


Input:
protected void performMultiAction(List<T> objects) {
    for (T object : objects) {
        perfromSingleAction(object);
    }
}

Output:
     for (T object : objects) {
-        perfromSingleAction(object);
+        perfromSingleAction(target, object);
     }


Input:
public void setCollectionContentType(Class javaClass) {
    collectionContentType = javaClass;
}

Output:
 public void setCollectionContentType(Class javaClass) {
-    collectionContentType = javaClass;
+    setAttributeElementClass(javaClass);
 }


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mPairsSpinner = new Spinner(getActivity());
    mPairsSpinner.setAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, getResources().getStringArray(R.array.ExchangePairs)));
    if (savedInstanceState != null) {
        mPairsSpinner.setSelection(savedInstanceState.getInt("String_Node_Str"));
    }
    mPairsSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
        public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
            String selected = parent.getSelectedItem().toString();
            Bundle bundle = new Bundle();
            bundle.putString("String_Node_Str", selected);
            if (mFragmentOpenedFirstTime) {
                getLoaderManager().initLoader(LOADER_ID, bundle, OrdersBookFragment.this);
                mFragmentOpenedFirstTime = false;
            } else {
                getLoaderManager().restartLoader(LOADER_ID, bundle, OrdersBookFragment.this);
            }
        }
        public void onNothingSelected(AdapterView<?> parent) {
        }
    });
    mAsksAdapter = new OrdersBookAdapter(getActivity());
    mBidsAdapter = new OrdersBookAdapter(getActivity());
}

Output:
     super.onCreate(savedInstanceState);
-    mPairsSpinner = new Spinner(getActivity());
+    mPairsSpinner = (Spinner) LayoutInflater.from(getActivity()).inflate(R.layout.spinner, null);
     mPairsSpinner.setAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, getResources().getStringArray(R.array.ExchangePairs)));


Input:
private static boolean checkIfFinalAndReplace(DfaState state, LookAheadDfa dnet) {
    Set<Integer> predictingAlts = state.getAllPredictingAlts();
    if (predictingAlts.size() == 1) {
        int alt = predictingAlts.iterator().next();
        state.setAlt(alt);
        dnet.overrideFinalState(alt, state);
        state.setStopTransit(true);
        return true;
    }
    return false;
}

Output:
         state.setAlt(alt);
-        dnet.overrideFinalState(alt, state);
+        DfaState oldFinal = dnet.overrideFinalState(alt, state);
+        if (backup && !finalsBack.containsKey(alt))
+            finalsBack.put(alt, oldFinal);
         state.setStopTransit(true);


Input:
public String asDScriptList() {
    String dScriptList = "String_Node_Str";
    if (this.isEmpty())
        return dScriptList;
    for (Enchantment enchantment : this.keySet()) dScriptList = dScriptList + enchantment.getName() + "String_Node_Str";
    return dScriptList.substring(1, dScriptList.length() - 1);
}

Output:
     for (Enchantment enchantment : this.keySet()) dScriptList = dScriptList + enchantment.getName() + "String_Node_Str";
-    return dScriptList.substring(1, dScriptList.length() - 1);
+    return dScriptList.substring(0, dScriptList.length() - 1);
 }


Input:
public boolean performOk() {
    if (doSaveEmptyParameter(parameters)) {
        refreshPositions();
        if (this.modelChanged && this.getContainer() != null && this.getContainer() instanceof DataSetEditor) {
            this.modelChanged = false;
            ((DataSetHandle) getContainer().getModel()).removeListener(this);
            ((DataSetEditor) getContainer()).updateDataSetDesign(this);
        }
        return super.performOk();
    } else {
        String name = getNoneValuedParameterName();
        TestDialog a = new TestDialog(null, "String_Node_Str");
        if (a.open() == Dialog.OK)
            return true;
        else
            return false;
    }
}

Output:
         String name = getNoneValuedParameterName();
-        TestDialog a = new TestDialog(null, "String_Node_Str");
-        if (a.open() == Dialog.OK)
-            return true;
-        else
-            return false;
+        boolean confirm = MessageDialog.openConfirm(null, Messages.getString("String_Node_Str"), Messages.getFormattedString("String_Node_Str", new Object[] { name }));
+        if (confirm)
+            ((DataSetEditor) getContainer()).updateDataSetDesign(this);
+        return confirm;
     }


Input:
public String getUser() {
    return user;
}

Output:
 public String getUser() {
-    return user;
+    return user.trim();
 }


Input:
public void testWriteChannelState() throws IOException, ClassNotFoundException {
    StorageOptions options = StorageOptions.builder().projectId("String_Node_Str").retryParams(RetryParams.defaultInstance()).build();
    BlobWriteChannel writer = new BlobWriteChannel(options, BlobInfo.builder(BlobId.of("String_Node_Str", "String_Node_Str")).build(), "String_Node_Str");
    RestorableState<WriteChannel> state = writer.capture();
    RestorableState<WriteChannel> deserializedState = serializeAndDeserialize(state);
    assertEquals(state, deserializedState);
    assertEquals(state.hashCode(), deserializedState.hashCode());
    assertEquals(state.toString(), deserializedState.toString());
}

Output:
 public void testWriteChannelState() throws IOException, ClassNotFoundException {
-    StorageOptions options = StorageOptions.builder().projectId("String_Node_Str").retryParams(RetryParams.defaultInstance()).build();
+    StorageOptions options = StorageOptions.builder().projectId("String_Node_Str").build();
     BlobWriteChannel writer = new BlobWriteChannel(options, BlobInfo.builder(BlobId.of("String_Node_Str", "String_Node_Str")).build(), "String_Node_Str");


Input:
public void getResourceResponse(JSONObject response) {
    try {
        final String username = response.getString("String_Node_Str");
        final String projectName = response.getString("String_Node_Str");
        final String resourcePath = response.getString("String_Node_Str");
        final long updateTimestamp = response.getLong("String_Node_Str");
        final String updateHash = response.getString("String_Node_Str");
        ConnectedProject connectedProject = this.syncedProjects.get(projectName);
        if (this.username.equals(username) && connectedProject != null) {
            boolean stored = false;
            IProject project = connectedProject.getProject();
            IResource resource = project.findMember(resourcePath);
            if (resource != null) {
                if (resource instanceof IFile) {
                    String localHash = connectedProject.getHash(resourcePath);
                    long localTimestamp = connectedProject.getTimestamp(resourcePath);
                    if (localHash != null && !localHash.equals(updateHash) && localTimestamp < updateTimestamp) {
                        IFile file = (IFile) resource;
                        String newResourceContent = response.getString("String_Node_Str");
                        connectedProject.setTimestamp(resourcePath, updateTimestamp);
                        connectedProject.setHash(resourcePath, updateHash);
                        file.setContents(new ByteArrayInputStream(newResourceContent.getBytes()), true, true, null);
                        file.setLocalTimeStamp(updateTimestamp);
                        stored = true;
                    }
                }
            } else {
                IFile newFile = project.getFile(resourcePath);
                String newResourceContent = response.getString("String_Node_Str");
                connectedProject.setHash(resourcePath, updateHash);
                connectedProject.setTimestamp(resourcePath, updateTimestamp);
                newFile.create(new ByteArrayInputStream(newResourceContent.getBytes()), true, null);
                newFile.setLocalTimeStamp(updateTimestamp);
                stored = true;
            }
            if (stored) {
                JSONObject message = new JSONObject();
                message.put("String_Node_Str", this.username);
                message.put("String_Node_Str", connectedProject.getName());
                message.put("String_Node_Str", resourcePath);
                message.put("String_Node_Str", updateTimestamp);
                message.put("String_Node_Str", updateHash);
                message.put("String_Node_Str", "String_Node_Str");
                messagingConnector.send("String_Node_Str", message);
                notifyResourceChanged(resource);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Output:
                 messagingConnector.send("String_Node_Str", message);
-                notifyResourceChanged(resource);
+                if (resource != null) {
+                    notifyResourceChanged(resource);
+                }
             }


Input:
public void handleEvent(Event event) {
    MessageBox messageBox = new MessageBox(parent.getShell(), SWT.APPLICATION_MODAL | SWT.OK | SWT.CANCEL);
    messageBox.setText(Messages.getString("String_Node_Str"));
    messageBox.setMessage(Messages.getString("String_Node_Str"));
    if (messageBox.open() == SWT.OK) {
        MetadataToolHelper.copyTable(getInputMetaData(), getOutputMetaData());
        outputMetaView.getTableViewerCreator().getTableViewer().refresh();
    }
}

Output:
     if (messageBox.open() == SWT.OK) {
-        MetadataToolHelper.copyTable(getInputMetaData(), getOutputMetaData());
+        MetadataToolHelper.copyTable(getInputMetaData(), getOutputMetaData(), true);
         outputMetaView.getTableViewerCreator().getTableViewer().refresh();


Input:
public FieldData updateFieldValues(PrestoContextRules rules, PrestoFieldUsage field, FieldData fieldData) {
    PrestoTopic topicAfterSave = updatePrestoTopic(rules, fieldData);
    return getFieldData(topicAfterSave, field);
}

Output:
 public FieldData updateFieldValues(PrestoContextRules rules, PrestoFieldUsage field, FieldData fieldData) {
-    PrestoTopic topicAfterSave = updatePrestoTopic(rules, fieldData);
-    return getFieldData(topicAfterSave, field);
+    PrestoContext updatedContext = updatePrestoTopic(rules, fieldData);
+    return getFieldDataAndProcess(updatedContext, field);
 }


Input:
public void parse(IoBuffer byteBuffer, CharsetDecoder decoder) throws SAXException {
    lastPosition = byteBuffer.position();
    while (byteBuffer.hasRemaining() && state != State.CLOSED) {
        char c = (char) byteBuffer.get();
        if (state == State.START) {
            if (c == '<') {
                emit(c, byteBuffer);
                state = State.IN_TAG;
            } else {
                state = State.IN_TEXT;
            }
        } else if (state == State.IN_TEXT) {
            if (c == '<') {
                emit(byteBuffer, decoder);
                emit(c, byteBuffer);
                state = State.IN_TAG;
            }
        } else if (state == State.IN_TAG) {
            if (c == '>') {
                emit(c, byteBuffer);
                state = State.START;
            } else if (c == '"') {
                emit(c, byteBuffer);
                state = State.IN_DOUBLE_ATTRIBUTE_VALUE;
            } else if (c == '\'') {
                emit(c, byteBuffer);
                state = State.IN_SINGLE_ATTRIBUTE_VALUE;
            } else if (c == '-') {
                emit(c, byteBuffer);
            } else if (isControlChar(c)) {
                emit(c, byteBuffer);
            } else if (Character.isWhitespace(c)) {
                lastPosition = byteBuffer.position();
            } else {
                state = State.IN_STRING;
            }
        } else if (state == State.IN_STRING) {
            if (c == '>') {
                emit(byteBuffer, CharsetUtil.UTF8_DECODER);
                emit(c, byteBuffer);
                state = State.START;
            } else if (isControlChar(c)) {
                emit(byteBuffer, CharsetUtil.UTF8_DECODER);
                emit(c, byteBuffer);
                state = State.IN_TAG;
            } else if (Character.isWhitespace(c)) {
                emit(byteBuffer, CharsetUtil.UTF8_DECODER);
                state = State.IN_TAG;
            } else {
            }
        } else if (state == State.IN_DOUBLE_ATTRIBUTE_VALUE) {
            if (c == '"') {
                emit(byteBuffer, decoder);
                emit(c, byteBuffer);
                state = State.IN_TAG;
            }
        } else if (state == State.IN_SINGLE_ATTRIBUTE_VALUE) {
            if (c == '\'') {
                emit(byteBuffer, decoder);
                emit(c, byteBuffer);
                state = State.IN_TAG;
            }
        }
    }
    byteBuffer.position(lastPosition);
}

Output:
             } else if (Character.isWhitespace(c)) {
-                lastPosition = byteBuffer.position();
+                buffer.clear();
             } else {


Input:
public String claimMessage() {
    final String uuid = UUID.randomUUID().toString();
    final int rows = jdbcTemplate.update("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", DequeueStatus.CLAIMED.name(), dateTimeProvider.getCurrentDateTime().toDate().getTime() / 1000, host.name(), uuid);
    switch(rows) {
        case 0:
            return null;
        case 1:
            return uuid;
        default:
            throw new IllegalStateException("String_Node_Str");
    }
}

Output:
     final String uuid = UUID.randomUUID().toString();
-    final int rows = jdbcTemplate.update("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", DequeueStatus.CLAIMED.name(), dateTimeProvider.getCurrentDateTime().toDate().getTime() / 1000, host.name(), uuid);
+    final int rows = jdbcTemplate.update("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", DequeueStatus.CLAIMED.name(), dateTimeProvider.getCurrentDateTime().toDate().getTime() / 1000, Hosts.getLocalHostName(), uuid);
     switch(rows) {


Input:
public void populate(LiveOperations liveOperations) {
    for (Queue<ParkedOperation> parkQueue : parkQueueMap.values()) {
        for (ParkedOperation op : parkQueue) {
            liveOperations.add(op.getCallerAddress(), op.getCallId());
        }
    }
}

Output:
     for (Queue<ParkedOperation> parkQueue : parkQueueMap.values()) {
-        for (ParkedOperation op : parkQueue) {
-            liveOperations.add(op.getCallerAddress(), op.getCallId());
+        for (ParkedOperation parkedOperation : parkQueue) {
+            Operation operation = parkedOperation.getOperation();
+            liveOperations.add(operation.getCallerAddress(), operation.getCallId());
         }


Input:
private WordElement convertNodeToWord(Node wordNode) {
    if (!wordNode.getNodeName().equalsIgnoreCase(XML_WORD))
        return null;
    WordElement word = new WordElement();
    List<Inflection> inflections = new ArrayList<Inflection>();
    NodeList nodes = wordNode.getChildNodes();
    for (int i = 0; i < nodes.getLength(); i++) {
        Node featureNode = nodes.item(i);
        if (featureNode.getNodeType() == Node.ELEMENT_NODE) {
            String feature = featureNode.getNodeName().trim();
            String value = featureNode.getTextContent();
            if (value != null)
                value = value.trim();
            if (feature == null) {
                System.out.println("String_Node_Str" + word.toString());
                break;
            }
            if (feature.equalsIgnoreCase(XML_BASE)) {
                word.setBaseForm(value);
            } else if (feature.equalsIgnoreCase(XML_CATEGORY))
                word.setCategory(LexicalCategory.valueOf(value.toUpperCase()));
            else if (feature.equalsIgnoreCase(XML_ID))
                word.setId(value);
            else if (value == null || value.equals("String_Node_Str")) {
                Inflection infl = Inflection.getInflCode(feature);
                if (infl != null) {
                    inflections.add(infl);
                } else {
                    word.setFeature(feature, true);
                }
            } else
                word.setFeature(feature, value);
        }
    }
    if (inflections.isEmpty()) {
        inflections.add(Inflection.REGULAR);
    }
    Inflection defaultInfl = inflections.contains(Inflection.REGULAR) ? Inflection.REGULAR : inflections.get(0);
    word.setFeature(LexicalFeature.DEFAULT_INFL, defaultInfl);
    word.setDefaultInflectionalVariant(defaultInfl);
    for (Inflection infl : inflections) {
        word.addInflectionalVariant(infl);
    }
    return word;
}

Output:
             if (feature == null) {
-                System.out.println("String_Node_Str" + word.toString());
+                System.err.println("String_Node_Str" + word.toString());
                 break;


Input:
public int getSourceActions(JComponent comp) {
    return MOVE;
}

Output:
 public int getSourceActions(JComponent comp) {
-    return MOVE;
+    return isEditable() ? MOVE : COPY;
 }


Input:
public boolean isCancelled() {
    if (spongeEvent instanceof Cancellable) {
        return ((Cancellable) spongeEvent).isCancelled();
    }
    return isCanceled();
}

Output:
 public boolean isCancelled() {
-    if (spongeEvent instanceof Cancellable) {
-        return ((Cancellable) spongeEvent).isCancelled();
+    if (this.spongeEvent instanceof Cancellable) {
+        return ((Cancellable) this.spongeEvent).isCancelled();
     }


Input:
private SheetData createImageData(IImageContent image, StyleEntry entry, XlsContainer container, int imageHeightDpi, int imageWidhtDpi) {
    int type = SheetData.IMAGE;
    entry.setProperty(StyleConstant.DATA_TYPE_PROP, type);
    String uri = image.getURI();
    String mimeType = image.getMIMEType();
    String extension = image.getExtension();
    String altText = image.getAltText();
    if (FlashFile.isFlash(mimeType, uri, extension)) {
        if (null == altText) {
            altText = messageFlashObjectNotSupported;
        }
        entry.setProperty(StyleConstant.DATA_TYPE_PROP, SheetData.STRING);
        return createData(altText, entry);
    }
    try {
        Image imageInfo = EmitterUtil.parseImage(image, image.getImageSource(), image.getURI(), image.getMIMEType(), image.getExtension());
        byte[] data = imageInfo.getData();
        if (data != null) {
            return createData(image, entry, container, type, imageInfo, imageHeightDpi, imageWidhtDpi);
        } else {
            entry.setProperty(StyleConstant.DATA_TYPE_PROP, SheetData.STRING);
            return createData(image.getAltText(), entry);
        }
    } catch (IOException e) {
        logger.log(Level.WARNING, e.getLocalizedMessage());
        entry.setProperty(StyleConstant.DATA_TYPE_PROP, SheetData.STRING);
        return createData(image.getAltText(), entry);
    }
}

Output:
         if (data != null) {
-            return createData(image, entry, container, type, imageInfo, imageHeightDpi, imageWidhtDpi);
+            return createData(image, imageWidth, entry, container, type, imageInfo, imageHeightDpi, imageWidhtDpi);
         } else {