Input:
public static void putAsJson(String path, JsonNode data, EtcdClient etcdClient) throws IOException, EtcdAuthenticationException, TimeoutException, EtcdException {
    Map<String, Object> flattened = new JsonFlattener(EtcdUtil.jsonToString(data)).withFlattenMode(FlattenMode.MONGODB).withSeparator('/').withKeyTransformer(new KeyTransformer() {
        public String transform(String s) {
            return s.replaceAll("String_Node_Str", "String_Node_Str");
        }
    }).flattenAsMap();
    try {
        etcdClient.delete(path).recursive().send().get();
    } catch (EtcdException e) {
        if (EtcdErrorCode.KeyNotFound != e.errorCode) {
            throw e;
        }
    }
    for (Map.Entry<String, Object> entry : flattened.entrySet()) {
        etcdClient.put(path + "String_Node_Str" + entry.getKey(), String.valueOf(entry.getValue())).send().get();
    }
}

Output:
 public static void putAsJson(String path, JsonNode data, EtcdClient etcdClient) throws IOException, EtcdAuthenticationException, TimeoutException, EtcdException {
-    Map<String, Object> flattened = new JsonFlattener(EtcdUtil.jsonToString(data)).withFlattenMode(FlattenMode.MONGODB).withSeparator('/').withKeyTransformer(new KeyTransformer() {
-        public String transform(String s) {
-            return s.replaceAll("String_Node_Str", "String_Node_Str");
-        }
-    }).flattenAsMap();
+    Map<String, Object> flattened = new JsonFlattener(EtcdUtil.jsonToString(data)).withFlattenMode(FlattenMode.MONGODB).withSeparator('/').flattenAsMap();
     try {


Input:
public boolean execute(ScriptEntry theEntry) throws CommandException {
    boolean shortFormat = false;
    if (theEntry.arguments() != null) {
        for (String thisArgument : theEntry.arguments()) {
            if (thisArgument.toUpperCase().contains("String_Node_Str"))
                shortFormat = true;
        }
    }
    String theScript = theEntry.getScript();
    Integer theStep = theEntry.getStep();
    List<String> chatTriggers = new ArrayList<String>();
    String scriptPath = theScript + "String_Node_Str" + theStep + "String_Node_Str";
    boolean thisTriggerExists = true;
    int x = 1;
    do {
        if (plugin.getScripts().contains(scriptPath + x + "String_Node_Str")) {
            String ct = plugin.getScripts().getString(scriptPath + x + "String_Node_Str");
            if (!ct.contains("String_Node_Str"))
                chatTriggers.add(ct);
            aH.echoDebug("String_Node_Str" + chatTriggers.get(x - 1) + "String_Node_Str");
        } else
            thisTriggerExists = false;
        x++;
    } while (thisTriggerExists);
    if (chatTriggers.isEmpty())
        return false;
    StringBuilder sb = new StringBuilder();
    sb.append(plugin.settings.NpcHintPrefix());
    for (int i = 0; i < chatTriggers.size(); i++) {
        String item = chatTriggers.get(i);
        String fitem = getFormattedTrigger(item, shortFormat);
        aH.echoDebug("String_Node_Str" + fitem);
        sb.append(fitem);
        if (i != chatTriggers.size() - 1)
            sb.append("String_Node_Str");
    }
    theEntry.getPlayer().sendMessage(sb.toString());
    return true;
}

Output:
                 chatTriggers.add(ct);
-            aH.echoDebug("String_Node_Str" + chatTriggers.get(x - 1) + "String_Node_Str");
+            aH.echoDebug("String_Node_Str" + ct + "String_Node_Str");
         } else


Input:
private boolean editDataSet(DataSetHandle ds) {
    dataSetHandle = ds;
    if (dataSetHandle == null)
        return false;
    if (dataSetHandle instanceof ScriptDataSetHandle) {
        return false;
    }
    DataSetEditor dialog = new AdvancedDataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true);
    return (dialog.open() == Window.OK);
}

Output:
     }
-    DataSetEditor dialog = new AdvancedDataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true);
+    DataSetEditor dialog = new AdvancedDataSetEditor(PlatformUI.getWorkbench().getDisplay().getActiveShell(), dataSetHandle, true, true);
     return (dialog.open() == Window.OK);


Input:
protected void addFields() {
    Composite mainComposite = Form.startNewGridLayout(this, 2);
    addGroupDelimitedFileSettings(mainComposite, 280, 80);
    addGroupRowsToSkip(mainComposite, 300, 80);
    addGroupDieOnErrorSettings(mainComposite, 280, 60);
    addGroupLimit(mainComposite, 300, 60);
    Composite mainComposite2 = Form.startNewGridLayout(this, 1);
    addGroupFileViewer(mainComposite2, 600, 200);
    if (!isInWizard()) {
        Composite compositeBottomButton = Form.startNewGridLayout(this, 2, false, SWT.CENTER, SWT.CENTER);
        cancelButton = new UtilsButton(compositeBottomButton, Messages.getString("String_Node_Str"), WIDTH_BUTTON_PIXEL, HEIGHT_BUTTON_PIXEL);
    }
}

Output:
     Composite mainComposite = Form.startNewGridLayout(this, 2);
-    addGroupDelimitedFileSettings(mainComposite, 280, 80);
-    addGroupRowsToSkip(mainComposite, 300, 80);
-    addGroupDieOnErrorSettings(mainComposite, 280, 60);
-    addGroupLimit(mainComposite, 300, 60);
+    addGroupDelimitedFileSettings(mainComposite, 280, 120);
+    addGroupRowsToSkip(mainComposite, 300, 120);
+    addGroupDieOnErrorSettings(mainComposite, 280, 67);
+    addGroupLimit(mainComposite, 300, 67);
     Composite mainComposite2 = Form.startNewGridLayout(this, 1);


Input:
private void updateScreenNail(long version, Future<Bitmap> future) {
    ImageEntry entry = mImageCache.get(version);
    if (entry == null || entry.screenNailTask == null) {
        Bitmap screenNail = future.get();
        if (screenNail != null)
            screenNail.recycle();
        return;
    }
    entry.screenNailTask = null;
    entry.screenNail = future.get();
    if (entry.screenNail == null) {
        entry.failToLoad = true;
    } else {
        if (mDataListener != null) {
            mDataListener.onPhotoAvailable(version, false);
        }
        for (int i = -1; i <= 1; ++i) {
            if (version == getVersion(mCurrentIndex + i)) {
                if (i == 0)
                    updateTileProvider(entry);
                mPhotoView.notifyImageInvalidated(i);
            }
        }
    }
    updateImageRequests();
}

Output:
     ImageEntry entry = mImageCache.get(version);
-    if (entry == null || entry.screenNailTask == null) {
+    if (entry == null || entry.screenNailTask != future) {
         Bitmap screenNail = future.get();


Input:
public org.hl7.fhir.dstu2.model.ClinicalImpression.ClinicalImpressionFindingComponent convertClinicalImpressionFindingComponent(org.hl7.fhir.dstu3.model.ClinicalImpression.ClinicalImpressionFindingComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.ClinicalImpression.ClinicalImpressionFindingComponent tgt = new org.hl7.fhir.dstu2.model.ClinicalImpression.ClinicalImpressionFindingComponent();
    copyElement(src, tgt);
    if (src.hasItemCodeableConcept())
        try {
            tgt.setItem(convertCodeableConcept(src.getItemCodeableConcept()));
        } catch (org.hl7.fhir.dstu3.exceptions.FHIRException e) {
        }
    tgt.setCause(src.getCause());
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.ClinicalImpression.ClinicalImpressionFindingComponent convertClinicalImpressionFindingComponent(org.hl7.fhir.dstu3.model.ClinicalImpression.ClinicalImpressionFindingComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
private void populateStockPanel() {
    game.StockPrice[][] market = modelChart.getStockChart();
    stockGrid.setColumns(market[0].length);
    stockGrid.setRows(market.length);
    for (int x = 0; x < market.length; x++) {
        for (int y = 0; y < market.length; y++) {
            JTextField foo;
            try {
                foo = new JTextField(Integer.toString(market[x][y].getPrice()));
            } catch (NullPointerException e) {
                foo = new JTextField("String_Node_Str");
                foo.setBorder(null);
            }
            try {
                setStockBGColor(market[x][y].getColour(), foo);
            } catch (NullPointerException e) {
                foo.setBackground(Color.WHITE);
            }
            foo.setEditable(false);
            stockPanel.add(foo);
        }
    }
}

Output:
     for (int x = 0; x < market.length; x++) {
-        for (int y = 0; y < market.length; y++) {
+        for (int y = 0; y < market[0].length; y++) {
             JTextField foo;


Input:
public TTQueueTable getQueueTable(byte[] queueTableName) throws OperationException {
    TTQueueTable queueTable = this.queueTables.get(queueTableName);
    if (queueTable != null)
        return queueTable;
    OrderedVersionedColumnarTable table = getTable(queueOVCTable);
    queueTable = new TTQueueTableOnVCTable(table, oracle, conf);
    TTQueueTable existing = this.queueTables.putIfAbsent(queueTableName, queueTable);
    return existing != null ? existing : queueTable;
}

Output:
     OrderedVersionedColumnarTable table = getTable(queueOVCTable);
-    queueTable = new TTQueueTableOnVCTable(table, oracle, conf);
+    queueTable = new TTQueueTableNewOnVCTable(table, oracle, conf);
     TTQueueTable existing = this.queueTables.putIfAbsent(queueTableName, queueTable);


Input:
public void refresh() {
    List<NutResource> nrs = new LinkedList<NutResource>();
    for (String path : paths) {
        File f = Files.findFile(path);
        if (null == f)
            continue;
        if (!f.getAbsolutePath().contains("String_Node_Str") && f.isFile()) {
            nrs.add(new FileResource(f.getParentFile(), f));
            if (autoscan == false)
                continue;
        }
        List<NutResource> list = Scans.me().scan(path, regex);
        String parent = path;
        int pos = path.lastIndexOf('/');
        if (pos == -1)
            pos = path.lastIndexOf('\\');
        if (pos > 0)
            parent = path.substring(0, pos);
        if (Strings.isBlank(parent)) {
            nrs.addAll(list);
        } else {
            for (NutResource nr : list) if (autoscan) {
                if (nr.getName().startsWith(parent)) {
                    nrs.add(nr);
                }
            } else {
                if (nr.getName().equals(path)) {
                    nrs.add(nr);
                }
            }
        }
    }
    buildSQLMaps(nrs);
}

Output:
 public void refresh() {
-    List<NutResource> nrs = new LinkedList<NutResource>();
-    for (String path : paths) {
-        File f = Files.findFile(path);
-        if (null == f)
-            continue;
-        if (!f.getAbsolutePath().contains("String_Node_Str") && f.isFile()) {
-            nrs.add(new FileResource(f.getParentFile(), f));
-            if (autoscan == false)
-                continue;
-        }
-        List<NutResource> list = Scans.me().scan(path, regex);
-        String parent = path;
-        int pos = path.lastIndexOf('/');
-        if (pos == -1)
-            pos = path.lastIndexOf('\\');
-        if (pos > 0)
-            parent = path.substring(0, pos);
-        if (Strings.isBlank(parent)) {
-            nrs.addAll(list);
-        } else {
-            for (NutResource nr : list) if (autoscan) {
-                if (nr.getName().startsWith(parent)) {
-                    nrs.add(nr);
-                }
-            } else {
-                if (nr.getName().equals(path)) {
-                    nrs.add(nr);
-                }
-            }
+    List<InputStream> list = Scans.me().loadResource(null, paths);
+    _sql_map = new HashMap<String, String>();
+    for (InputStream ins : list) {
+        Reader r = new InputStreamReader(ins);
+        try {
+            loadSQL(r);
+        } catch (IOException e) {
+            throw Lang.wrapThrow(e);
         }


Input:
public <T> Class<? extends T> injectClass(ClassLoader classLoader, String className) {
    try {
        if (classLoader == null) {
            return (Class<T>) injectToBootstrapClassLoader(className);
        } else if (classLoader instanceof URLClassLoader) {
            return (Class<T>) injectToURLClassLoader((URLClassLoader) classLoader, className);
        } else {
            return (Class<T>) injectToPlainClassLoader(classLoader, className);
        }
    } catch (Exception e) {
        logger.warn("String_Node_Str", className, classLoader, e);
        throw new PinpointException("String_Node_Str" + className + "String_Node_Str" + classLoader, e);
    }
}

Output:
         } else if (classLoader instanceof URLClassLoader) {
-            return (Class<T>) injectToURLClassLoader((URLClassLoader) classLoader, className);
+            final URLClassLoader urlClassLoader = (URLClassLoader) classLoader;
+            return (Class<T>) injectToURLClassLoader(urlClassLoader, className);
         } else {


Input:
public boolean contains(AtomicEvent atomicEvent, ConditionExecutor conditionExecutor) {
    PredicateTreeNode predicate = null;
    if (bloomFiltersEnabled) {
        predicate = conditionExecutor.constructPredicate(atomicEvent, tableDefinition, new SQLPredicateBuilder());
        ArrayList tokenList = new ArrayList();
        predicate.populateTokens(tokenList);
        for (int ops = 1; ops < tokenList.size() - 1; ops++) {
            if (tokenList.get(ops).toString().startsWith("String_Node_Str") && tokenList.get(ops).toString().replaceFirst("String_Node_Str", "String_Node_Str").trim().equals("String_Node_Str")) {
                String param = tokenList.get(ops - 1).toString();
                String value = tokenList.get(ops + 1).toString();
                if (!param.startsWith("String_Node_Str")) {
                    param = value.replaceFirst("String_Node_Str", "String_Node_Str").trim();
                    value = tokenList.get(ops - 1).toString().replaceFirst("String_Node_Str", "String_Node_Str").trim();
                } else {
                    param = param.replaceFirst("String_Node_Str", "String_Node_Str").trim();
                    value = value.replaceFirst("String_Node_Str", "String_Node_Str").trim();
                }
                for (int i = 0; i < attributeList.size(); i++) {
                    if (attributeList.get(i).getName().equals(param)) {
                        boolean mightContain = bloomFilters[i].mightContain(value.getBytes());
                        if (!mightContain) {
                            return false;
                        }
                    }
                }
            }
        }
    }
    if ((cachedTable != null) && cachedTable.contains(atomicEvent, conditionExecutor)) {
        return true;
    } else {
        Connection con = null;
        PreparedStatement statement = null;
        try {
            if (predicate == null) {
                predicate = conditionExecutor.constructPredicate(atomicEvent, tableDefinition, new SQLPredicateBuilder());
            }
            con = dataSource.getConnection();
            statement = con.prepareStatement("String_Node_Str" + fullTableName + "String_Node_Str" + predicate.buildPredicateString() + "String_Node_Str");
            ArrayList paramList = new ArrayList();
            predicate.populateParameters(paramList);
            for (int i = 0; i < paramList.size(); i++) {
                populateStatement(statement, i + 1, paramList.get(i));
            }
            ResultSet resultSet = statement.executeQuery();
            boolean contains = false;
            long timestamp = System.currentTimeMillis();
            while (resultSet.next()) {
                contains = true;
                if (cachedTable != null) {
                    Object[] data = new Object[attributeList.size()];
                    for (int i = 0; i < attributeList.size(); i++) {
                        switch(attributeList.get(i).getType()) {
                            case BOOL:
                                data[i] = resultSet.getBoolean(attributeList.get(i).getName());
                                break;
                            case DOUBLE:
                                data[i] = resultSet.getDouble(attributeList.get(i).getName());
                                break;
                            case FLOAT:
                                data[i] = resultSet.getFloat(attributeList.get(i).getName());
                                break;
                            case INT:
                                data[i] = resultSet.getInt(attributeList.get(i).getName());
                                break;
                            case LONG:
                                data[i] = resultSet.getLong(attributeList.get(i).getName());
                                break;
                            case STRING:
                                data[i] = resultSet.getString(attributeList.get(i).getName());
                                break;
                            default:
                                data[i] = resultSet.getObject(attributeList.get(i).getName());
                        }
                    }
                    Event event = new InEvent(tableDefinition.getExternalTable().getParameter(PARAM_TABLE_NAME), timestamp, data);
                    cachedTable.add(event);
                } else {
                    break;
                }
            }
            resultSet.close();
            return contains;
        } catch (SQLException e) {
            log.error("String_Node_Str" + tableDefinition.getExternalTable().getParameter(PARAM_TABLE_NAME), e);
        } finally {
            cleanUpConnections(statement, con);
        }
        return false;
    }
}

Output:
             }
-            con = dataSource.getConnection();
-            statement = con.prepareStatement("String_Node_Str" + fullTableName + "String_Node_Str" + predicate.buildPredicateString() + "String_Node_Str");
-            ArrayList paramList = new ArrayList();
-            predicate.populateParameters(paramList);
-            for (int i = 0; i < paramList.size(); i++) {
-                populateStatement(statement, i + 1, paramList.get(i));
-            }
-            ResultSet resultSet = statement.executeQuery();
-            boolean contains = false;
-            long timestamp = System.currentTimeMillis();
-            while (resultSet.next()) {
-                contains = true;
-                if (cachedTable != null) {
-                    Object[] data = new Object[attributeList.size()];
-                    for (int i = 0; i < attributeList.size(); i++) {
-                        switch(attributeList.get(i).getType()) {
-                            case BOOL:
-                                data[i] = resultSet.getBoolean(attributeList.get(i).getName());
-                                break;
-                            case DOUBLE:
-                                data[i] = resultSet.getDouble(attributeList.get(i).getName());
-                                break;
-                            case FLOAT:
-                                data[i] = resultSet.getFloat(attributeList.get(i).getName());
-                                break;
-                            case INT:
-                                data[i] = resultSet.getInt(attributeList.get(i).getName());
-                                break;
-                            case LONG:
-                                data[i] = resultSet.getLong(attributeList.get(i).getName());
-                                break;
-                            case STRING:
-                                data[i] = resultSet.getString(attributeList.get(i).getName());
-                                break;
-                            default:
-                                data[i] = resultSet.getObject(attributeList.get(i).getName());
+            if (dataSource != null) {
+                con = dataSource.getConnection();
+                statement = con.prepareStatement("String_Node_Str" + fullTableName + "String_Node_Str" + predicate.buildPredicateString() + "String_Node_Str");
+                ArrayList paramList = new ArrayList();
+                predicate.populateParameters(paramList);
+                for (int i = 0; i < paramList.size(); i++) {
+                    populateStatement(statement, i + 1, paramList.get(i));
+                }
+                ResultSet resultSet = statement.executeQuery();
+                boolean contains = false;
+                long timestamp = System.currentTimeMillis();
+                while (resultSet.next()) {
+                    contains = true;
+                    if (cachedTable != null) {
+                        Object[] data = new Object[attributeList.size()];
+                        for (int i = 0; i < attributeList.size(); i++) {
+                            switch(attributeList.get(i).getType()) {
+                                case BOOL:
+                                    data[i] = resultSet.getBoolean(attributeList.get(i).getName());
+                                    break;
+                                case DOUBLE:
+                                    data[i] = resultSet.getDouble(attributeList.get(i).getName());
+                                    break;
+                                case FLOAT:
+                                    data[i] = resultSet.getFloat(attributeList.get(i).getName());
+                                    break;
+                                case INT:
+                                    data[i] = resultSet.getInt(attributeList.get(i).getName());
+                                    break;
+                                case LONG:
+                                    data[i] = resultSet.getLong(attributeList.get(i).getName());
+                                    break;
+                                case STRING:
+                                    data[i] = resultSet.getString(attributeList.get(i).getName());
+                                    break;
+                                default:
+                                    data[i] = resultSet.getObject(attributeList.get(i).getName());
+                            }
                         }


Input:
private void actionPropertyLinkClicked(AjaxRequestTarget target) {
    send(getPage(), Broadcast.BREADTH, new AjaxPropertySelectionEvent(target, groupModel.getObject().getProperty()));
}

Output:
 private void actionPropertyLinkClicked(AjaxRequestTarget target) {
-    send(getPage(), Broadcast.BREADTH, new AjaxPropertySelectionEvent(target, groupModel.getObject().getProperty()));
+    send(getPage(), Broadcast.BREADTH, new AjaxPropertySelectionEvent(target, groupModel.getObject().getProperty(), true));
 }


Input:
private String[] handleEOF() {
    String[] row = null;
    if (output.column != 0) {
        if (output.appender.length() > 0) {
            output.valueParsed();
        } else {
            output.emptyParsed();
        }
        row = output.rowParsed();
    } else if (output.appender.length() > 0) {
        output.valueParsed();
        row = output.rowParsed();
    }
    if (row != null) {
        rowProcessed(row);
    }
    return row;
}

Output:
     String[] row = null;
-    if (output.column != 0) {
-        if (output.appender.length() > 0) {
+    try {
+        if (output.column != 0) {
+            if (output.appender.length() > 0) {
+                output.valueParsed();
+            } else {
+                output.emptyParsed();
+            }
+            row = output.rowParsed();
+        } else if (output.appender.length() > 0) {
             output.valueParsed();


Input:
public List<BusManaged> getEventQualifiers(final Class<? extends BaseEvent> class1) {
    List<BusManaged> result = new ArrayList<BusManaged>();
    for (Entry<Class<?>, List<BusManaged>> entry : eventQualifierMap.entrySet()) {
        Class<?> key = entry.getKey();
        List<BusManaged> value = entry.getValue();
        if (key.isAssignableFrom(class1)) {
            result = value;
        }
    }
    return result;
}

Output:
         if (key.isAssignableFrom(class1)) {
-            result = value;
+            result.addAll(value);
         }


Input:
public void destination(BundleContext context) throws IOException {
    assertThat("String_Node_Str", context, is(notNullValue()));
    setup(context);
    ServiceReference sr = osgi.getServiceReference("String_Node_Str");
    ServicesConfig sc = (ServicesConfig) osgi.getServiceObject(sr);
    ServiceReference sr2 = osgi.getServiceReference("String_Node_Str");
    ConfigurationHelper ch = (ConfigurationHelper) osgi.getServiceObject(sr2);
    assertThat("String_Node_Str", sc, is(notNullValue()));
    ComponentInstance destination1, channel1, service1, adapter1, adapter2, factory;
    adapter1 = ch.newAdapter("String_Node_Str");
    adapter2 = ch.newAdapter("String_Node_Str");
    service1 = ch.newGravityService("String_Node_Str");
    channel1 = ch.newGravityChannel("String_Node_Str", "String_Node_Str");
    destination1 = ch.newGravityDestination("String_Node_Str", "String_Node_Str");
    Service ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser, is(notNullValue()));
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str"), is(notNullValue()));
    destination1.dispose();
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str"), is(nullValue()));
    destination1 = ch.newGravityDestination("String_Node_Str", "String_Node_Str");
    service1.dispose();
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser, is(nullValue()));
    service1 = ch.newGravityService("String_Node_Str", "String_Node_Str");
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str").getAdapter(), is(notNullValue()));
    assertTrue("String_Node_Str", ser.findDestinationById("String_Node_Str").getAdapter().getId().equals("String_Node_Str"));
    destination1.dispose();
    destination1 = ch.newGravityDestination("String_Node_Str", "String_Node_Str", "String_Node_Str");
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str").getAdapter(), is(notNullValue()));
    assertTrue("String_Node_Str", ser.findDestinationById("String_Node_Str").getAdapter().getId().equals("String_Node_Str"));
    adapter2.dispose();
    assertThat("String_Node_Str", sc.findDestinationById("String_Node_Str", "String_Node_Str"), is(nullValue()));
    destination1.dispose();
    service1.dispose();
    service1 = ch.newGraniteService("String_Node_Str");
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser, is(notNullValue()));
    destination1 = ch.newGraniteDestination("String_Node_Str", "String_Node_Str");
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str"), is(notNullValue()));
    destination1.dispose();
    destination1 = ch.newGraniteDestination("String_Node_Str", "String_Node_Str", "String_Node_Str", ConfigurationHelper.SCOPE.SESSION);
    ser = sc.findServiceById("String_Node_Str");
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str"), is(nullValue()));
    factory = ch.newFactory("String_Node_Str");
    assertThat("String_Node_Str", ser.findDestinationById("String_Node_Str"), is(notNullValue()));
    destination1.dispose();
    factory.dispose();
    service1.dispose();
    channel1.dispose();
    adapter1.dispose();
}

Output:
     service1 = ch.newGravityService("String_Node_Str");
-    channel1 = ch.newGravityChannel("String_Node_Str", "String_Node_Str");
+    channel1 = ch.newGravityChannel("String_Node_Str", "String_Node_Str", "String_Node_Str");
     destination1 = ch.newGravityDestination("String_Node_Str", "String_Node_Str");


Input:
private void clickUnitButton(int buttonPos) {
    clearButtonSelection();
    boolean didConvert = mUnitType.selectUnit(buttonPos);
    if (didConvert)
        mCallback.updateScreen(true);
    colorSelectedButton();
}

Output:
     boolean didConvert = mUnitType.selectUnit(buttonPos);
-    if (didConvert)
-        mCallback.updateScreen(true);
+    mCallback.updateScreen(true);
     colorSelectedButton();


Input:
public void debug(String msg) {
    debugRecipient.sendMessage(msg);
}

Output:
 public void debug(String msg) {
-    debugRecipient.sendMessage(msg);
+    if (debugRecipient != null)
+        debugRecipient.sendMessage(msg);
 }


Input:
private static void injectViews(Object classObj, ViewFinder viewFinder) throws IllegalAccessException, IllegalArgumentException {
    Class<?> clazz = classObj.getClass();
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        if (field.isAnnotationPresent(ViewInject.class)) {
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            int id = viewInject.value();
            if (id > 0) {
                field.setAccessible(true);
                View v = viewFinder.findViewById(id);
                if (v != null) {
                    field.set(classObj, v);
                }
            }
        }
    }
}

Output:
                 if (v != null) {
-                    field.set(classObj, v);
+                    try {
+                        field.set(classObj, v);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
                 }


Input:
public void metadataInputChanged(IODataComponent dataComponent, String connectionToApply) {
    List<Map<String, String>> listRoot = (List<Map<String, String>>) this.getElementParameter(ROOT).getValue();
    boolean flagRoot = false;
    List<Map<String, String>> listGroup = (List<Map<String, String>>) this.getElementParameter(GROUP).getValue();
    boolean flagGroup = false;
    List<Map<String, String>> listLoop = (List<Map<String, String>>) this.getElementParameter(LOOP).getValue();
    boolean flagLoop = false;
    String schemaId = "String_Node_Str";
    if (istFileOutputMSXML()) {
        schemaId = dataComponent.getConnection().getMetadataTable().getLabel() + "String_Node_Str";
    }
    for (ColumnNameChanged col : dataComponent.getColumnNameChanged()) {
        for (Map<String, String> map : listRoot) {
            if (map.get(COLUMN).equals(schemaId + col.getOldName())) {
                map.put(COLUMN, schemaId + col.getNewName());
                flagRoot = true;
            }
        }
        for (Map<String, String> map : listGroup) {
            if (map.get(COLUMN).equals(schemaId + col.getOldName())) {
                map.put(COLUMN, schemaId + col.getNewName());
                flagGroup = true;
            }
        }
        for (Map<String, String> map : listLoop) {
            if (map.get(COLUMN).equals(schemaId + col.getOldName())) {
                map.put(COLUMN, schemaId + col.getNewName());
                flagLoop = true;
            }
        }
    }
    if (flagRoot) {
        this.getElementParameter(ROOT).setValue(listRoot);
    }
    if (flagGroup) {
        this.getElementParameter(GROUP).setValue(listGroup);
    }
    if (flagLoop) {
        this.getElementParameter(LOOP).setValue(listLoop);
    }
}

Output:
 public void metadataInputChanged(IODataComponent dataComponent, String connectionToApply) {
-    List<Map<String, String>> listRoot = (List<Map<String, String>>) this.getElementParameter(ROOT).getValue();
+    List<Map<String, String>> listRoot = new ArrayList<Map<String, String>>();
+    if (this.getElementParameter(ROOT) != null && this.getElementParameter(ROOT).getValue() != null) {
+        listRoot.addAll((List<Map<String, String>>) this.getElementParameter(ROOT).getValue());
+    }
     boolean flagRoot = false;


Input:
public String getId() {
    if (!data.containsKey(ID_KEY)) {
        data.put(ID_KEY, UUID.randomUUID().toString());
    }
    return data.get(ID_KEY);
}

Output:
     if (!data.containsKey(ID_KEY)) {
-        data.put(ID_KEY, UUID.randomUUID().toString());
+        put(ID_KEY, UUID.randomUUID().toString());
     }


Input:
public static StringFormatValidator withTranslation(final String format, final String translationFormat) {
    final StringFormatValidator result = new StringFormatValidator(format);
    final StringFormatValidator translationResult = new StringFormatValidator(translationFormat);
    try {
        result.init();
        result.validate();
    } catch (RuntimeException e) {
        if (result.isValid()) {
            result.valid = false;
            result.setDetailMessage("String_Node_Str", format, e.getMessage());
        }
    }
    try {
        translationResult.init();
        translationResult.validate();
    } catch (RuntimeException e) {
        if (translationResult.isValid()) {
            translationResult.valid = false;
            translationResult.setDetailMessage("String_Node_Str", format, e.getMessage());
        }
    }
    if (!result.isValid())
        return result;
    if (!translationResult.isValid())
        return translationResult;
    final List<StringFormatPart> initParts = sortParts(result.formats);
    final List<StringFormatPart> translationParts = sortParts(translationResult.formats);
    if (initParts.size() == translationParts.size()) {
        final Iterator<StringFormatPart> initIter = initParts.iterator();
        final Iterator<StringFormatPart> translationIter = translationParts.iterator();
        while (initIter.hasNext()) {
            final StringFormatPart initPart = initIter.next();
            final StringFormatPart translationPart = translationIter.next();
            if (initPart.conversion() != translationPart.conversion()) {
                result.valid = false;
                result.setDetailMessage("String_Node_Str", translationFormat, format);
                result.setSummaryMessage("String_Node_Str");
                break;
            }
        }
    } else {
        result.valid = false;
        result.setDetailMessage("String_Node_Str", translationFormat, format);
        result.setSummaryMessage("String_Node_Str");
    }
    return result;
}

Output:
             if (initPart.conversion() != translationPart.conversion()) {
-                result.valid = false;
-                result.setDetailMessage("String_Node_Str", translationFormat, format);
-                result.setSummaryMessage("String_Node_Str");
+                translationResult.valid = false;
+                translationResult.setDetailMessage("String_Node_Str", translationFormat, format);
+                translationResult.setSummaryMessage("String_Node_Str");
                 break;


Input:
public void setExpression(String expr) {
    ChartUIUtil.setText(control, expr);
}

Output:
 public void setExpression(String expr) {
-    ChartUIUtil.setText(control, expr);
+    if (expr != null) {
+        ChartUIUtil.setText(control, expr);
+    }
 }


Input:
public void setServerHost(String serverHost) {
    this.serverHost = serverHost;
}

Output:
 public void setServerHost(String serverHost) {
-    this.serverHost = serverHost;
+    this.metadata.put(serverHostField, serverHost);
 }


Input:
public void registerCreatureDeath(CreatureKilledByPlayerEvent event) {
    if (shouldClearDefaultDrops) {
        event.getDrops().clear();
        event.setDroppedExp(0);
    }
    if (event.getKiller().getItemInHand().getType().equals(Material.BOW) && !hasBowRewards) {
        messageManager.basicMessage(messageManager.noBowRewardMessage, event.getKiller());
        return;
    }
    if (EntityUtils.isUnderSeaLevel(event.getKiller()) && !canHuntUnderSeaLevel) {
        messageManager.basicMessage(messageManager.noBowRewardMessage, event.getKiller());
        return;
    }
    if (event.usedTamedCreature() && !isWolverineMode) {
        ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str");
        return;
    }
    if (EntityUtils.isOwner(event.getKiller(), event.getKilledCreature())) {
        ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str");
        return;
    }
    if (DependencyUtils.hasMobArena() && DependencyUtils.getMobArenaHandler().isPlayerInArena(event.getKiller()) && !hasMobArenaRewards) {
        ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str");
        return;
    }
    if (!hasCreativeModeRewards && event.getKiller().getGameMode() == GameMode.CREATIVE) {
        ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str");
        return;
    }
    if (!canCampSpawner && (campByDistance || campByEntity)) {
        if ((campByEntity && isSpawnerMob(event.getKilledCreature())) || (campByDistance && (EntityUtils.isNearSpawner(event.getKiller(), campRadius) || EntityUtils.isNearSpawner(event.getKilledCreature(), campRadius)))) {
            if (shouldClearCampDrops) {
                event.getDrops().clear();
                event.setDroppedExp(0);
            }
            messageManager.spawnerMessage(messageManager.noCampMessage, event.getKiller());
            ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str");
            return;
        }
    }
    if (!DependencyUtils.hasPermission(event.getKiller(), "String_Node_Str" + RewardType.fromEntity(event.getKilledCreature()).getName())) {
        ECLogger.getInstance().debug("String_Node_Str" + event.getKiller().getName() + "String_Node_Str" + RewardType.fromEntity(event.getKilledCreature()).getName());
        return;
    }
    if (hasReward(event.getKilledCreature())) {
        Reward reward = getRewardForEntity(event.getKilledCreature());
        if (reward.hasExp()) {
            event.setDroppedExp(reward.getExp().getAmount());
        }
        registerReward(event.getKiller(), reward, event.getWeaponName());
        try {
            List<ItemStack> rewardDrops = reward.getDropAmounts(isFixedDrops);
            if (!rewardDrops.isEmpty()) {
                if (!event.getDrops().isEmpty() && shouldOverrideDrops) {
                    event.getDrops().clear();
                }
                event.getDrops().addAll(rewardDrops);
            }
        } catch (IllegalArgumentException e) {
            ECLogger.getInstance().warning(e.getMessage());
        }
    }
}

Output:
     }
-    if (event.getKiller().getItemInHand().getType().equals(Material.BOW) && !hasBowRewards) {
+    if (EntityUtils.getItemTypeInHand(event.getKiller()).equals(Material.BOW) && !hasBowRewards) {
         messageManager.basicMessage(messageManager.noBowRewardMessage, event.getKiller());


Input:
public void addNetInternalOutMegs(Long netInternalOutMegs) {
    if (netInternalOutMegs != null) {
        this.netInternalOutMegs = this.netInternalOutMegs + netInternalOutMegs;
    }
}

Output:
 public void addNetInternalOutMegs(Long netInternalOutMegs) {
-    if (netInternalOutMegs != null) {
-        this.netInternalOutMegs = this.netInternalOutMegs + netInternalOutMegs;
-    }
+    this.netInternalOutMegs = plus(this.netInternalOutMegs, netInternalOutMegs);
 }


Input:
public void setLensDistortion(PixelTransform_F32 distToUndist) {
    this.ellipseDetector.setLensDistortion(distToUndist);
    this.ellipseRefiner.setTransform(distToUndist);
    this.intensityCheck.setTransform(distToUndist);
}

Output:
     this.ellipseDetector.setLensDistortion(distToUndist);
-    this.ellipseRefiner.setTransform(distToUndist);
+    if (this.ellipseRefiner != null)
+        this.ellipseRefiner.setTransform(distToUndist);
     this.intensityCheck.setTransform(distToUndist);


Input:
private String getExceptionStackTrace(Throwable throwable) {
    if (throwable == null) {
        return UNKNOWN;
    }
    StringBuilder stackTrace = new StringBuilder(128);
    stackTrace.append(throwable.toString()).append("String_Node_Str");
    for (StackTraceElement traceElement : throwable.getStackTrace()) {
        stackTrace.append("String_Node_Str" + traceElement.toString()).append("String_Node_Str");
    }
    return stackTrace.toString();
}

Output:
     StringBuilder stackTrace = new StringBuilder(128);
-    stackTrace.append(throwable.toString()).append("String_Node_Str");
+    stackTrace.append(throwable.toString());
+    stackTrace.append("String_Node_Str");
     for (StackTraceElement traceElement : throwable.getStackTrace()) {


Input:
private boolean times_up() {
    return (System.currentTimeMillis() - startTimeMillis) > searchTime;
}

Output:
 private boolean times_up() {
-    return (System.currentTimeMillis() - startTimeMillis) > searchTime;
+    boolean timesUp = (System.currentTimeMillis() - startTimeMillis) > searchTime;
+    return timesUp;
 }


Input:
public String getName() {
    if (name == null)
        name = remoteCommit.getShortMessage();
    return name;
}

Output:
     if (name == null)
-        name = remoteCommit.getShortMessage();
+        name = baseCommit.getShortMessage();
     return name;


Input:
private void replaceValues(ByteBuffer buffer, Dimension bufferSize, Rectangle replaceRegion, int bufferBandCount, int bufferType, int bufferTypeSize, boolean floatingPoint, MinMaxArray[] minMaxs, NullableNumberArray replacement, NullableNumberArray otherwise) throws TilerException {
    if (minMaxs == null || minMaxs.length == 0)
        return;
    if (replacement == null && otherwise == null)
        return;
    for (int i = 0; i < minMaxs.length; i++) if (minMaxs[i].length() != bufferBandCount)
        throw new IllegalArgumentException("String_Node_Str");
    if ((replacement != null && replacement.length() != bufferBandCount) || (otherwise != null && otherwise.length() != bufferBandCount))
        throw new IllegalArgumentException("String_Node_Str");
    boolean allNull = true;
    for (int b = 0; b < bufferBandCount; b++) {
        if ((replacement != null && replacement.getDouble(b) != null) || (otherwise != null && otherwise.getDouble(b) != null)) {
            allNull = false;
            break;
        }
    }
    if (allNull) {
        return;
    }
    double[] doubleValues = new double[bufferBandCount];
    long[] longValues = new long[bufferBandCount];
    int[] indices = new int[bufferBandCount];
    for (int y = replaceRegion.y; y < replaceRegion.height; y++) {
        for (int x = replaceRegion.x; x < replaceRegion.width; x++) {
            boolean between = false;
            for (int b = 0; b < bufferBandCount; b++) {
                indices[b] = getBufferIndex(x, y, b, bufferSize.width, bufferSize.height) * bufferTypeSize;
                if (floatingPoint)
                    doubleValues[b] = getDoubleValue(indices[b], buffer, bufferType);
                else
                    longValues[b] = getLongValue(indices[b], buffer, bufferType);
            }
            for (int i = 0; i < minMaxs.length; i++) {
                if (minMaxs[i] != null) {
                    if (floatingPoint)
                        between = minMaxs[i].isBetweenDouble(doubleValues);
                    else
                        between = minMaxs[i].isBetweenLong(longValues);
                    if (between)
                        break;
                }
            }
            NullableNumberArray values = between ? replacement : otherwise;
            if (values != null) {
                for (int b = 0; b < bufferBandCount; b++) {
                    if (values.getDouble(b) != null) {
                        if (floatingPoint)
                            putDoubleValue(indices[b], buffer, bufferType, values.getDouble(b));
                        else
                            putLongValue(indices[b], buffer, bufferType, values.getLong(b));
                    }
                }
            }
        }
    }
}

Output:
     int[] indices = new int[bufferBandCount];
-    for (int y = replaceRegion.y; y < replaceRegion.height; y++) {
-        for (int x = replaceRegion.x; x < replaceRegion.width; x++) {
+    for (int y = replaceRegion.y; y < replaceRegion.y + replaceRegion.height; y++) {
+        for (int x = replaceRegion.x; x < replaceRegion.x + replaceRegion.width; x++) {
             boolean between = false;


Input:
public void widgetSelected(SelectionEvent e) {
    formatCode.setText(provider.getPattern(((TableItem) e.item).getText(FORMAT_TYPE_INDEX)));
    updatePreview();
    notifyFormatChange();
}

Output:
 public void widgetSelected(SelectionEvent e) {
-    formatCode.setText(provider.getPattern(((TableItem) e.item).getText(FORMAT_TYPE_INDEX)));
+    formatCode.setText(((TableItem) e.item).getText(FORMAT_CODE_INDEX));
     updatePreview();


Input:
public void stop() {
    List<Runnable> pending = eventHandlerPool.shutdownNow();
    if (pending != null && !pending.isEmpty()) {
        StringBuilder pendingMsg = new StringBuilder("String_Node_Str");
        for (Runnable handler : pending) {
            if (handler instanceof EventHandler) {
                pendingMsg.append(((EventHandler) handler).event.getEventId()).append("String_Node_Str");
            }
        }
        LOG.info("String_Node_Str" + pending.size() + "String_Node_Str");
        LOG.info(pendingMsg.toString());
    }
    super.stop();
    LOG.info("String_Node_Str");
}

Output:
 public void stop() {
-    List<Runnable> pending = eventHandlerPool.shutdownNow();
-    if (pending != null && !pending.isEmpty()) {
-        StringBuilder pendingMsg = new StringBuilder("String_Node_Str");
-        for (Runnable handler : pending) {
-            if (handler instanceof EventHandler) {
-                pendingMsg.append(((EventHandler) handler).event.getEventId()).append("String_Node_Str");
+    if (eventHandlerPool != null) {
+        List<Runnable> pending = eventHandlerPool.shutdownNow();
+        if (pending != null && !pending.isEmpty()) {
+            StringBuilder pendingMsg = new StringBuilder("String_Node_Str");
+            for (Runnable handler : pending) {
+                if (handler instanceof EventHandler) {
+                    pendingMsg.append(((EventHandler) handler).event.getEventId()).append("String_Node_Str");
+                }
             }


Input:
public void defineDataSet(DataSetHandle dataSet) {
    DataSourceHandle dataSource = dataSet.getDataSource();
    ModelDteApiAdapter adaptor = new ModelDteApiAdapter(context, context.getSharedScope());
    try {
        if (dataSource != null) {
            doDefineDataSource(adaptor, dataSource);
        }
        doDefineDataSet(adaptor, dataSet);
    } catch (BirtException e) {
        logger.log(Level.SEVERE, e.getMessage());
    }
}

Output:
     try {
-        if (dataSource != null) {
-            doDefineDataSource(adaptor, dataSource);
-        }
-        doDefineDataSet(adaptor, dataSet);
+        adapter.defineDataSet(dataSet, dteEngine);
     } catch (BirtException e) {


Input:
private void replaceBasicOrCustomValidationRules(INode graphicalNode, IConnection connection, ValidationRulesConnection rulesConnection, boolean isCustom, boolean isOutput) {
    INode node = getApplicableNode(connection, isOutput);
    INode endNode = null;
    if (!checkTriggerAndDBSettings(node, rulesConnection, isOutput)) {
        return;
    }
    DataNode nodeUseValidationRule = (DataNode) node;
    endNode = nodeUseValidationRule;
    DataNode filterNode = null;
    List<IConnection> validRuleConnections;
    List<? extends IConnection> mainConnections;
    IMetadataTable rejectMetadataTable = null;
    DataConnection dataConnection = null;
    if (isOutput) {
        validRuleConnections = (List<IConnection>) nodeUseValidationRule.getIncomingConnections();
        mainConnections = nodeUseValidationRule.getIncomingConnections("String_Node_Str");
    } else {
        validRuleConnections = (List<IConnection>) nodeUseValidationRule.getOutgoingConnections();
        mainConnections = nodeUseValidationRule.getOutgoingConnections("String_Node_Str");
    }
    if (validRuleConnections == null || validRuleConnections.size() == 0)
        return;
    if (mainConnections != null && mainConnections.size() > 0) {
        dataConnection = (DataConnection) mainConnections.get(0);
    }
    if (dataConnection != null) {
        validRuleConnections.remove(dataConnection);
    }
    IComponent component = ComponentsFactoryProvider.getInstance().get("String_Node_Str");
    String typeStr;
    if (isOutput) {
        typeStr = "String_Node_Str";
    } else {
        typeStr = "String_Node_Str";
    }
    String uniqueName = component.getName() + "String_Node_Str" + typeStr;
    if (dataConnection != null) {
        uniqueName += "String_Node_Str" + dataConnection.getName();
    }
    filterNode = new DataNode(component, uniqueName);
    filterNode.setActivate(connection.isActivate());
    filterNode.setStart(false);
    filterNode.setDesignSubjobStartNode(null);
    IMetadataTable filterNodeMetadataTable = null;
    if (dataConnection != null) {
        if (dataConnection.getMetadataTable() != null) {
            filterNodeMetadataTable = dataConnection.getMetadataTable();
        }
    } else {
        List<IMetadataTable> metadatas = nodeUseValidationRule.getMetadataList();
        if (metadatas != null && metadatas.size() > 0) {
            for (IMetadataTable metadataTable : metadatas) {
                if ("String_Node_Str".equals(metadataTable.getAttachedConnector())) {
                    filterNodeMetadataTable = metadataTable;
                    break;
                }
            }
        }
    }
    if (filterNodeMetadataTable != null) {
        IMetadataTable newMetadata = filterNodeMetadataTable.clone();
        newMetadata.setTableName(uniqueName);
        filterNode.getMetadataList().remove(0);
        filterNode.getMetadataList().add(newMetadata);
    }
    filterNode.setSubProcessStart(false);
    filterNode.setProcess(node.getProcess());
    filterNode.setElementParameters(component.createElementParameters(filterNode));
    updateFilterParametersWithValidRuleConnection(filterNode, rulesConnection, isCustom);
    List<IConnection> outgoingConnections = new ArrayList<IConnection>();
    List<IConnection> incomingConnections = new ArrayList<IConnection>();
    filterNode.setIncomingConnections(incomingConnections);
    filterNode.setOutgoingConnections(outgoingConnections);
    addDataNode(filterNode);
    List<? extends INodeConnector> connectors = nodeUseValidationRule.getListConnector();
    INodeConnector rejectConnector = null;
    for (INodeConnector connector : connectors) {
        if ("String_Node_Str".equals(connector.getName())) {
            rejectConnector = connector;
            break;
        }
    }
    ((List<INodeConnector>) filterNode.getListConnector()).add(rejectConnector);
    List<IMetadataTable> metadataList = nodeUseValidationRule.getMetadataList();
    for (IMetadataTable metadataTable : metadataList) {
        if ("String_Node_Str".equals(metadataTable.getTableName()) && !filterNode.getMetadataList().contains(metadataTable)) {
            rejectMetadataTable = metadataTable;
            filterNode.getMetadataList().add(metadataTable);
            break;
        }
    }
    if (dataConnection != null) {
        if (isOutput) {
            incomingConnections.add(dataConnection);
            dataConnection.setTarget(filterNode);
        } else {
            outgoingConnections.add(dataConnection);
            dataConnection.setSource(filterNode);
            dataConnection.setTarget(connection.getTarget());
            dataConnection.setConnectorName("String_Node_Str");
        }
    }
    DataConnection dataConnec = new DataConnection();
    dataConnec.setActivate(connection.isActivate());
    dataConnec.setLineStyle(EConnectionType.FLOW_MAIN);
    dataConnec.setTraceConnection(connection.isTraceConnection());
    dataConnec.setTracesCondition(connection.getTracesCondition());
    dataConnec.setEnabledTraceColumns(connection.getEnabledTraceColumns());
    dataConnec.setMonitorConnection(connection.isMonitorConnection());
    if (!nodeUseValidationRule.getMetadataList().isEmpty()) {
        dataConnec.setMetadataTable(nodeUseValidationRule.getMetadataList().get(0));
    }
    if (isOutput) {
        dataConnec.setConnectorName("String_Node_Str");
        dataConnec.setName("String_Node_Str" + nodeUseValidationRule.getUniqueName());
        dataConnec.setSource(filterNode);
        dataConnec.setTarget(nodeUseValidationRule);
        outgoingConnections.add(dataConnec);
    } else {
        dataConnec.setConnectorName("String_Node_Str");
        dataConnec.setName("String_Node_Str" + nodeUseValidationRule.getUniqueName());
        dataConnec.setSource(nodeUseValidationRule);
        dataConnec.setTarget(filterNode);
        incomingConnections.add(dataConnec);
    }
    validRuleConnections.add(dataConnec);
    if (endNode.getOutgoingConnections("String_Node_Str") != null && endNode.getOutgoingConnections("String_Node_Str").size() == 1) {
        IConnection conn = endNode.getOutgoingConnections("String_Node_Str").get(0);
        INode targetNode = conn.getTarget();
        List<IConnection> outputconns = (List<IConnection>) endNode.getOutgoingConnections();
        List<IConnection> inputconnns = (List<IConnection>) targetNode.getIncomingConnections();
        outputconns.remove(conn);
        inputconnns.remove(conn);
        DataConnection rejectLink = new DataConnection();
        rejectLink.setActivate(connection.isActivate());
        rejectLink.setLineStyle(EConnectionType.FLOW_MAIN);
        rejectLink.setMetadataTable(rejectMetadataTable);
        rejectLink.setConnectorName("String_Node_Str");
        rejectLink.setName(conn.getName());
        rejectLink.setSource(filterNode);
        rejectLink.setTarget(targetNode);
        ((List<IConnection>) filterNode.getOutgoingConnections()).add(rejectLink);
        ((List<IConnection>) targetNode.getIncomingConnections()).add(rejectLink);
    }
}

Output:
     }
-    if (validRuleConnections == null || validRuleConnections.size() == 0)
+    if (validRuleConnections == null || validRuleConnections.size() == 0) {
         return;


Input:
public void run() {
    while (true) {
        Connection connection = null;
        Call c = null;
        try {
            try {
                c = queue.take();
                callMap.put(c.getId(), c);
                connection = connectionManager.getConnection();
                writer.write(connection, c.getRequest());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (IOException io) {
            io.printStackTrace();
            connectionManager.destroyConnection(connection);
            continue;
        }
    }
}

Output:
                 connection = connectionManager.getConnection();
-                writer.write(connection, c.getRequest());
+                if (connection != null) {
+                    writer.write(connection, c.getRequest());
+                }
             } catch (InterruptedException e) {


Input:
public static String summarizeUnitCategories() {
    synchronized (_indexTable) {
        return "String_Node_Str" + categories + _categoryList.toString();
    }
}

Output:
     synchronized (_indexTable) {
-        return "String_Node_Str" + categories + _categoryList.toString();
+        return "String_Node_Str" + _categories + "String_Node_Str" + _categoryList.toString();
     }


Input:
public Object createWebSocket(UpgradeRequest req, UpgradeResponse resp) {
    return new DataHubWebSocket(subscriptionDispatcher);
}

Output:
 public Object createWebSocket(UpgradeRequest req, UpgradeResponse resp) {
-    return new DataHubWebSocket(subscriptionDispatcher);
+    return new DataHubWebSocket(subscriptions);
 }


Input:
public List<Account> getMembers() throws AccountNotFoundException, OrganizationNotFoundException, AccessRightException {
    Organization organization = this.getOrganizationOfCurrentUser();
    return organization.getMembers();
}

Output:
     Organization organization = this.getOrganizationOfCurrentUser();
-    return organization.getMembers();
+    List<Account> accounts = organization.getMembers();
+    AccountDTO[] dtos = new AccountDTO[accounts.size()];
+    for (int i = 0; i < accounts.size(); i++) {
+        dtos[i] = mapper.map(accounts.get(i), AccountDTO.class);
+    }
+    return dtos;
 }


Input:
public void end() throws SAXException {
    makeTestExpressionCompatible();
    Set elements = handler.tempValue.keySet();
    ContainerSlot groups = element.getSlot(ListingElement.GROUP_SLOT);
    for (int i = 0; i < groups.getCount(); i++) {
        GroupElement group = (GroupElement) groups.getContent(i);
        handler.getModule().getNameManager().makeUniqueName(group);
        String groupName = (String) group.getLocalProperty(handler.getModule(), GroupElement.GROUP_NAME_PROP);
        if (!elements.contains(group))
            continue;
        List columns = (List) handler.tempValue.get(group);
        if (columns == null || columns.isEmpty())
            continue;
        List tmpList = (List) element.getLocalProperty(handler.module, ListingElement.BOUND_DATA_COLUMNS_PROP);
        if (tmpList == null) {
            tmpList = new ArrayList();
            element.setProperty(ListingElement.BOUND_DATA_COLUMNS_PROP, tmpList);
        }
        for (int j = 0; j < columns.size(); j++) {
            ComputedColumn column = (ComputedColumn) columns.get(j);
            column.setAggregrateOn(groupName);
            ComputedColumn foundColumn = checkMatchedBoundColumnForGroup(tmpList, column.getExpression(), column.getAggregrateOn());
            if (foundColumn == null || !foundColumn.getName().equals(column.getName())) {
                String newName = getUniqueBoundColumnNameForGroup(tmpList, column);
                column.setName(newName);
                tmpList.add(column);
            }
        }
        reCheckResultSetColumnName(group, tmpList);
    }
    super.end();
}

Output:
         }
-        for (int j = 0; j < columns.size(); j++) {
-            ComputedColumn column = (ComputedColumn) columns.get(j);
-            column.setAggregrateOn(groupName);
-            ComputedColumn foundColumn = checkMatchedBoundColumnForGroup(tmpList, column.getExpression(), column.getAggregrateOn());
-            if (foundColumn == null || !foundColumn.getName().equals(column.getName())) {
-                String newName = getUniqueBoundColumnNameForGroup(tmpList, column);
-                column.setName(newName);
-                tmpList.add(column);
-            }
+        if (StringUtil.compareVersion(handler.getVersion(), "String_Node_Str") <= 0) {
+            addCachedListWithAggregateOnToListing(columns, tmpList, group, groupName);
+            continue;
         }


Input:
void destroy() {
    try {
        for (Connection c : queue) {
            c.close().markForRecycle(true);
        }
        queue.clear();
    } catch (IOException ignored) {
    }
    queues.remove(this);
}

Output:
 void destroy() {
-    try {
-        for (Connection c : queue) {
-            c.close().markForRecycle(true);
-        }
-        queue.clear();
-    } catch (IOException ignored) {
+    for (Connection c : queue) {
+        c.close().markForRecycle(true);
     }


Input:
public Object[] getElements(Object inputElement) {
    return new Object[] { getDateTypeNames(getLevelTypesByDateType()).get(0) };
}

Output:
 public Object[] getElements(Object inputElement) {
-    return new Object[] { getDateTypeNames(getLevelTypesByDateType()).get(0) };
+    if (getLevelTypesByDateType() != null && getLevelTypesByDateType().length > 0)
+        return new Object[] { getDateTypeNames(getLevelTypesByDateType()).get(0) };
+    return new Object[0];
 }


Input:
public String callerBaseDn() {
    return null;
}

Output:
 public String callerBaseDn() {
-    return null;
+    return (overrides != null && overrides.containsKey("String_Node_Str")) ? (String) overrides.get("String_Node_Str") : "String_Node_Str";
 }


Input:
public void setMode(int mode, IBinder cb) {
    if (!checkAudioSettingsPermission("String_Node_Str")) {
        return;
    }
    if (mode < AudioSystem.MODE_CURRENT || mode > AudioSystem.MODE_IN_CALL) {
        return;
    }
    synchronized (mSettingsLock) {
        if (mode == AudioSystem.MODE_CURRENT) {
            mode = mMode;
        }
        if (mode != mMode) {
            if (AudioSystem.setPhoneState(mode) == AudioSystem.AUDIO_STATUS_OK) {
                checkForUndispatchedAudioFocusChange(mMode, mode);
                mMode = mode;
                synchronized (mSetModeDeathHandlers) {
                    SetModeDeathHandler hdlr = null;
                    Iterator iter = mSetModeDeathHandlers.iterator();
                    while (iter.hasNext()) {
                        SetModeDeathHandler h = (SetModeDeathHandler) iter.next();
                        if (h.getBinder() == cb) {
                            hdlr = h;
                            iter.remove();
                            break;
                        }
                    }
                    if (hdlr == null) {
                        hdlr = new SetModeDeathHandler(cb);
                        if (cb != null) {
                            try {
                                cb.linkToDeath(hdlr, 0);
                            } catch (RemoteException e) {
                                Log.w(TAG, "String_Node_Str" + cb + "String_Node_Str");
                            }
                        }
                    }
                    mSetModeDeathHandlers.add(0, hdlr);
                    hdlr.setMode(mode);
                }
                if (mode != AudioSystem.MODE_NORMAL) {
                    clearAllScoClients();
                }
            }
        }
        int streamType = getActiveStreamType(AudioManager.USE_DEFAULT_STREAM_TYPE);
        int index = mStreamStates[STREAM_VOLUME_ALIAS[streamType]].mIndex;
        setStreamVolumeInt(STREAM_VOLUME_ALIAS[streamType], index, true, true);
    }
}

Output:
         int index = mStreamStates[STREAM_VOLUME_ALIAS[streamType]].mIndex;
-        setStreamVolumeInt(STREAM_VOLUME_ALIAS[streamType], index, true, true);
+        setStreamVolumeInt(STREAM_VOLUME_ALIAS[streamType], index, true, false);
     }


Input:
public Object toMongoObject(MappedField mf, MappedClass mc, Object value) {
    Object mappedValue = value;
    if ((mf != null && (mf.hasAnnotation(Reference.class) || mf.getType().isAssignableFrom(Key.class) || mf.getType().isAssignableFrom(DBRef.class))) || (mc != null && mc.getEntityAnnotation() != null)) {
        try {
            Key<?> k = (value instanceof Key) ? (Key<?>) value : getKey(value);
            mappedValue = keyToRef(k);
        } catch (Exception e) {
            log.debug("String_Node_Str" + value + "String_Node_Str", e);
            mappedValue = toMongoObject(value, false);
        }
    } else if (mf != null && mf.hasAnnotation(Serialized.class))
        try {
            mappedValue = Serializer.serialize(value, !mf.getAnnotation(Serialized.class).disableCompression());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    else if (value instanceof DBObject)
        mappedValue = value;
    else {
        mappedValue = toMongoObject(value, EmbeddedMapper.shouldSaveClassName(value, mappedValue, mf));
        if (mappedValue instanceof DBObject && !EmbeddedMapper.shouldSaveClassName(value, mappedValue, mf))
            ((DBObject) mappedValue).removeField(CLASS_NAME_FIELDNAME);
    }
    return mappedValue;
}

Output:
     Object mappedValue = value;
-    if ((mf != null && (mf.hasAnnotation(Reference.class) || mf.getType().isAssignableFrom(Key.class) || mf.getType().isAssignableFrom(DBRef.class))) || (mc != null && mc.getEntityAnnotation() != null)) {
+    if ((mf != null && (mf.hasAnnotation(Reference.class) || mf.getType().isAssignableFrom(Key.class) || mf.getType().isAssignableFrom(DBRef.class) || (value instanceof Iterable && (mf.getSubClass().isAssignableFrom(Key.class) || mf.getSubClass().isAssignableFrom(DBRef.class))))) || (mc != null && mc.getEntityAnnotation() != null)) {
         try {


Input:
public double inner(Vector vector) {
    checkVectorSize(vector);
    double result = 0;
    if (vector.type() != VectorType.SPARSE) {
        for (int key : hashMap.keys().elements()) {
            result += hashMap.get(key) * vector.get(key);
        }
    } else {
        if (this.numberOfNonzeroElements() <= vector.numberOfNonzeroElements()) {
            for (int key : hashMap.keys().elements()) {
                if (((SparseVector) vector).hashMap.containsKey(key)) {
                    result += hashMap.get(key) * vector.get(key);
                }
            }
        } else {
            for (int key : ((SparseVector) vector).hashMap.keys().elements()) {
                if (hashMap.containsKey(key)) {
                    result += hashMap.get(key) * vector.get(key);
                }
            }
        }
    }
    return result;
}

Output:
     } else {
-        if (this.numberOfNonzeroElements() <= vector.numberOfNonzeroElements()) {
+        if (this.cardinality() <= vector.cardinality()) {
             for (int key : hashMap.keys().elements()) {


Input:
public final No_comma_or_semicolonContext no_comma_or_semicolon() throws RecognitionException {
    No_comma_or_semicolonContext _localctx = new No_comma_or_semicolonContext(_ctx, getState());
    enterRule(_localctx, 40, RULE_no_comma_or_semicolon);
    int _la;
    try {
        enterOuterAlt(_localctx, 1);
        {
            setState(242);
            _la = _input.LA(1);
            if (_la <= 0 || (_la == 26 || _la == 45)) {
                _errHandler.recoverInline(this);
            }
            consume();
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

Output:
             _la = _input.LA(1);
-            if (_la <= 0 || (_la == 26 || _la == 45)) {
+            if (_la <= 0 || (_la == 27 || _la == 46)) {
                 _errHandler.recoverInline(this);


Input:
public String getDisplayText(Object element) {
    if (element instanceof Object[]) {
        if (element instanceof Operator[]) {
            if (element == OPERATORS_ASSIGNMENT) {
                return DISPLAY_TEXT_ASSIGNMENT;
            } else if (element == OPERATORS_COMPARISON) {
                return DISPLAY_TEXT_COMPARISON;
            } else if (element == OPERATORS_COMPUTATIONAL) {
                return DISPLAY_TEXT_COMPUTATIONAL;
            } else if (element == OPERATORS_LOGICAL) {
                return DISPLAY_TEXT_LOGICAL;
            }
        } else if (element instanceof ILocalizableInfo[]) {
            ILocalizableInfo info = ((ILocalizableInfo[]) element)[1];
            StringBuffer displayText = new StringBuffer(info.getName());
            if (info instanceof IMethodInfo) {
                IMethodInfo method = (IMethodInfo) info;
                displayText.append("String_Node_Str");
                displayText.append("String_Node_Str");
                displayText.append(method.getReturnType());
            }
            return displayText.toString();
        }
        return ALL;
    } else if (element instanceof String) {
        return (String) element;
    } else if (element instanceof Operator) {
        return ((Operator) element).symbol;
    } else if (element instanceof ParameterHandle) {
        return ((ParameterHandle) element).getName();
    } else if (element instanceof DataSetHandle) {
        return ((DataSetHandle) element).getName();
    } else if (element instanceof DataSetItemModel) {
        return ((DataSetItemModel) element).getName();
    }
    return element.toString();
}

Output:
         return ((Operator) element).symbol;
-    } else if (element instanceof ParameterHandle) {
-        return ((ParameterHandle) element).getName();
-    } else if (element instanceof DataSetHandle) {
-        return ((DataSetHandle) element).getName();
+    } else if (element instanceof DesignElementHandle) {
+        return ((DesignElementHandle) element).getName();
     } else if (element instanceof DataSetItemModel) {


Input:
private static List<Integer> getCommonArtifactIds() throws OseeCoreException {
    OseeConnection connection = ConnectionHandler.getConnection();
    IOseeStatement chStmt = ConnectionHandler.getStatement(connection);
    List<Integer> artIds = new ArrayList<Integer>();
    ElapsedTime time = new ElapsedTime("String_Node_Str");
    try {
        chStmt.runPreparedQuery(SELECT_COMMON_ART_IDS, new Object[] { AtsUtilCore.getAtsBranch().getUuid() });
        while (chStmt.next()) {
            artIds.add(chStmt.getInt(1));
        }
    } finally {
        chStmt.close();
        connection.close();
    }
    time.end();
    return artIds;
}

Output:
     List<Integer> artIds = new ArrayList<Integer>();
-    ElapsedTime time = new ElapsedTime("String_Node_Str");
+    xResultData.log(null, "String_Node_Str" + DateUtil.getMMDDYYHHMM());
     try {


Input:
protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buf) throws Exception {
    if (buf.readableBytes() < 2) {
        return null;
    }
    int index = buf.indexOf(buf.readerIndex() + 1, buf.writerIndex(), (byte) 0xC0);
    if (index != -1) {
        return buf.readBytes(index + 1 - buf.readerIndex());
    }
    return null;
}

Output:
     if (index != -1) {
-        return buf.readBytes(index + 1 - buf.readerIndex());
+        ChannelBuffer result = ChannelBuffers.buffer(index + 1 - buf.readerIndex());
+        while (buf.readerIndex() <= index) {
+            int b = buf.readUnsignedByte();
+            if (b == 0xDB) {
+                int ext = buf.readUnsignedByte();
+                if (ext == 0xDC) {
+                    result.writeByte(0xC0);
+                } else if (ext == 0xDD) {
+                    result.writeByte(0xDB);
+                }
+            } else {
+                result.writeByte(b);
+            }
+        }
+        return result;
     }


Input:
public void updateTimesheetLine(TSTimer tsTimer) {
    TimesheetLine timesheetLine = tsTimer.getTimeSheetLine();
    timesheetLine.setProjectTask(tsTimer.getProjectTask());
    timesheetLine.setProduct(tsTimer.getProduct());
    timesheetLine.setDurationStored(BigDecimal.valueOf(tsTimer.getDuration() / 3600));
    timesheetLine.setComments(tsTimer.getComments());
    Beans.get(TimesheetLineRepository.class).save(timesheetLine);
}

Output:
 public void updateTimesheetLine(TSTimer tsTimer) {
-    TimesheetLine timesheetLine = tsTimer.getTimeSheetLine();
+    TimesheetLine timesheetLine = tsTimer.getTimesheetLine();
     timesheetLine.setProjectTask(tsTimer.getProjectTask());


Input:
private static boolean isTooComplexToInline(List<JExpression> bodyAsExpressionList, boolean ignoringReturn) {
    if (ignoringReturn) {
        return bodyAsExpressionList.size() > 2;
    }
    if (bodyAsExpressionList.size() == 3 && bodyAsExpressionList.get(2).hasSideEffects()) {
        return true;
    }
    return false;
}

Output:
 private static boolean isTooComplexToInline(List<JExpression> bodyAsExpressionList, boolean ignoringReturn) {
-    if (ignoringReturn) {
-        return bodyAsExpressionList.size() > 2;
+    if (bodyAsExpressionList.size() > 3) {
+        return true;
     }


Input:
protected UniversalDate fromMillis(long millisFromJavaEpoch) {
    long millisFromMinDay = millisFromJavaEpoch - MIN_MILLIS_FROM_JAVA_EPOCH;
    long daysFromMinDay = millisFromMinDay / AbstractUniversalDateWidget.MILLIS_IN_DAY;
    int days = 0;
    for (int year = MIN_YEAR; year <= MAX_YEAR; year++) {
        int[] monthsInYear = NEPALI_YEAR_MONTHS.get(year);
        for (int month = 1; month <= 12; month++) {
            int daysInMonth = monthsInYear[month];
            for (int day = 1; day <= daysInMonth; day++) {
                days++;
                if (days == daysFromMinDay) {
                    return new UniversalDate(year, month, day, millisFromJavaEpoch);
                }
            }
        }
    }
    throw new RuntimeException("String_Node_Str");
}

Output:
     long daysFromMinDay = millisFromMinDay / AbstractUniversalDateWidget.MILLIS_IN_DAY;
-    int days = 0;
+    int days = -1;
     for (int year = MIN_YEAR; year <= MAX_YEAR; year++) {


Input:
public ScribNode leaveProjectedRoleDeclFixing(ScribNode parent, ScribNode child, ProjectedRoleDeclFixer fixer, ScribNode visited) throws ScribbleException {
    LDo ld = (LDo) visited;
    LProtocolDecl lpd = ld.getTargetProtocolDecl(fixer.getJobContext(), fixer.getModuleContext());
    Iterator<Role> roleargs = ld.roles.args.stream().map((ra) -> ra.val.toName()).collect(Collectors.toList()).iterator();
    Map<Role, Role> rolemap = lpd.header.roledecls.getRoles().stream().collect(Collectors.toMap((r) -> r, (r) -> roleargs.next()));
    Set<Role> occs = ((LProtocolDeclDel) lpd.del()).getProtocolDeclContext().getRoleOccurrences().stream().map((r) -> rolemap.get(r)).collect(Collectors.toSet());
    List<RoleArg> ras = ld.roles.args.stream().filter((ra) -> occs.contains(ra.val.toName())).collect(Collectors.toList());
    RoleArgList roles = ld.roles.reconstruct(ras);
    return super.leaveProjectedRoleDeclFixing(parent, child, fixer, ld.reconstruct(roles, ld.args, ld.getProtocolNameNode()));
}

Output:
     Iterator<Role> roleargs = ld.roles.args.stream().map((ra) -> ra.val.toName()).collect(Collectors.toList()).iterator();
-    Map<Role, Role> rolemap = lpd.header.roledecls.getRoles().stream().collect(Collectors.toMap((r) -> r, (r) -> roleargs.next()));
+    JobContext jcontext = fixer.getJobContext();
+    ModuleContext mcontext = fixer.getModuleContext();
+    String mname = ld.getTargetFullProtocolName(mcontext).getPrefix().toString();
+    mname = mname.substring(0, mname.lastIndexOf('_'));
+    mname = mname.substring(0, mname.lastIndexOf('_'));
+    String simppn = ld.getTargetFullProtocolName(mcontext).getLastElement();
+    simppn = simppn.substring(0, simppn.lastIndexOf('_'));
+    ModuleName modname;
+    if (mname.indexOf('.') == -1) {
+        modname = new ModuleName(mname);
+    } else {
+        String[] elems = mname.split("String_Node_Str");
+        PackageName packname = new PackageName(Arrays.copyOf(elems, elems.length - 1));
+        modname = new ModuleName(packname, new ModuleName(elems[elems.length - 1]));
+    }
+    GProtocolDecl gpd = (GProtocolDecl) jcontext.getModule(modname).getProtocolDecl(new GProtocolName(simppn));
+    Map<Role, Role> rolemap = gpd.header.roledecls.getRoles().stream().collect(Collectors.toMap((r) -> r, (r) -> roleargs.next()));
     Set<Role> occs = ((LProtocolDeclDel) lpd.del()).getProtocolDeclContext().getRoleOccurrences().stream().map((r) -> rolemap.get(r)).collect(Collectors.toSet());


Input:
public void init() throws ComponentInitException {
    atomicConcepts = new TreeSet<NamedClass>(conceptComparator);
    atomicRoles = new TreeSet<ObjectProperty>(roleComparator);
    datatypeProperties = new TreeSet<DatatypeProperty>();
    booleanDatatypeProperties = new TreeSet<DatatypeProperty>();
    doubleDatatypeProperties = new TreeSet<DatatypeProperty>();
    intDatatypeProperties = new TreeSet<DatatypeProperty>();
    stringDatatypeProperties = new TreeSet<DatatypeProperty>();
    individuals = new TreeSet<Individual>();
    manager = OWLManager.createOWLOntologyManager();
    Comparator<OWLNamedObject> namedObjectComparator = new Comparator<OWLNamedObject>() {
        public int compare(OWLNamedObject o1, OWLNamedObject o2) {
            return o1.getIRI().compareTo(o2.getIRI());
        }
    };
    Set<OWLClass> classes = new TreeSet<OWLClass>(namedObjectComparator);
    Set<OWLObjectProperty> owlObjectProperties = new TreeSet<OWLObjectProperty>(namedObjectComparator);
    Set<OWLDataProperty> owlDatatypeProperties = new TreeSet<OWLDataProperty>(namedObjectComparator);
    Set<OWLNamedIndividual> owlIndividuals = new TreeSet<OWLNamedIndividual>(namedObjectComparator);
    Set<OWLOntology> allImports = new HashSet<OWLOntology>();
    prefixes = new TreeMap<String, String>();
    Set<OWLImportsDeclaration> directImports = new HashSet<OWLImportsDeclaration>();
    for (AbstractKnowledgeSource source : sources) {
        if (source instanceof OWLFile || source instanceof SparqlKnowledgeSource || source instanceof OWLAPIOntology) {
            URL url = null;
            if (source instanceof OWLFile) {
                url = ((OWLFile) source).getURL();
            }
            try {
                if (source instanceof OWLAPIOntology) {
                    ontology = ((OWLAPIOntology) source).getOWLOntolgy();
                    manager = ontology.getOWLOntologyManager();
                } else if (source instanceof SparqlKnowledgeSource) {
                    ontology = ((SparqlKnowledgeSource) source).getOWLAPIOntology();
                    manager = ontology.getOWLOntologyManager();
                } else {
                    ontology = manager.loadOntologyFromOntologyDocument(IRI.create(url.toURI()));
                }
                owlAPIOntologies.add(ontology);
                directImports.addAll(ontology.getImportsDeclarations());
                try {
                    Set<OWLOntology> imports = manager.getImportsClosure(ontology);
                    allImports.addAll(imports);
                    for (OWLOntology ont : imports) {
                        classes.addAll(ont.getClassesInSignature());
                        owlObjectProperties.addAll(ont.getObjectPropertiesInSignature());
                        owlDatatypeProperties.addAll(ont.getDataPropertiesInSignature());
                        owlIndividuals.addAll(ont.getIndividualsInSignature());
                    }
                } catch (UnknownOWLOntologyException uooe) {
                    logger.error("String_Node_Str");
                }
                OWLOntologyFormat format = manager.getOntologyFormat(ontology);
                if (format instanceof PrefixOWLOntologyFormat) {
                    prefixes.putAll(((PrefixOWLOntologyFormat) format).getPrefixName2PrefixMap());
                    baseURI = ((PrefixOWLOntologyFormat) format).getDefaultPrefix();
                    prefixes.remove("String_Node_Str");
                }
            } catch (OWLOntologyCreationException e) {
                e.printStackTrace();
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
        } else {
            KB kb = source.toKB();
            IRI ontologyURI = IRI.create("String_Node_Str");
            ontology = null;
            try {
                ontology = manager.createOntology(ontologyURI);
            } catch (OWLOntologyCreationException e) {
                e.printStackTrace();
            }
            OWLAPIAxiomConvertVisitor.fillOWLOntology(manager, ontology, kb);
            owlAPIOntologies.add(ontology);
            allImports.add(ontology);
            atomicConcepts.addAll(kb.findAllAtomicConcepts());
            atomicRoles.addAll(kb.findAllAtomicRoles());
            individuals.addAll(kb.findAllIndividuals());
        }
    }
    try {
        ontology = manager.createOntology(IRI.create("String_Node_Str"), new HashSet<OWLOntology>(owlAPIOntologies));
        List<OWLOntologyChange> addImports = new ArrayList<OWLOntologyChange>();
        for (OWLImportsDeclaration i : directImports) {
            addImports.add(new AddImport(ontology, i));
        }
        manager.applyChanges(addImports);
    } catch (OWLOntologyCreationException e1) {
        e1.printStackTrace();
    }
    ReasonerProgressMonitor progressMonitor = new NullReasonerProgressMonitor();
    FreshEntityPolicy freshEntityPolicy = FreshEntityPolicy.ALLOW;
    long timeOut = Integer.MAX_VALUE;
    IndividualNodeSetPolicy individualNodeSetPolicy = IndividualNodeSetPolicy.BY_NAME;
    OWLReasonerConfiguration conf = new SimpleConfiguration(progressMonitor, freshEntityPolicy, timeOut, individualNodeSetPolicy);
    if (getReasonerTypeString().equals("String_Node_Str")) {
        try {
            reasoner = new FaCTPlusPlusReasonerFactory().createNonBufferingReasoner(ontology, conf);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("String_Node_Str");
    } else if (getReasonerTypeString().equals("String_Node_Str")) {
        reasoner = new ReasonerFactory().createNonBufferingReasoner(ontology, conf);
    } else if (getReasonerTypeString().equals("String_Node_Str")) {
        reasoner = PelletReasonerFactory.getInstance().createNonBufferingReasoner(owlAPIOntologies.iterator().next(), conf);
        Logger pelletLogger = Logger.getLogger("String_Node_Str");
        pelletLogger.setLevel(Level.WARN);
    } else {
        try {
            OWLlinkHTTPXMLReasonerFactory factory = new OWLlinkHTTPXMLReasonerFactory();
            URL url = new URL(getOwlLinkURL());
            OWLlinkReasonerConfiguration config = new OWLlinkReasonerConfiguration(url);
            reasoner = factory.createNonBufferingReasoner(ontology, config);
            System.out.println(reasoner.getReasonerName());
        } catch (Exception e) {
            throw new ComponentInitException(e);
        }
    }
    boolean inconsistentOntology = !reasoner.isConsistent();
    if (!inconsistentOntology) {
        reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY, InferenceType.CLASS_ASSERTIONS);
    } else {
        throw new ComponentInitException("String_Node_Str");
    }
    factory = manager.getOWLDataFactory();
    for (OWLClass owlClass : classes) atomicConcepts.add(new NamedClass(owlClass.toStringID()));
    for (OWLObjectProperty owlProperty : owlObjectProperties) atomicRoles.add(new ObjectProperty(owlProperty.toStringID()));
    for (OWLDataProperty owlProperty : owlDatatypeProperties) {
        DatatypeProperty dtp = new DatatypeProperty(owlProperty.toStringID());
        Set<OWLDataRange> ranges = owlProperty.getRanges(allImports);
        Iterator<OWLDataRange> it = ranges.iterator();
        if (it.hasNext()) {
            OWLDataRange range = it.next();
            if (range.isDatatype()) {
                URI uri = ((OWLDatatype) range).getIRI().toURI();
                if (uri.equals(OWL2Datatype.BOOLEAN.getURI()))
                    booleanDatatypeProperties.add(dtp);
                else if (uri.equals(OWL2Datatype.DOUBLE.getURI()))
                    doubleDatatypeProperties.add(dtp);
                else if (uri.equals(OWL2Datatype.INT.getURI()))
                    intDatatypeProperties.add(dtp);
                else if (uri.equals(OWL2Datatype.STRING.getURI()))
                    stringDatatypeProperties.add(dtp);
            }
        } else {
            stringDatatypeProperties.add(dtp);
        }
        datatypeProperties.add(dtp);
    }
    for (OWLNamedIndividual owlIndividual : owlIndividuals) {
        individuals.add(new Individual(owlIndividual.toStringID()));
    }
}

Output:
     } else if (getReasonerTypeString().equals("String_Node_Str")) {
-        reasoner = PelletReasonerFactory.getInstance().createNonBufferingReasoner(owlAPIOntologies.iterator().next(), conf);
+        reasoner = PelletReasonerFactory.getInstance().createNonBufferingReasoner(ontology, conf);
         Logger pelletLogger = Logger.getLogger("String_Node_Str");


Input:
protected boolean removeChild(Location child) {
    boolean removed;
    synchronized (children) {
        removed = children.remove(child);
    }
    if (removed) {
        if (child instanceof Closeable) {
            Closeables.closeQuietly((Closeable) child);
        }
        child.setParent(null);
        if (isManaged()) {
            managementContext.getLocationManager().unmanage(child);
        }
    }
    return removed;
}

Output:
         if (child instanceof Closeable) {
-            Closeables.closeQuietly((Closeable) child);
+            Streams.closeQuietly((Closeable) child);
         }


Input:
public void setup() throws Exception {
    threadingModelFactory = new Spinning_EventLoopGroupFactory();
    super.setup();
}

Output:
 public void setup() throws Exception {
-    threadingModelFactory = new Spinning_EventLoopGroupFactory();
+    eventLoopGroupFactory = new Spinning_EventLoopGroupFactory();
     super.setup();


Input:
public void mouseMoved(MouseEvent e) {
    if (isDrawing) {
        mouseLocation = e.getPoint();
        levelCursor = viewToLevel(mouseLocation);
    }
    updateCursorSnap();
    viewport.repaint();
    e.consume();
}

Output:
 public void mouseMoved(MouseEvent e) {
-    if (isDrawing) {
-        mouseLocation = e.getPoint();
-        levelCursor = viewToLevel(mouseLocation);
-    }
+    mouseLocation = e.getPoint();
+    levelCursor = viewToLevel(mouseLocation);
     updateCursorSnap();


Input:
public String readRawContent(ZVerseBackendState rafBook, Key key, String keyName) throws IOException {
    SwordBookMetaData bookMetaData = getBookMetaData();
    final String charset = bookMetaData.getBookCharset();
    final String compressType = (String) bookMetaData.getProperty(ConfigEntryType.COMPRESS_TYPE);
    final String v11nName = getBookMetaData().getProperty(ConfigEntryType.VERSIFICATION).toString();
    final Versification v11n = Versifications.instance().getVersification(v11nName);
    Verse verse = KeyUtil.getVerse(v11n, key);
    int index = verse.getOrdinal();
    final Testament testament = v11n.getTestament(index);
    index = v11n.getTestamentOrdinal(index);
    final RandomAccessFile compRaf;
    final RandomAccessFile idxRaf;
    final RandomAccessFile textRaf;
    if (testament == Testament.OLD) {
        compRaf = rafBook.getOtCompRaf();
        idxRaf = rafBook.getOtIdxRaf();
        textRaf = rafBook.getOtTextRaf();
    } else {
        compRaf = rafBook.getNtCompRaf();
        idxRaf = rafBook.getNtIdxRaf();
        textRaf = rafBook.getNtTextRaf();
    }
    if (compRaf == null) {
        return "String_Node_Str";
    }
    byte[] temp = SwordUtil.readRAF(compRaf, 1L * index * COMP_ENTRY_SIZE, COMP_ENTRY_SIZE);
    if (temp == null || temp.length == 0) {
        return "String_Node_Str";
    }
    final long blockNum = SwordUtil.decodeLittleEndian32(temp, 0);
    final int verseStart = SwordUtil.decodeLittleEndian32(temp, 4);
    final int verseSize = SwordUtil.decodeLittleEndian16(temp, 8);
    byte[] uncompressed = null;
    if (blockNum == rafBook.getLastBlockNum() && testament == rafBook.getLastTestament()) {
        uncompressed = rafBook.getLastUncompressed();
    } else {
        temp = SwordUtil.readRAF(idxRaf, blockNum * IDX_ENTRY_SIZE, IDX_ENTRY_SIZE);
        if (temp == null || temp.length == 0) {
            return "String_Node_Str";
        }
        final int blockStart = SwordUtil.decodeLittleEndian32(temp, 0);
        final int blockSize = SwordUtil.decodeLittleEndian32(temp, 4);
        final int uncompressedSize = SwordUtil.decodeLittleEndian32(temp, 8);
        final byte[] data = SwordUtil.readRAF(textRaf, blockStart, blockSize);
        decipher(data);
        uncompressed = CompressorType.fromString(compressType).getCompressor(data).uncompress(uncompressedSize).toByteArray();
        rafBook.setLastBlockNum(blockNum);
        rafBook.setLastTestament(testament);
        rafBook.setLastUncompressed(uncompressed);
    }
    final byte[] chopped = new byte[verseSize];
    System.arraycopy(uncompressed, verseStart, chopped, 0, verseSize);
    return SwordUtil.decode(keyName, chopped, charset);
}

Output:
     final Versification v11n = Versifications.instance().getVersification(v11nName);
-    Verse verse = KeyUtil.getVerse(v11n, key);
+    Verse verse = KeyUtil.getVerse(key);
     int index = verse.getOrdinal();


Input:
public void widgetSelected(SelectionEvent e) {
    if (m_configuration != null) {
        encodePlatformInformation(m_selectPlatformCombo.getText());
        showApplyButton();
    }
}

Output:
     if (m_configuration != null) {
-        encodePlatformInformation(m_selectPlatformCombo.getText());
-        showApplyButton();
+        try {
+            encodePlatformInformation(m_selectPlatformCombo.getText());
+            setPlatfromTypeCombo(m_configuration);
+            showApplyButton();
+        } catch (CoreException e1) {
+        }
     }


Input:
private List<HostVO> searchForServers(Long startIndex, Long pageSize, Object name, Object type, Object state, Object zone, Object pod, Object cluster, Object id, Object keyword, Object allocationState) {
    Filter searchFilter = new Filter(HostVO.class, "String_Node_Str", Boolean.TRUE, startIndex, pageSize);
    SearchCriteria<HostVO> sc = _hostDao.createSearchCriteria();
    if (keyword != null) {
        SearchCriteria<HostVO> ssc = _hostDao.createSearchCriteria();
        ssc.addOr("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + keyword + "String_Node_Str");
        ssc.addOr("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + keyword + "String_Node_Str");
        ssc.addOr("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + keyword + "String_Node_Str");
        sc.addAnd("String_Node_Str", SearchCriteria.Op.SC, ssc);
    }
    if (id != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, id);
    }
    if (name != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + name + "String_Node_Str");
    }
    if (type != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, type);
    }
    if (state != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, state);
    }
    if (zone != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, zone);
    }
    if (pod != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, pod);
    }
    if (cluster != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, cluster);
    }
    if (allocationState != null) {
        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, allocationState);
    }
    return _hostDao.search(sc, searchFilter);
}

Output:
     if (type != null) {
-        sc.addAnd("String_Node_Str", SearchCriteria.Op.EQ, type);
+        sc.addAnd("String_Node_Str", SearchCriteria.Op.LIKE, "String_Node_Str" + type + "String_Node_Str");
     }


Input:
public static <T> void restoreInstanceState(T target, Bundle bundle) {
    BundleBinding<T> binding = (BundleBinding<T>) getBundleBinding(target.getClass().getClassLoader(), target.getClass().getName());
    if (binding != null) {
        binding.restoreInstanceState(target, bundle);
    }
}

Output:
 public static <T> void restoreInstanceState(T target, Bundle bundle) {
-    BundleBinding<T> binding = (BundleBinding<T>) getBundleBinding(target.getClass().getClassLoader(), target.getClass().getName());
+    BundleBinding<T> binding = (BundleBinding<T>) getBundleBinding(target.getClass().getClassLoader(), target.getClass());
     if (binding != null) {


Input:
public String _generateOutDriverCode() throws IllegalActionException {
    StringBuffer code = new StringBuffer();
    System.out.println("String_Node_Str");
    String sinkReference;
    String srcReference;
    String actorDriverCode = "String_Node_Str";
    CodeGeneratorHelper myHelper;
    Director dir;
    for (Actor actor : (List<Actor>) ((TypedCompositeActor) _director.getContainer()).deepEntityList()) {
        List outputPortList = actor.outputPortList();
        Iterator outputPorts = outputPortList.iterator();
        sinkReference = "String_Node_Str";
        srcReference = "String_Node_Str";
        actorDriverCode = "String_Node_Str";
        dir = actor.getDirector();
        if (actor instanceof CompositeActor && dir != null) {
            while (outputPorts.hasNext()) {
                TypedIOPort sourcePort = (TypedIOPort) outputPorts.next();
                TypedIOPort sp = sourcePort;
                List<TypedIOPort> ports = sourcePort.insidePortList();
                for (TypedIOPort port : ports) {
                    if (port.isOutput()) {
                        sp = port;
                    }
                }
                String[] channelOffset = { "String_Node_Str", "String_Node_Str" };
                int i = sourcePort.getWidth();
                myHelper = (CodeGeneratorHelper) this._getHelper(sourcePort.getContainer());
                if (i > 1) {
                    for (int j = 0; j < i; j++) {
                        actorDriverCode += "String_Node_Str";
                    }
                } else {
                    channelOffset[0] = "String_Node_Str";
                    srcReference = this.driverGetReference((TypedIOPort) sp, channelOffset, true, true, myHelper);
                    sinkReference = this.driverGetReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
                    String temp = _typeConversion(sp, sourcePort);
                    String src;
                    if (temp.length() == 0)
                        src = srcReference;
                    else
                        src = temp + "String_Node_Str" + srcReference + "String_Node_Str";
                    actorDriverCode += sinkReference + "String_Node_Str" + src + "String_Node_Str" + _eol;
                }
            }
        } else {
            while (outputPorts.hasNext()) {
                IOPort sourcePort = (IOPort) outputPorts.next();
                String[] channelOffset = { "String_Node_Str", "String_Node_Str" };
                int i = sourcePort.getWidth();
                myHelper = (CodeGeneratorHelper) this._getHelper(sourcePort.getContainer());
                if (i > 1) {
                    for (int j = 0; j < i; j++) {
                        actorDriverCode += "String_Node_Str";
                    }
                } else {
                    channelOffset[0] = "String_Node_Str";
                    srcReference = this.getReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
                    sinkReference = this.driverGetReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
                    ArrayList args = new ArrayList();
                    args.add(sinkReference);
                    args.add(srcReference);
                    actorDriverCode += _generateBlockCode("String_Node_Str", args);
                }
            }
            System.out.println("String_Node_Str");
            System.out.println(actorDriverCode);
        }
        ArrayList args = new ArrayList();
        args.add(_generateDriverName((NamedObj) actor) + "String_Node_Str");
        args.add(actorDriverCode);
        code.append(_generateBlockCode("String_Node_Str", args));
    }
    return code.toString();
}

Output:
         dir = actor.getDirector();
-        if (actor instanceof CompositeActor && dir != null) {
+        code.append(_eol + "String_Node_Str" + dir.getFullName() + _eol);
+        if (actor instanceof CompositeActor && (dir.getFullName().contains("String_Node_Str") || dir.getFullName().contains("String_Node_Str"))) {
+            code.append(_eol + "String_Node_Str" + _eol);
+            actorDriverCode += _eol + "String_Node_Str" + _eol;
+            while (outputPorts.hasNext()) {
+                IOPort sourcePort = (IOPort) outputPorts.next();
+                String[] channelOffset = { "String_Node_Str", "String_Node_Str" };
+                int i = sourcePort.getWidth();
+                myHelper = (CodeGeneratorHelper) this._getHelper(sourcePort.getContainer());
+                if (i > 1) {
+                    for (int j = 0; j < i; j++) {
+                        actorDriverCode += "String_Node_Str";
+                    }
+                } else {
+                    channelOffset[0] = "String_Node_Str";
+                    srcReference = this.getReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
+                    sinkReference = this.driverGetReference((TypedIOPort) sourcePort, channelOffset, false, true, myHelper);
+                    ArrayList args = new ArrayList();
+                    args.add(sinkReference);
+                    args.add(srcReference);
+                    actorDriverCode += _generateBlockCode("String_Node_Str", args);
+                }
+            }
+        } else if (actor instanceof CompositeActor && dir != null) {
+            code.append(_eol + "String_Node_Str" + dir.getFullName() + _eol);
             while (outputPorts.hasNext()) {


Input:
private void readLabelData() throws ParseException {
    if (lengthOfLabel == 0) {
        return;
    }
    if (shouldParseLabelData) {
        segment.setLabelData(reader.readBytesRaw(lengthOfLabel));
    } else {
        reader.skip(lengthOfLabel);
    }
}

Output:
     if (shouldParseLabelData) {
-        segment.setLabelData(reader.readBytesRaw(lengthOfLabel));
+        segment.setLabelData(reader.readBytes(lengthOfLabel));
     } else {


Input:
public final boolean addPower(long microJoules) {
    power += microJoules;
    if (power >= getTarget()) {
        if (!finish()) {
            battery.addPower(Math.min(power, battery.getCapacity() - battery.getStored()));
        }
        return true;
    } else {
        return onReceivePower();
    }
}

Output:
         if (!finish()) {
-            battery.addPower(Math.min(power, battery.getCapacity() - battery.getStored()));
+            battery.addPower(Math.min(power, battery.getCapacity() - battery.getStored()), false);
         }


Input:
private boolean isSpecialObject(Map<String, Object> map) {
    if (map != null && map.keySet().size() == 1) {
        String key = map.keySet().iterator().next();
        if (key.startsWith("String_Node_Str") && map.get(key) != null) {
            return true;
        }
    }
    return false;
}

Output:
 private boolean isSpecialObject(Map<String, Object> map) {
-    if (map != null && map.keySet().size() == 1) {
-        String key = map.keySet().iterator().next();
-        if (key.startsWith("String_Node_Str") && map.get(key) != null) {
+    if (map != null && map.entrySet().size() == 1) {
+        Entry<String, Object> next = map.entrySet().iterator().next();
+        String key = next.getKey();
+        Object value = next.getValue();
+        if (key.startsWith("String_Node_Str") && value != null) {
             return true;