Input:
protected void inputChanged(Object input, Object oldInput) {
    if (input == null) {
        return;
    }
    InputStream isRight = null;
    IPath pathRight = null;
    IResource resLeft = null;
    IResource resRight = null;
    DiffNode node = (DiffNode) input;
    ITypedElement teLeft = node.getLeft();
    if (teLeft instanceof ResourceNode) {
        rnLeft = (ResourceNode) teLeft;
        resLeft = rnLeft.getResource();
    }
    ITypedElement teRight = node.getRight();
    if (teRight instanceof ResourceNode) {
        iCompareType = RESOURCE_NODE_TO_RESOURCE_NODE;
        rnRight = (ResourceNode) teRight;
        resRight = rnRight.getResource();
    } else if (teRight instanceof HistoryItem) {
        iCompareType = RESOURCE_NODE_TO_INPUT_STREAM;
        rnRight = null;
        hiRight = (HistoryItem) teRight;
        pathRight = new Path(hiRight.getName());
        try {
            isRight = hiRight.getContents();
        } catch (CoreException ce) {
            UiConstants.Util.log(ce);
        }
    }
    if (iCompareType == RESOURCE_NODE_TO_RESOURCE_NODE) {
        try {
            ModelResource mrLeft = findModelResource(resLeft, true);
            ModelResource mrRight = findModelResource(resRight, true);
            dpProcessor = ModelerComparePlugin.createDifferenceProcessor(mrLeft, mrRight);
        } catch (ModelWorkspaceException mwe) {
            UiConstants.Util.log(mwe);
        }
    } else {
        IProject project = resLeft.getProject();
        if ((project != null) && project.isOpen() && ModelerCore.hasModelNature(project) && (resLeft.getType() == IResource.FILE)) {
            try {
                ModelResource mrLeft = findModelResource(resLeft, true);
                if (mrLeft != null) {
                    dpProcessor = ModelerComparePlugin.createDifferenceProcessor(isRight, pathRight, mrLeft, mrLeft.getDescription());
                }
            } catch (ModelWorkspaceException mwe) {
                UiConstants.Util.log(mwe);
            }
        }
    }
    dpProcessor.execute(new NullProgressMonitor());
    drReport = dpProcessor.getDifferenceReport();
    getDifferenceReportsPanel().setTerminologyStyle(getTerminologyStyle(iCompareType));
    getDifferenceReportsPanel().setDifferenceReports(Collections.singletonList(drReport));
    if (iCompareType == RESOURCE_NODE_TO_RESOURCE_NODE) {
        getDifferenceReportsPanel().setObjectNames(getLeftObjectName(), getRightObjectName());
    } else if (iCompareType == RESOURCE_NODE_TO_INPUT_STREAM) {
        getDifferenceReportsPanel().setObjectNames(getRightObjectName(), getLeftObjectName());
    }
}

Output:
     } else {
-        IProject project = resLeft.getProject();
+        IProject project = null;
+        if (resLeft != null) {
+            project = resLeft.getProject();
+        }
         if ((project != null) && project.isOpen() && ModelerCore.hasModelNature(project) && (resLeft.getType() == IResource.FILE)) {


Input:
protected void onPreExecute() {
    super.onPreExecute();
    mNewDictionary = DictionaryFactory.getInstance().createUserDictionary(getApplicationContext(), mSelectedLocale);
}

Output:
     super.onPreExecute();
-    mNewDictionary = DictionaryFactory.getInstance().createUserDictionary(getApplicationContext(), mSelectedLocale);
+    mNewDictionary = new SafeUserDictionary(getApplicationContext(), mSelectedLocale);
+    mNewDictionary.loadDictionary();
+    if (mNewDictionary != mCurrentDictionary && mCurrentDictionary != null) {
+        mCursor.close();
+        mCurrentDictionary.close();
+    }
 }


Input:
protected Migrator createMigrator() throws MalformedURLException, ClassNotFoundException, JDBCException, SQLException, MigrationFailedException, IllegalAccessException, InstantiationException {
    String[] strings = classpath.list();
    List<URL> taskClassPath = new ArrayList<URL>();
    for (int i = 0; i < strings.length; i++) {
        URL url = new File(strings[i]).toURL();
        taskClassPath.add(url);
    }
    Driver driver = (Driver) Class.forName(getDriver(), true, new URLClassLoader(taskClassPath.toArray(new URL[taskClassPath.size()]))).newInstance();
    Properties info = new Properties();
    info.put("String_Node_Str", getUsername());
    info.put("String_Node_Str", getPassword());
    Connection connection = driver.connect(getUrl(), info);
    if (connection == null) {
        throw new JDBCException("String_Node_Str" + getUrl() + "String_Node_Str" + driver.getClass().getName() + "String_Node_Str");
    }
    Migrator migrator = new Migrator(getChangeLogFile().trim(), new AntFileOpener(getProject(), classpath));
    migrator.init(connection);
    return migrator;
}

Output:
     String[] strings = classpath.list();
-    List<URL> taskClassPath = new ArrayList<URL>();
+    final List<URL> taskClassPath = new ArrayList<URL>();
     for (int i = 0; i < strings.length; i++) {


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
    getActivity().registerReceiver(receiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
    Log.d(TAG, "String_Node_Str");
}

Output:
     setRetainInstance(true);
-    getActivity().registerReceiver(receiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+    getActivity().registerReceiver(mChargingReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
     Log.d(TAG, "String_Node_Str");


Input:
private Object apply(Sym name, List<Object> args) {
    try {
        Object ret = ((Invocable) engine).invokeFunction(iso2.get(name), args);
        check(syms.get(name).second, ret);
        return ret;
    } catch (Throwable e) {
        throw new RuntimeException("String_Node_Str" + name + "String_Node_Str" + args + "String_Node_Str" + e.getClass() + "String_Node_Str" + e.getMessage() + postfix);
    }
}

Output:
     } catch (Throwable e) {
-        throw new RuntimeException("String_Node_Str" + name + "String_Node_Str" + args + "String_Node_Str" + e.getClass() + "String_Node_Str" + e.getMessage() + postfix);
+        throw new RuntimeException("String_Node_Str" + name + "String_Node_Str" + args + "String_Node_Str" + Util.sep(args.stream().map(x -> x.getClass()).collect(Collectors.toList()), "String_Node_Str") + "String_Node_Str" + e.getClass() + "String_Node_Str" + e.getMessage() + postfix);
     }


Input:
public void processAction(Game game) {
    game.getState().handleSimultaneousEvent(game);
    applyEffects(game);
}

Output:
     game.getState().handleSimultaneousEvent(game);
-    applyEffects(game);
+    game.applyEffects();
 }


Input:
private void verifyIndexCreationCommand(DBObject indexDocument, DBCollection collection) {
    final ArgumentCaptor<DBObject> indexCommandCaptor = ArgumentCaptor.forClass(DBObject.class);
    verify(collection, times(1)).createIndex(indexCommandCaptor.capture());
    assertThat(indexCommandCaptor.getValue(), is(indexDocument));
}

Output:
     final ArgumentCaptor<DBObject> indexCommandCaptor = ArgumentCaptor.forClass(DBObject.class);
-    verify(collection, times(1)).createIndex(indexCommandCaptor.capture());
+    verify(collection, times(1)).ensureIndex(indexCommandCaptor.capture());
     assertThat(indexCommandCaptor.getValue(), is(indexDocument));


Input:
private Node createFilterBox() {
    filterTextField = new FilterTextField("String_Node_Str").setOnConfirm((text) -> {
        ui.triggerEvent(new PanelReloadingEvent());
        applyStringFilter(text);
        ui.triggerEvent(new PanelReloadedEvent());
        return text;
    }).setOnCancel(this::requestFocus);
    filterTextField.setId(guiController.getDefaultRepo() + "String_Node_Str" + panelIndex + "String_Node_Str");
    filterTextField.setMinWidth(388);
    filterTextField.setMaxWidth(388);
    ui.registerEvent(onModelUpdate);
    filterTextField.setOnMouseClicked(e -> ui.triggerEvent(new PanelClickedEvent(panelIndex)));
    HBox layout = new HBox();
    layout.getChildren().addAll(filterTextField);
    layout.setPadding(new Insets(0, 0, 3, 0));
    setupPanelDragEvents(layout);
    return layout;
}

Output:
     filterTextField = new FilterTextField("String_Node_Str").setOnConfirm((text) -> {
-        ui.triggerEvent(new PanelReloadingEvent());
+        Platform.runLater(() -> ui.triggerEvent(new PanelReloadingEvent()));
         applyStringFilter(text);


Input:
public static List<AutoConversionType> load(File file) {
    List<AutoConversionType> beanList = new ArrayList<>();
    try {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder analyseur = documentBuilderFactory.newDocumentBuilder();
        analyseur.setErrorHandler(new ErrorHandler() {
            public void error(final SAXParseException exception) throws SAXException {
                throw exception;
            }
            public void fatalError(final SAXParseException exception) throws SAXException {
                throw exception;
            }
            public void warning(final SAXParseException exception) throws SAXException {
                throw exception;
            }
        });
        Document document = analyseur.parse(file);
        NodeList typeNodes = document.getElementsByTagName("String_Node_Str");
        for (int i = 0; i < typeNodes.getLength(); i++) {
            Node typeNode = typeNodes.item(i);
            NamedNodeMap typeAttributes = typeNode.getAttributes();
            AutoConversionType typeObj = new AutoConversionType();
            typeObj.setSourceDataType(typeAttributes.getNamedItem("String_Node_Str").getNodeValue());
            typeObj.setTargetDataType(typeAttributes.getNamedItem("String_Node_Str").getNodeValue());
            typeObj.setConversionFunction(typeAttributes.getNamedItem("String_Node_Str").getNodeValue());
            beanList.add(typeObj);
        }
    } catch (Exception e) {
        return beanList;
    }
    return beanList;
}

Output:
 public static List<AutoConversionType> load(File file) {
-    List<AutoConversionType> beanList = new ArrayList<>();
+    beanList = new ArrayList<>();
     try {


Input:
private Model getModel(List<OWLAxiom> axioms) {
    Model model = ModelFactory.createDefaultModel();
    try {
        Conversion.OWLAPIOntology2JenaModel(OWLManager.createOWLOntologyManager().createOntology(new HashSet<OWLAxiom>(axioms)), model);
    } catch (OWLOntologyCreationException e) {
        e.printStackTrace();
    }
    return model;
}

Output:
     try {
-        Conversion.OWLAPIOntology2JenaModel(OWLManager.createOWLOntologyManager().createOntology(new HashSet<OWLAxiom>(axioms)), model);
+        OWLOntology ontology = OWLManager.createOWLOntologyManager().createOntology(new HashSet<OWLAxiom>(axioms));
+        String s = new org.aksw.commons.owlapi.StringConverter(ontology).toStringAsTurtle();
+        System.out.println(s);
+        ByteArrayInputStream bs = new ByteArrayInputStream(s.getBytes());
+        model.read(bs, "String_Node_Str", "String_Node_Str");
     } catch (OWLOntologyCreationException e) {


Input:
private CompoundVector createCompoundVector() {
    return new CompoundVector((EF_ConditionalDistribution) this.getEF_BaseDistribution(0), this.numberOfConfigurations());
}

Output:
 private CompoundVector createCompoundVector() {
-    return new CompoundVector((EF_ConditionalDistribution) this.getEF_BaseDistribution(0), this.numberOfConfigurations());
+    return new CompoundVector((EF_Distribution) this.getEF_BaseDistribution(0), this.numberOfConfigurations());
 }


Input:
public void noargsTest() {
    Invocation invocation = new Invocation("String_Node_Str");
    Operation op = xrService.getOperation(invocation.getName());
    Object result = op.invoke(xrService, invocation);
    assertNotNull("String_Node_Str", result);
    Document doc = xmlPlatform.createDocument();
    XMLMarshaller marshaller = xrService.getXMLContext().createMarshaller();
    marshaller.marshal(result, doc);
    Document controlDoc = xmlParser.parse(new StringReader(SIMPLE_XML_RESULT));
    assertTrue("String_Node_Str" + documentToString(controlDoc) + "String_Node_Str" + documentToString(doc), comparer.isNodeEqual(controlDoc, doc));
}

Output:
     marshaller.marshal(result, doc);
-    Document controlDoc = xmlParser.parse(new StringReader(SIMPLE_XML_RESULT));
+    Document controlDoc = xmlParser.parse(new StringReader(VALUE_1_XML));
     assertTrue("String_Node_Str" + documentToString(controlDoc) + "String_Node_Str" + documentToString(doc), comparer.isNodeEqual(controlDoc, doc));


Input:
protected void updatePreview(Object handle) {
    if (handle != null) {
        previewLabel.setText(provider.getDisplayText(handle));
        previewLabel.updateView();
    } else {
        previewLabel.restoreDefaultState();
        previewLabel.setForeground(ColorManager.getColor(-1));
        previewLabel.setBackground(ColorManager.getColor(-1));
        previewLabel.setText("String_Node_Str");
        previewLabel.updateView();
        if (isFormStyle()) {
            FormWidgetFactory.getInstance().paintFormStyle(previewLabel);
            FormWidgetFactory.getInstance().adapt(previewLabel);
        }
    }
}

Output:
 protected void updatePreview(Object handle) {
-    if (handle != null) {
-        previewLabel.setText(provider.getDisplayText(handle));
+    if (handle != null && mapProvider != null) {
+        previewLabel.setText(mapProvider.getDisplayText(handle));
         previewLabel.updateView();


Input:
private void sleep() {
    try {
        Thread.sleep(DELAY_MILLIS);
    } catch (InterruptedException ignore) {
        EmptyStatement.ignore(ignore);
    }
}

Output:
     try {
-        Thread.sleep(DELAY_MILLIS);
+        Thread.sleep(SCAN_DELAY_MILLIS);
     } catch (InterruptedException ignore) {


Input:
public Object getLevelAttribute(int levelIndex, int attributeIndex) {
    return metaResultSet.getLevelAttribute(levelIndex, attributeIndex);
}

Output:
 public Object getLevelAttribute(int levelIndex, int attributeIndex) {
-    return metaResultSet.getLevelAttribute(levelIndex, attributeIndex);
+    if (resultObject.getLevelMembers() == null || levelIndex < 0 || levelIndex > resultObject.getLevelMembers().length - 1) {
+        return null;
+    }
+    return resultObject.getLevelMembers()[levelIndex].getAttributes()[attributeIndex];
 }


Input:
public void save(Configuration credentials) {
    Properties props = new Properties();
    props.setProperty(Keys.AMAZON_ACCESS_KEY_ID.name(), credentials.getAccessKeyId());
    props.setProperty(Keys.AMAZON_SECRET_ACCESS_KEY.name(), credentials.getSecretAccessKey());
    props.setProperty(Keys.PROXY_HOST.name(), credentials.getProxyHost());
    props.setProperty(Keys.PROXY_PORT.name(), Integer.toString(credentials.getProxyPort()));
    props.setProperty(Keys.PROXY_USERNAME.name(), credentials.getProxyUsername());
    props.setProperty(Keys.PROXY_PASSWORD.name(), credentials.getProxyPassword());
    props.setProperty(Keys.USE_SSL.name(), Boolean.toString(credentials.isUseSecureProtocol()));
    saveProperties(props);
}

Output:
     Properties props = new Properties();
-    props.setProperty(Keys.AMAZON_ACCESS_KEY_ID.name(), credentials.getAccessKeyId());
-    props.setProperty(Keys.AMAZON_SECRET_ACCESS_KEY.name(), credentials.getSecretAccessKey());
-    props.setProperty(Keys.PROXY_HOST.name(), credentials.getProxyHost());
-    props.setProperty(Keys.PROXY_PORT.name(), Integer.toString(credentials.getProxyPort()));
-    props.setProperty(Keys.PROXY_USERNAME.name(), credentials.getProxyUsername());
-    props.setProperty(Keys.PROXY_PASSWORD.name(), credentials.getProxyPassword());
-    props.setProperty(Keys.USE_SSL.name(), Boolean.toString(credentials.isUseSecureProtocol()));
+    setProperty(props, Keys.AMAZON_ACCESS_KEY_ID, credentials.getAccessKeyId());
+    setProperty(props, Keys.AMAZON_SECRET_ACCESS_KEY, credentials.getSecretAccessKey());
+    setProperty(props, Keys.PROXY_HOST, credentials.getProxyHost());
+    setProperty(props, Keys.PROXY_PORT, credentials.getProxyPort());
+    setProperty(props, Keys.PROXY_USERNAME, credentials.getProxyUsername());
+    setProperty(props, Keys.PROXY_PASSWORD, credentials.getProxyPassword());
+    setProperty(props, Keys.USE_SSL, credentials.isUseSecureProtocol());
     saveProperties(props);


Input:
private void addMissingXAxii() {
    String xAxisType = (String) getPropertyValueMap().get("String_Node_Str");
    if ("String_Node_Str".equals(xAxisType)) {
        return;
    }
    int maxSeries = Integer.valueOf((String) getPropertyByName("String_Node_Str").getAllowedValues()[getPropertyByName("String_Node_Str").getAllowedValues().length - 1]);
    for (int i = 0; i < maxSeries; i++) {
        GraphNodeEndpoint yep = getEndpointByLabel("String_Node_Str" + (i + 1));
        if (yep == null) {
            return;
        }
        int insIndex = Math.max(0, getEndpointDefinitions().indexOf(yep) - 1);
        GraphNodeEndpoint ep = getEndpointByLabel("String_Node_Str" + (i + 1));
        if (ep == null) {
            ep = new DefaultGraphNodeEndpoint();
            ep.setType(EndpointType.Input);
            ep.setAnchor(AnchorType.Left);
            ep.setConnectorType(ConnectorType.Rectangle);
            ep.setLabel("String_Node_Str" + (i + 1));
            ep.setRequired(true);
            if ("String_Node_Str".equals(xAxisType)) {
                ep.setScope("String_Node_Str");
                ep.setMaxConnections(1);
            } else {
                ep.setScope("String_Node_Str");
                ep.setMaxConnections(-1);
            }
            getEndpointDefinitions().add(insIndex, ep);
        } else {
            if ("String_Node_Str".equals(xAxisType) && ep.getScope().contains("String_Node_Str")) {
                disconnectEndpoint(ep);
                ep.setScope("String_Node_Str");
            } else if ("String_Node_Str".equals(xAxisType) && ep.getScope().contains("String_Node_Str")) {
                disconnectEndpoint(ep);
                ep.setScope("String_Node_Str");
            }
        }
    }
}

Output:
         }
-        int insIndex = Math.max(0, getEndpointDefinitions().indexOf(yep) - 1);
+        int insIndex = Math.max(0, getEndpointDefinitions().indexOf(yep));
         GraphNodeEndpoint ep = getEndpointByLabel("String_Node_Str" + (i + 1));


Input:
public void activate() {
    if (Dungeon.bossLevel()) {
        return;
    }
    int nMobs = 1;
    if (Random.Int(2) == 0) {
        nMobs++;
        if (Random.Int(2) == 0) {
            nMobs++;
        }
    }
    ArrayList<Integer> candidates = new ArrayList<>();
    for (int i = 0; i < Level.NEIGHBOURS8.length; i++) {
        int p = pos + Level.NEIGHBOURS8[i];
        if (Actor.findChar(p) == null && (Level.passable[p] || Level.avoid[p])) {
            candidates.add(p);
        }
    }
    ArrayList<Integer> respawnPoints = new ArrayList<>();
    while (nMobs > 0 && candidates.size() > 0) {
        int index = Random.index(candidates);
        DUMMY.pos = candidates.get(index);
        respawnPoints.add(candidates.remove(index));
        nMobs--;
    }
    for (Integer point : respawnPoints) {
        Mob mob = Bestiary.mob(Dungeon.depth);
        mob.state = mob.WANDERING;
        GameScene.add(mob, DELAY);
        ScrollOfTeleportation.appear(mob, point);
    }
}

Output:
         GameScene.add(mob, DELAY);
-        ScrollOfTeleportation.appear(mob, point);
+        mobs.add(mob);
+    }
+    for (Mob mob : mobs) {
+        ScrollOfTeleportation.appear(mob, mob.pos);
     }


Input:
public String getPermaLink() {
    return permaLink;
}

Output:
 public String getPermaLink() {
-    return permaLink;
+    return StringUtils.notNullStr(permaLink);
 }


Input:
public void run() {
    backupEntrySet = new MapEntrySet();
    int partitionId = getPartitionId();
    RecordStore recordStore = mapService.getRecordStore(partitionId, name);
    Set<Map.Entry<Data, Data>> entries = entrySet.getEntrySet();
    PartitionService partitionService = getNodeEngine().getPartitionService();
    for (Map.Entry<Data, Data> entry : entries) {
        Data dataKey = entry.getKey();
        Data dataValue = entry.getValue();
        if (partitionId == partitionService.getPartitionId(dataKey)) {
            Data dataOldValue = null;
            if (initialLoad) {
                recordStore.putFromLoad(dataKey, dataValue, -1);
            } else {
                dataOldValue = mapService.toData(recordStore.put(dataKey, dataValue, -1));
            }
            mapService.interceptAfterPut(name, dataValue);
            EntryEventType eventType = dataOldValue == null ? EntryEventType.ADDED : EntryEventType.UPDATED;
            mapService.publishEvent(getCallerAddress(), name, eventType, dataKey, dataOldValue, dataValue);
            invalidateNearCaches(dataKey);
            if (mapContainer.getWanReplicationPublisher() != null && mapContainer.getWanMergePolicy() != null) {
                Record record = recordStore.getRecord(dataKey);
                SimpleEntryView entryView = new SimpleEntryView(dataKey, mapService.toData(dataValue), record.getStatistics(), record.getVersion());
                mapService.publishWanReplicationUpdate(name, entryView);
            }
            backupEntrySet.add(entry);
        }
    }
}

Output:
                 Record record = recordStore.getRecord(dataKey);
-                SimpleEntryView entryView = new SimpleEntryView(dataKey, mapService.toData(dataValue), record.getStatistics(), record.getVersion());
+                SimpleEntryView entryView = new SimpleEntryView(dataKey, mapService.toData(dataValue), record.getStatistics(), record.getCost(), record.getVersion());
                 mapService.publishWanReplicationUpdate(name, entryView);


Input:
public void setLocalLog(File log) {
    System.out.println("String_Node_Str" + log);
    try {
        fw = new FileWriter(log, true);
    } catch (Exception e1) {
        return;
    }
    System.out.println("String_Node_Str" + log.getAbsoluteFile());
    this.bwout = new BufferedWriter(fw);
    if (this.bwout == null) {
        System.out.println("String_Node_Str");
    } else {
        System.out.println("String_Node_Str");
    }
    if (this.getLocalLog() == null) {
        System.out.println("String_Node_Str");
    } else {
        System.out.println("String_Node_Str");
    }
}

Output:
     }
-    System.out.println("String_Node_Str" + log.getAbsoluteFile());
-    this.bwout = new BufferedWriter(fw);
-    if (this.bwout == null) {
-        System.out.println("String_Node_Str");
-    } else {
-        System.out.println("String_Node_Str");
-    }
-    if (this.getLocalLog() == null) {
-        System.out.println("String_Node_Str");
-    } else {
-        System.out.println("String_Node_Str");
-    }
+    this.pwout = new PrintWriter(fw);
 }


Input:
public void onBackPressed() {
    if (!router.handleBack()) {
        super.onBackPressed();
    }
}

Output:
 public void onBackPressed() {
-    if (!router.handleBack()) {
-        super.onBackPressed();
-    }
+    finish();
 }


Input:
protected HearthTreeNode summonMinion_core(int targetPlayerIndex, Minion targetMinion, HearthTreeNode boardState, Deck deckPlayer0, Deck deckPlayer1) throws HSException {
    if (boardState.data_.getNumMinions_p0() < 7) {
        if (!charge_) {
            hasAttacked_ = true;
        }
        hasBeenUsed_ = true;
        if (targetMinion instanceof Hero)
            boardState.data_.placeMinion(targetPlayerIndex, this, 0);
        else
            boardState.data_.placeMinion(targetPlayerIndex, this, boardState.data_.getMinions(targetPlayerIndex).indexOf(targetMinion) + 1);
        return boardState;
    } else {
        return null;
    }
}

Output:
 protected HearthTreeNode summonMinion_core(int targetPlayerIndex, Minion targetMinion, HearthTreeNode boardState, Deck deckPlayer0, Deck deckPlayer1) throws HSException {
-    if (boardState.data_.getNumMinions_p0() < 7) {
+    if (boardState.data_.getNumMinions(targetPlayerIndex) < 7) {
         if (!charge_) {


Input:
private static List<List<String>> createBatches(Set<Path> sourceFiles) {
    List<List<String>> result = new ArrayList<>();
    List<String> batch = new ArrayList<>(BATCH_SIZE);
    for (Path path : sourceFiles) {
        if (batch.size() == BATCH_SIZE) {
            result.add(batch);
            batch = new ArrayList<>(BATCH_SIZE);
        }
        batch.add(path.toAbsolutePath().toString());
    }
    return result;
}

Output:
     List<List<String>> result = new ArrayList<>();
-    List<String> batch = new ArrayList<>(BATCH_SIZE);
-    for (Path path : sourceFiles) {
-        if (batch.size() == BATCH_SIZE) {
-            result.add(batch);
-            batch = new ArrayList<>(BATCH_SIZE);
+    List<Path> sourceFiles = new ArrayList<>(sourceSet);
+    while (!sourceFiles.isEmpty()) {
+        ListIterator<Path> sourceFileIterator = sourceFiles.listIterator();
+        Set<String> batchDupeCheck = new HashSet<>();
+        List<String> batch = new ArrayList<>(BATCH_SIZE);
+        result.add(batch);
+        while (sourceFileIterator.hasNext()) {
+            if (batch.size() == BATCH_SIZE) {
+                batch = new ArrayList<>(BATCH_SIZE);
+                result.add(batch);
+                batchDupeCheck.clear();
+            }
+            Path path = sourceFileIterator.next();
+            if (!batchDupeCheck.contains(path.getFileName().toString())) {
+                batch.add(path.toAbsolutePath().toString());
+                batchDupeCheck.add(path.getFileName().toString());
+                sourceFileIterator.remove();
+            }
         }


Input:
File tempFile() {
    return tempFile != null ? tempFile.file : null;
}

Output:
 File tempFile() {
-    return tempFile != null ? tempFile.file : null;
+    return file;
 }


Input:
public String[] getSlaves() {
    return getStringArray("String_Node_Str", null);
}

Output:
 public String[] getSlaves() {
-    return getStringArray("String_Node_Str", null);
+    if (toUpdate.containsKey("String_Node_Str")) {
+        String value = (String) toUpdate.get("String_Node_Str");
+        return value.split("String_Node_Str");
+    } else {
+        return getStringArray("String_Node_Str", null);
+    }
 }


Input:
public ServerCallTree selectServerCallTree(Set<TraceId> traceIds, String applicationName, long from, long to) {
    final Map<String, ServiceType> terminalQueryParams = new HashMap<String, ServiceType>();
    final ServerCallTree tree = new ServerCallTree();
    StopWatch watch = new StopWatch();
    watch.start("String_Node_Str");
    List<List<SpanBo>> traces = this.traceDao.selectSpans(traceIds);
    watch.stop();
    int totalNonTerminalSpansCount = 0;
    Set<String> endPoints = new HashSet<String>();
    for (List<SpanBo> transaction : traces) {
        totalNonTerminalSpansCount += transaction.size();
        markRecursiveCall(transaction);
        for (SpanBo eachTransaction : transaction) {
            tree.addSpan(eachTransaction);
            terminalQueryParams.put(eachTransaction.getServiceName(), eachTransaction.getServiceType());
            endPoints.add(eachTransaction.getEndPoint());
        }
    }
    if (logger.isInfoEnabled()) {
        logger.info("String_Node_Str", new Object[] { watch.getLastTaskTimeMillis(), traces.size(), totalNonTerminalSpansCount });
    }
    watch.start("String_Node_Str");
    for (Entry<String, ServiceType> param : terminalQueryParams.entrySet()) {
        ServiceType svcType = param.getValue();
        if (!svcType.isRpcClient() && !svcType.isUnknown() && !svcType.isTerminal()) {
            long start = System.currentTimeMillis();
            List<List<TerminalRequest>> terminals = terminalStatisticsDao.selectTerminal(param.getKey(), from, to);
            logger.info("String_Node_Str", param.getKey(), System.currentTimeMillis() - start);
            for (List<TerminalRequest> terminal : terminals) {
                for (TerminalRequest t : terminal) {
                    if (!endPoints.contains(t.getTo())) {
                        t.setToServiceType(ServiceType.UNKNOWN_CLOUD.getCode());
                        tree.addTerminal(t);
                    } else {
                    }
                }
            }
        }
    }
    watch.stop();
    logger.info("String_Node_Str", watch.getLastTaskTimeMillis());
    return tree.build();
}

Output:
                     if (!endPoints.contains(t.getTo())) {
-                        t.setToServiceType(ServiceType.UNKNOWN_CLOUD.getCode());
+                        if (ServiceType.parse(t.getToServiceType()).isRpcClient()) {
+                            t.setToServiceType(ServiceType.UNKNOWN_CLOUD.getCode());
+                        }
                         tree.addTerminal(t);


Input:
public UploadEntity createUploadEntity(String uuid, String metadata, long contentLength) {
    TemplateOrVolumePostUploadCommand cmd = getTemplateOrVolumePostUploadCmd(metadata);
    UploadEntity uploadEntity = null;
    if (cmd == null) {
        String errorMessage = "String_Node_Str";
        updateStateMapWithError(uuid, errorMessage);
        throw new InvalidParameterValueException(errorMessage);
    } else {
        uuid = cmd.getEntityUUID();
        if (isOneTimePostUrlUsed(cmd)) {
            uploadEntity = uploadEntityStateMap.get(uuid);
            StringBuilder errorMessage = new StringBuilder("String_Node_Str");
            if (uploadEntity != null) {
                errorMessage.append("String_Node_Str").append(uploadEntity.getUploadState()).append("String_Node_Str");
            }
            throw new InvalidParameterValueException(errorMessage.toString());
        }
        int maxSizeInGB = Integer.valueOf(cmd.getMaxUploadSize());
        int contentLengthInGB = getSizeInGB(contentLength);
        if (contentLengthInGB > maxSizeInGB) {
            String errorMessage = "String_Node_Str" + contentLengthInGB + "String_Node_Str" + maxSizeInGB + "String_Node_Str";
            updateStateMapWithError(uuid, errorMessage);
            throw new InvalidParameterValueException(errorMessage);
        }
        checkSecondaryStorageResourceLimit(cmd, contentLengthInGB);
        try {
            String absolutePath = cmd.getAbsolutePath();
            uploadEntity = new UploadEntity(uuid, cmd.getEntityId(), UploadEntity.Status.IN_PROGRESS, cmd.getName(), absolutePath);
            uploadEntity.setMetaDataPopulated(true);
            uploadEntity.setResourceType(UploadEntity.ResourceType.valueOf(cmd.getType()));
            uploadEntity.setFormat(Storage.ImageFormat.valueOf(cmd.getImageFormat()));
            uploadEntity.setTemplatePath(absolutePath);
            String dataStoreUrl = cmd.getDataTo();
            String installPathPrefix = this.getRootDir(dataStoreUrl) + File.separator + absolutePath;
            uploadEntity.setInstallPathPrefix(installPathPrefix);
            uploadEntity.setHvm(cmd.getRequiresHvm());
            uploadEntity.setChksum(cmd.getChecksum());
            uploadEntity.setMaxSizeInGB(maxSizeInGB);
            uploadEntity.setDescription(cmd.getDescription());
            uploadEntity.setContentLength(contentLength);
            if (!_storage.exists(installPathPrefix)) {
                _storage.mkdir(installPathPrefix);
            }
            uploadEntityStateMap.put(uuid, uploadEntity);
        } catch (Exception e) {
            s_logger.error("String_Node_Str", e);
            updateStateMapWithError(uuid, e.getMessage());
        }
    }
    return uploadEntity;
}

Output:
         }
-        int maxSizeInGB = Integer.valueOf(cmd.getMaxUploadSize());
+        int maxSizeInGB = Integer.parseInt(cmd.getMaxUploadSize());
         int contentLengthInGB = getSizeInGB(contentLength);


Input:
public void updateStep(Matrix measurement, ObservationModel oModel, Matrix DH) {
    predictStep();
    Matrix inovation = measurement.minus(oModel.getObservationSpaceState(state));
    Matrix innovationCovariance = DH.times(covariance).times(DH.transpose());
    Matrix kalmanGain = covariance.times(DH.transpose()).times(innovationCovariance.inverse());
    covariance = (Util.eye(3).minus(kalmanGain.times(DH)).times(covariance));
    state = state.plus(kalmanGain.times(inovation));
    mostRecentUpdateTime = new Date();
}

Output:
     Matrix inovation = measurement.minus(oModel.getObservationSpaceState(state));
-    Matrix innovationCovariance = DH.times(covariance).times(DH.transpose());
-    Matrix kalmanGain = covariance.times(DH.transpose()).times(innovationCovariance.inverse());
-    covariance = (Util.eye(3).minus(kalmanGain.times(DH)).times(covariance));
+    Matrix innovationCovariance = matrixDH.times(covariance).times(matrixDH.transpose());
+    Matrix kalmanGain = covariance.times(matrixDH.transpose()).times(innovationCovariance.inverse());
+    covariance = (Util.createIdentityMatrix(3).minus(kalmanGain.times(matrixDH)).times(covariance));
     state = state.plus(kalmanGain.times(inovation));


Input:
private void applyStyleOnComponent(Component comp, Object bgColor, Object fgColor, Object compFont, Object compBorder) {
    if (comp instanceof IScriptableProvider) {
        IScriptable s = ((IScriptableProvider) comp).getScriptObject();
        if (s instanceof IRuntimeComponent) {
            IRuntimeComponent sbm = (IRuntimeComponent) s;
            RenderableWrapper sbmRW = null;
            if (s instanceof ISupportOnRenderCallback) {
                IScriptRenderMethods sr = ((ISupportOnRenderCallback) s).getRenderable();
                if (sr instanceof RenderableWrapper)
                    sbmRW = (RenderableWrapper) sr;
            }
            if (bgColor != null) {
                if (sbmRW != null)
                    sbmRW.clearProperty(RenderableWrapper.PROPERTY_BGCOLOR);
                sbm.setBgcolor(bgColor.toString());
                if (sbm.isTransparent()) {
                    if (comp instanceof IProviderStylePropertyChanges && ((IProviderStylePropertyChanges) comp).getStylePropertyChanges() instanceof IStylePropertyChangesRecorder) {
                        ((IStylePropertyChangesRecorder) (((IProviderStylePropertyChanges) comp).getStylePropertyChanges())).setBgcolor(bgColor.toString());
                    }
                }
            } else {
                sbm.setBgcolor(runtimeComponentStyleAttributes.get(sbm).get(RenderableWrapper.PROPERTY_BGCOLOR));
                setParentBGcolor(comp, "String_Node_Str");
            }
            if (fgColor != null) {
                if (sbmRW != null)
                    sbmRW.clearProperty(RenderableWrapper.PROPERTY_FGCOLOR);
                sbm.setFgcolor(fgColor.toString());
            } else {
                sbm.setFgcolor(runtimeComponentStyleAttributes.get(sbm).get(RenderableWrapper.PROPERTY_FGCOLOR));
            }
            if (compFont != null) {
                if (sbmRW != null)
                    sbmRW.clearProperty(RenderableWrapper.PROPERTY_FONT);
                sbm.setFont(compFont.toString());
            } else {
                sbm.setFont(runtimeComponentStyleAttributes.get(sbm).get(RenderableWrapper.PROPERTY_FONT));
            }
            if (compBorder != null) {
                String newBorder = compBorder.toString();
                Border currentBorder = ComponentFactoryHelper.createBorder(sbm.getBorder());
                Border marginBorder = null;
                if (currentBorder instanceof EmptyBorder) {
                    marginBorder = currentBorder;
                } else if (currentBorder instanceof CompoundBorder && ((CompoundBorder) currentBorder).getInsideBorder() instanceof EmptyBorder) {
                    marginBorder = ((CompoundBorder) currentBorder).getInsideBorder();
                }
                if (marginBorder != null) {
                    newBorder = ComponentFactoryHelper.createBorderString(BorderFactory.createCompoundBorder(ComponentFactoryHelper.createBorder(newBorder), marginBorder));
                }
                if (sbmRW != null)
                    sbmRW.clearProperty(RenderableWrapper.PROPERTY_BORDER);
                sbm.setBorder(newBorder);
                sbm.setSize(sbm.getWidth(), sbm.getHeight());
            } else {
                sbm.setBorder(runtimeComponentStyleAttributes.get(sbm).get(RenderableWrapper.PROPERTY_BORDER));
            }
        }
    }
}

Output:
             }
-            if (compBorder != null) {
-                String newBorder = compBorder.toString();
+            if (listItemBorder != null) {
+                String newBorder = listItemBorder.toString();
                 Border currentBorder = ComponentFactoryHelper.createBorder(sbm.getBorder());


Input:
public String createdDocumentDestination() {
    List<Documents> documentsList = new ArrayList<Documents>();
    List<String> vendorCodeDocument = new ArrayList<String>();
    List<OrderItems> orderItemsList = new ArrayList<OrderItems>();
    Orders orderEntity = orderService.findOrdersById(orderIdParam);
    order = transformToOrderFormBean(orderEntity);
    orderItemsList = operationsService.findAllOrderItemsByOrderId(orderIdParam);
    for (OrderItems everyItem : orderItemsList) {
        if (vendorCodeDocument.isEmpty()) {
            vendorCodeDocument.add(everyItem.getVendorDestination());
        } else {
            if (!vendorCodeDocument.contains(everyItem.getVendorDestination())) {
                vendorCodeDocument.add(everyItem.getVendorDestination());
            }
        }
    }
    List<Documents> proforma = documentsService.findDocumentNameAndId("String_Node_Str", orderIdParam);
    for (String itemVendor : vendorCodeDocument) {
        if (itemVendor != null) {
            if (proforma.size() == 0) {
                Documents documentEntity = new Documents();
                Client client = clientService.findClientById(getClientId().toString());
                documentEntity.setClient(client);
                documentEntity.setDocumentName(DocumentsConstants.HOUSE_WAYBILL_DESTINATION);
                documentEntity.setReferenceId(orderEntity.getOrderId());
                documentEntity.setReferenceTable("String_Node_Str");
                documentEntity.setOrderNumber(orderEntity.getOrderNumber());
                documentEntity.setCreatedDate(new Date());
                documentEntity.setDocumentStatus("String_Node_Str");
                documentEntity.setVendorCode(itemVendor);
                documentEntity.setReferenceNumber(orderEntity.getOrderNumber());
                documentEntity.setFinalOutboundStage(0);
                documentEntity.setDocumentProcessed(2);
                documentEntity.setCreatedBy(commonUtils.getUserNameFromSession());
                documentsService.addDocuments(documentEntity);
            } else {
                clearErrorsAndMessages();
                addActionError("String_Node_Str");
                for (OrderItems orderItemsElem : orderItemsList) {
                    orderItems.add(transformToOrderItemFormBean(orderItemsElem));
                }
                return INPUT;
            }
        } else {
            clearErrorsAndMessages();
            addActionError("String_Node_Str");
            for (OrderItems orderItemsElem : orderItemsList) {
                orderItems.add(transformToOrderItemFormBean(orderItemsElem));
            }
            return INPUT;
        }
    }
    clearErrorsAndMessages();
    addActionMessage("String_Node_Str");
    for (OrderItems orderItemsElem : orderItemsList) {
        orderItems.add(transformToOrderItemFormBean(orderItemsElem));
    }
    return SUCCESS;
}

Output:
     }
-    List<Documents> proforma = documentsService.findDocumentNameAndId("String_Node_Str", orderIdParam);
+    List<Documents> waybillDestination = documentsService.findDocumentNameAndId("String_Node_Str", orderIdParam);
     for (String itemVendor : vendorCodeDocument) {


Input:
public String isNotBlank(String colName) {
    if (is(MSSQL)) {
        return "String_Node_Str" + colName + "String_Node_Str" + notEqual() + "String_Node_Str";
    }
    if (is(ORACLE)) {
        return "String_Node_Str" + colName + "String_Node_Str" + isNull();
    }
    return "String_Node_Str" + colName + "String_Node_Str" + notEqual() + "String_Node_Str";
}

Output:
     if (is(ORACLE)) {
-        return "String_Node_Str" + colName + "String_Node_Str" + isNull();
+        return "String_Node_Str" + colName + "String_Node_Str" + isNotNull();
     }


Input:
public void success(SearchResult searchResult, Response response) {
    bmarks.addAll(searchResult.search_results);
    setProgressBarIndeterminateVisibility(false);
    Log.w(TAG, "String_Node_Str" + bmarks.size());
    adapter.notifyDataSetChanged();
    pagesLoaded = nextPage;
}

Output:
     adapter.notifyDataSetChanged();
-    pagesLoaded = nextPage;
+    pagesLoaded++;
 }


Input:
public static boolean doesBlockHaveSolidTopSurface(World worldIn, BlockPos pos) {
    return worldIn.getBlockState(pos.down()).isSideSolid(worldIn, pos, EnumFacing.UP) && worldIn.getBlockState(pos).getMaterial().isSolid() && !worldIn.getBlockState(pos.up()).getMaterial().isSolid();
}

Output:
 public static boolean doesBlockHaveSolidTopSurface(World worldIn, BlockPos pos) {
-    return worldIn.getBlockState(pos.down()).isSideSolid(worldIn, pos, EnumFacing.UP) && worldIn.getBlockState(pos).getMaterial().isSolid() && !worldIn.getBlockState(pos.up()).getMaterial().isSolid();
+    return worldIn.getBlockState(pos).isSideSolid(worldIn, pos, EnumFacing.UP);
 }


Input:
public void drawLines(RenderObject robj, int gidx, LineStyle style, double rad) {
    maybeUpdateState(gl);
    switch(style) {
        case LINE:
            {
                float fold = getLineWidth();
                float frad = (float) rad;
                boolean changeWidth = false;
                if (fold != frad) {
                    setLineWidth(frad);
                    changeWidth = true;
                }
                drawLines(robj, gidx);
                if (changeWidth) {
                    setLineWidth(fold);
                }
                break;
            }
        case CYLINDER:
        case SPINDLE:
        case SOLID_ARROW:
            drawSolidLines(robj, gidx, style, (float) rad);
            break;
    }
}

Output:
             {
-                float fold = getLineWidth();
+                float fold = getLineWidth(gl);
                 float frad = (float) rad;


Input:
private void initComponents() {
    setLayout(new GridBagLayout());
    GridBagConstraints constraints = new GridBagConstraints();
    Board[] boards = mGame.getBoards();
    IntStream.range(0, boards.length).forEach(boardIndex -> {
        mGameBoards[boardIndex] = new BoardPanel(boards[boardIndex].getBoardSize(), mSquareConfig, coordinate -> {
            Piece piece = mGame.getPiece(boardIndex, coordinate);
            if (piece != null && piece.getTeamId() == mGame.getTurnKeeper().getActiveTeamId()) {
                return mGame.getMovesFrom(boardIndex, coordinate);
            } else {
                return Collections.emptySet();
            }
        });
        constraints.gridx = boardIndex;
        constraints.weightx = 1.0;
        constraints.weighty = 1.0;
        constraints.gridheight = 2;
        constraints.fill = GridBagConstraints.BOTH;
        constraints.insets = new Insets(10, 0, 0, 0);
        add(mGameBoards[boardIndex], constraints);
    });
    Stream.of(mGame.getTeams()).forEach(team -> mTeamStatusPanels.add(new TeamStatusPanel(team)));
    mTeamStatusPanels.forEach(panel -> mTabbedPane.addTab(panel.getName(), panel));
    constraints.gridx = boards.length * 2;
    constraints.weightx = 0.3;
    constraints.gridheight = 1;
    constraints.weighty = 1.0;
    constraints.insets = new Insets(0, 25, 0, 10);
    add(mTabbedPane, constraints);
    mUndoButton.addActionListener(event -> {
        mGame.undoMove();
        refresh();
    });
    mForwardButton.addActionListener(event -> {
        mGame.nextMove();
        refresh();
    });
    mBackButton.addActionListener(event -> {
        mGame.previousMove();
        refresh();
    });
    GridBagConstraints gbc = new GridBagConstraints();
    JPanel buttonPanel = new JPanel();
    buttonPanel.setLayout(new GridBagLayout());
    buttonPanel.setOpaque(false);
    gbc.gridy = 0;
    gbc.gridx = 0;
    gbc.gridwidth = 2;
    gbc.weightx = 1.0;
    gbc.fill = GridBagConstraints.BOTH;
    buttonPanel.add(mUndoButton, gbc);
    gbc.gridy = 1;
    gbc.gridx = 0;
    gbc.gridwidth = 1;
    buttonPanel.add(mBackButton, gbc);
    gbc.gridx = 1;
    buttonPanel.add(mForwardButton, gbc);
    constraints.gridy = 1;
    constraints.gridx = boards.length * 2;
    constraints.weighty = 0.2;
    add(buttonPanel, constraints);
    refresh();
}

Output:
     setLayout(new GridBagLayout());
-    GridBagConstraints constraints = new GridBagConstraints();
+    JPanel boardPanels = new JPanel();
+    boardPanels.setOpaque(false);
+    boardPanels.setLayout(new GridBagLayout());
     Board[] boards = mGame.getBoards();


Input:
public boolean attackEntityAsMob(Entity enemy) {
    ItemStack stack = this.getHeldItemMainhand();
    if (stack != null) {
        NBTTagCompound nbt = NBTHelper.loadStackNBT(stack);
        double damage = Math.random() * (nbt.getInteger("String_Node_Str") - nbt.getInteger("String_Node_Str")) + nbt.getInteger("String_Node_Str");
        boolean hasAttacked = enemy.attackEntityFrom(DamageSource.causeMobDamage(this), (float) damage);
        if (hasAttacked && enemy instanceof EntityLivingBase) {
            WeaponHelper.useWeaponAttributes((float) damage, this, (EntityLivingBase) enemy, stack, nbt);
            int knockback = EnchantmentHelper.getKnockbackModifier(this);
            if (knockback > 0) {
                ((EntityLivingBase) enemy).knockBack(this, (float) knockback * 0.5F, (double) MathHelper.sin(this.rotationYaw * 0.017453292F), (double) (-MathHelper.cos(this.rotationYaw * 0.017453292F)));
                this.motionX *= 0.6D;
                this.motionZ *= 0.6D;
            }
        }
        return hasAttacked;
    } else {
        return false;
    }
}

Output:
     ItemStack stack = this.getHeldItemMainhand();
-    if (stack != null) {
+    if (stack != null && entity instanceof EntityPlayer) {
+        EntityPlayer enemy = (EntityPlayer) entity;
         NBTTagCompound nbt = NBTHelper.loadStackNBT(stack);


Input:
public int getViewTypeCount() {
    int result = 0;
    for (int i = 0; i < eventProviders.size(); i++) {
        IEventProvider<?> eventProvider = eventProviders.get(i);
        result += eventProvider.getViewTypeCount();
    }
    return result;
}

Output:
     for (int i = 0; i < eventProviders.size(); i++) {
-        IEventProvider<?> eventProvider = eventProviders.get(i);
+        IEventVisualizer<?> eventProvider = eventProviders.get(i);
         result += eventProvider.getViewTypeCount();


Input:
public double[][] getRegretCm() {
    try {
        double[][] featCounts = new double[idm.getNumConds()][];
        for (int c = 0; c < idm.getNumConds(); c++) {
            featCounts[c] = new double[idm.getNumParams(c)];
        }
        for (LambdaVar triple : mp.lambdaVars) {
            double frac = cplex.getValue(triple.lambdaVar);
            int s = triple.s;
            int[] sentSol = triple.sentSol;
            for (int i = 0; i < sentSol.length; i++) {
                int c = idm.getC(s, i);
                int m = idm.getM(s, i);
                featCounts[c][m] += sentSol[i] * frac;
            }
        }
        double[][] objVals = new double[idm.getNumConds()][];
        for (int c = 0; c < idm.getNumConds(); c++) {
            objVals[c] = cplex.getValues(mp.objVars[c]);
        }
        double[][] regret = new double[idm.getNumConds()][];
        for (int c = 0; c < idm.getNumConds(); c++) {
            regret[c] = new double[idm.getNumParams(c)];
            for (int m = 0; m < idm.getNumParams(c); m++) {
                regret[c][m] = objVals[c][m] - (logProbs[c][m] * featCounts[c][m]);
                if (!Utilities.gte(regret[c][m], 0.0, 1e-7)) {
                    log.warn(String.format("String_Node_Str", c, m, regret[c][m]));
                }
            }
        }
        return regret;
    } catch (IloException e) {
        throw new RuntimeException(e);
    }
}

Output:
             for (int m = 0; m < idm.getNumParams(c); m++) {
-                regret[c][m] = objVals[c][m] - (logProbs[c][m] * featCounts[c][m]);
+                regret[c][m] = objVals[c][m] - (optimalLogProbs[c][m] * featCounts[c][m]);
                 if (!Utilities.gte(regret[c][m], 0.0, 1e-7)) {


Input:
public void handleServiceEvent(IRemoteServiceEvent event) {
    if (event instanceof IRemoteServiceUnregisteredEvent) {
        trace("String_Node_Str", "String_Node_Str" + event.getLocalContainerID() + "String_Node_Str" + event.getContainerID() + "String_Node_Str" + event.getReference());
        ServiceRegistration[] proxyServiceRegistrations = null;
        synchronized (serviceLocations) {
            RemoteServiceRegistration rsRegs = (RemoteServiceRegistration) discoveredRemoteServiceRegistrations.get(event.getLocalContainerID());
            if (rsRegs != null) {
                proxyServiceRegistrations = rsRegs.removeServiceRegistration(event.getReference());
                if (rsRegs.isEmpty()) {
                    rsRegs.dispose();
                    discoveredRemoteServiceRegistrations.remove(event.getContainerID());
                }
            }
        }
        if (proxyServiceRegistrations != null) {
            for (int i = 0; i < proxyServiceRegistrations.length; i++) {
                trace("String_Node_Str", "String_Node_Str" + event.getLocalContainerID() + "String_Node_Str" + event.getContainerID() + "String_Node_Str" + event.getReference() + "String_Node_Str" + proxyServiceRegistrations[i]);
                unregisterProxyServiceRegistration(null, proxyServiceRegistrations[i]);
            }
        }
    }
}

Output:
     if (event instanceof IRemoteServiceUnregisteredEvent) {
-        trace("String_Node_Str", "String_Node_Str" + event.getLocalContainerID() + "String_Node_Str" + event.getContainerID() + "String_Node_Str" + event.getReference());
-        ServiceRegistration[] proxyServiceRegistrations = null;
+        ID containerID = event.getContainerID();
+        ID localContainerID = event.getLocalContainerID();
+        IRemoteServiceReference reference = event.getReference();
+        trace("String_Node_Str", "String_Node_Str" + localContainerID + "String_Node_Str" + containerID + "String_Node_Str" + reference);
+        RemoteServiceRegistration.RSEDAndSRAssoc[] assocs = null;
         synchronized (serviceLocations) {


Input:
public void run() {
    this.applicationsEventReceiver = new ApplicationsEventReceiver();
    addEventListeners();
}

Output:
 public void run() {
-    this.applicationsEventReceiver = new ApplicationsEventReceiver();
-    addEventListeners();
+    if (log.isInfoEnabled()) {
+        log.info("String_Node_Str");
+    }
+    Thread thread = new Thread(applicationsEventReceiver);
+    thread.start();
+    while (!terminated) {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException ignore) {
+        }
+    }
+    if (log.isInfoEnabled()) {
+        log.info("String_Node_Str");
+    }
 }


Input:
public void translateToBlueprint(Vec3d transform) {
    super.translateToBlueprint(transform);
    Vec3d pos = new Vec3d(entityNBT.getInteger("String_Node_Str"), entityNBT.getInteger("String_Node_Str"), entityNBT.getInteger("String_Node_Str"));
    pos = pos.add(transform);
    Vec3di floored = Utils.convertFloor(pos);
    entityNBT.setInteger("String_Node_Str", floored.getX());
    entityNBT.setInteger("String_Node_Str", floored.getY());
    entityNBT.setInteger("String_Node_Str", floored.getZ());
}

Output:
     pos = pos.add(transform);
-    Vec3di floored = Utils.convertFloor(pos);
+    Vec3i floored = Utils.convertFloor(pos);
     entityNBT.setInteger("String_Node_Str", floored.getX());


Input:
public void render() {
    List<PreviewChunk> previewChunks = this.previewChunks;
    if (previewChunks != null) {
        this.performUploads(previewChunks);
        for (PreviewChunk chunk : previewChunks) {
            chunk.render();
        }
    }
}

Output:
         for (PreviewChunk chunk : previewChunks) {
-            chunk.render();
+            chunk.render(this.centerBlockPos.getX(), this.centerBlockPos.getZ());
         }


Input:
public static Shell getShell(Widget widget) {
    Widget wdgt = widget;
    while (!(wdgt instanceof Control) && wdgt != null) {
        wdgt = getWidgetParent(wdgt);
    }
    if (wdgt != null) {
        return ((Control) wdgt).getShell();
    }
    return null;
}

Output:
     }
-    if (wdgt != null) {
+    if (wdgt != null && !wdgt.isDisposed()) {
         return ((Control) wdgt).getShell();


Input:
public Object updateOrAddAttribute(Map<String, String> tenantId, String entityName, Object id, Map<String, Object> properties, String attribute, Object attributeValue, String partner) {
    EntityManager em = getEmf().createEntityManager(tenantId);
    try {
        ClassDescriptor descriptor = getServerSession().getClassDescriptor(getClass(entityName));
        DatabaseMapping mapping = descriptor.getMappingForAttributeName(attribute);
        Object object = null;
        if (mapping == null) {
            return null;
        } else if (mapping.isObjectReferenceMapping() || mapping.isCollectionMapping()) {
            DatabaseMapping partnerMapping = null;
            if (partner != null) {
                ClassDescriptor referenceDescriptor = ((ForeignReferenceMapping) mapping).getReferenceDescriptor();
                partnerMapping = referenceDescriptor.getMappingForAttributeName(partner);
                if (partnerMapping == null) {
                    return null;
                }
            }
            transaction.beginTransaction(em);
            try {
                object = em.find(getClass(entityName), id, properties);
                if (object == null) {
                    return null;
                }
                attributeValue = em.merge(attributeValue);
                setMappingValueInObject(object, attributeValue, mapping, partnerMapping);
                transaction.commitTransaction(em);
            } catch (Exception e) {
                JPARSLogger.fine("String_Node_Str", new Object[] { entityName, getName(), e.toString() });
                transaction.rollbackTransaction(em);
                return null;
            }
        } else {
            return null;
        }
        return object;
    } finally {
        em.close();
    }
}

Output:
             } catch (Exception e) {
-                JPARSLogger.fine("String_Node_Str", new Object[] { entityName, getName(), e.toString() });
+                JPARSLogger.fine("String_Node_Str", new Object[] { DataStorage.get(DataStorage.REQUEST_UNIQUE_ID), entityName, getName(), e.toString() });
                 transaction.rollbackTransaction(em);


Input:
protected void writeSocketBindingGroup(XMLExtendedStreamWriter writer, ModelNode bindingGroup, boolean fromServer) throws XMLStreamException {
    writer.writeStartElement(Element.SOCKET_BINDING_GROUP.getLocalName());
    ModelNode attr = bindingGroup.get(NAME);
    writeAttribute(writer, Attribute.NAME, attr.asString());
    attr = bindingGroup.get(DEFAULT_INTERFACE);
    writeAttribute(writer, Attribute.DEFAULT_INTERFACE, attr.asString());
    if (fromServer && bindingGroup.has(PORT_OFFSET) && bindingGroup.get(PORT_OFFSET).asInt() != 0) {
        attr = bindingGroup.get(PORT_OFFSET);
        writeAttribute(writer, Attribute.PORT_OFFSET, attr.asString());
    }
    if (!fromServer && bindingGroup.hasDefined(INCLUDES)) {
        for (ModelNode include : bindingGroup.get(INCLUDES).asList()) {
            writer.writeStartElement(Element.INCLUDE.getLocalName());
            writeAttribute(writer, Attribute.SOCKET_BINDING_GROUP, include.asString());
            writer.writeEndElement();
        }
    }
    if (bindingGroup.hasDefined(SOCKET_BINDING)) {
        ModelNode bindings = bindingGroup.get(SOCKET_BINDING);
        for (String bindingName : bindings.keys()) {
            ModelNode binding = bindings.get(bindingName);
            writer.writeStartElement(Element.SOCKET_BINDING.getLocalName());
            writeAttribute(writer, Attribute.NAME, bindingName);
            attr = binding.get(PORT);
            writeAttribute(writer, Attribute.PORT, attr.asString());
            attr = binding.get(FIXED_PORT);
            if (attr.isDefined() && attr.asBoolean()) {
                writeAttribute(writer, Attribute.FIXED_PORT, attr.asString());
            }
            attr = binding.get(INTERFACE);
            if (attr.isDefined()) {
                writeAttribute(writer, Attribute.INTERFACE, attr.asString());
            }
            attr = binding.get(MULTICAST_ADDRESS);
            if (attr.isDefined()) {
                writeAttribute(writer, Attribute.MULTICAST_ADDRESS, attr.asString());
            }
            attr = binding.get(MULTICAST_PORT);
            if (attr.isDefined()) {
                writeAttribute(writer, Attribute.MULTICAST_PORT, attr.asString());
            }
            writer.writeEndElement();
        }
    }
    writer.writeEndElement();
}

Output:
     writeAttribute(writer, Attribute.DEFAULT_INTERFACE, attr.asString());
-    if (fromServer && bindingGroup.has(PORT_OFFSET) && bindingGroup.get(PORT_OFFSET).asInt() != 0) {
+    if (fromServer && bindingGroup.hasDefined(PORT_OFFSET) && bindingGroup.get(PORT_OFFSET).asInt() >= 0) {
         attr = bindingGroup.get(PORT_OFFSET);


Input:
synchronized public Object lockEntry(String name) throws IOException {
    assertOpen();
    ArchiveEntryV2 entry = entries.get(name);
    if (entry == null) {
        if (!isWritable) {
            throw new FileNotFoundException(name);
        }
        entry = (ArchiveEntryV2) createEntry(name);
    }
    if (useNativeLock) {
        if (!isTransient) {
            entry.ensureSize(1);
            int blockId = entry.index.getBlock(0);
            return rf.getChannel().lock(blockId * BLOCK_SIZE, 1, false);
        }
    }
    return entry;
}

Output:
     assertOpen();
-    ArchiveEntryV2 entry = entries.get(name);
+    NameEntry entry = entries.get(name);
     if (entry == null) {


Input:
protected void drawDocumentBackground() throws IOException {
    IStyle style = previousPage.getComputedStyle();
    String backgroundColor = style.getBackgroundColor();
    String backgroundImageUrl = EmitterUtil.getBackgroundImageUrl(style, reportContent.getDesign().getReportDesign());
    wordWriter.drawDocumentBackground(backgroundColor, backgroundImageUrl);
}

Output:
     String backgroundImageUrl = EmitterUtil.getBackgroundImageUrl(style, reportContent.getDesign().getReportDesign());
-    wordWriter.drawDocumentBackground(backgroundColor, backgroundImageUrl);
+    String height = style.getBackgroundHeight();
+    String width = style.getBackgroundWidth();
+    wordWriter.drawDocumentBackground(backgroundColor, backgroundImageUrl, height, width);
 }


Input:
public void waitUntilDocReady(int timeout, TimeUnit unit) {
    String state = String.valueOf(engine.executeScript("String_Node_Str")).trim().toLowerCase(Locale.ENGLISH);
    if ("String_Node_Str".equals(state)) {
        return;
    }
    LOG.debug("String_Node_Str" + timeout + "String_Node_Str" + unit.toString());
    CountDownLatch latch = new CountDownLatch(1);
    DocumentListener listener = new SyncDocumentListener(latch);
    addDocumentListener(listener);
    try {
        latch.await(timeout, unit);
    } catch (InterruptedException e) {
        throw new Ui4jExecutionTimeoutException(e, timeout, unit);
    }
    removeListener(listener);
}

Output:
 public void waitUntilDocReady(int timeout, TimeUnit unit) {
-    String state = String.valueOf(engine.executeScript("String_Node_Str")).trim().toLowerCase(Locale.ENGLISH);
+    String state = executeScript("String_Node_Str").toString().trim().toLowerCase(Locale.ENGLISH);
     if ("String_Node_Str".equals(state)) {


Input:
static boolean isTargetable(Map<String, FlagInfo> search, String key) {
    if (search.containsKey("String_Node_Str")) {
        return !search.get("String_Node_Str").isSafe();
    }
    return search.containsKey(key) && !search.get(key).isSafe();
}

Output:
 static boolean isTargetable(Map<String, FlagInfo> search, String key) {
-    if (search.containsKey("String_Node_Str")) {
-        return !search.get("String_Node_Str").isSafe();
+    if (!search.containsKey(key)) {
+        key = "String_Node_Str";
     }


Input:
public INDArray subArray(int[] offsets, int[] shape, int[] stride) {
    ensureNotCleanedUp();
    int n = shape.length;
    if (shape.length < 1)
        return Nd4j.create(Nd4j.createBuffer(shape));
    if (offsets.length != n)
        throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(offsets));
    if (shape.length != n)
        throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(shape));
    if (Arrays.equals(shape, this.shape)) {
        if (ArrayUtil.isZero(offsets)) {
            return this;
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
    int offset = this.offset + ArrayUtil.dotProduct(offsets, this.stride);
    if (ordering() == NDArrayFactory.C && shape[0] == 1)
        return Nd4j.create(data, Arrays.copyOf(shape, shape.length), ArrayUtil.reverseCopy(stride), offset, ordering);
    return Nd4j.create(data, Arrays.copyOf(shape, shape.length), stride, offset, ordering);
}

Output:
     if (shape.length < 1)
-        return Nd4j.create(Nd4j.createBuffer(shape));
+        return create(Nd4j.createBuffer(shape));
     if (offsets.length != n)


Input:
public void finish() {
    if (contentVA != null && contentClusterSizes != null && contentSampleElements != null) {
        isPartitionallyClustered = true;
        ContentGroupList contentGroupList = new ContentGroupList();
        int cnt = 0;
        contentTree = new Tree<ClusterNode>();
        contentTree.setUseDefaultComparator(false);
        int clusterNr = 0;
        ClusterNode root = new ClusterNode(contentTree, "String_Node_Str", clusterNr++, true, -1);
        contentTree.setRootNode(root);
        ClusterNode node;
        int from = 0;
        int to = 0;
        for (Integer clusterSize : contentClusterSizes) {
            node = new ClusterNode(contentTree, "String_Node_Str" + clusterNr, clusterNr++, true, -1);
            Group temp = new Group(clusterSize, false, contentSampleElements.get(cnt), SelectionType.NORMAL, node);
            contentTree.addChild(root, node);
            contentGroupList.append(temp);
            cnt++;
            to += clusterSize;
            ClusterNode leaf;
            for (int vaIndex = from; vaIndex < to; vaIndex++) {
                Integer contentID = contentVA.get(vaIndex);
                leaf = new ClusterNode(contentTree, "String_Node_Str" + contentID, clusterNr++, true, contentID);
                contentTree.addChild(node, leaf);
            }
            from = to;
        }
        contentVA.setGroupList(contentGroupList);
    } else if (contentVA != null && contentTree != null) {
        contentVA.buildNewGroupList(contentTree.getRoot().getChildren());
    }
    contentTree.setUseDefaultComparator(false);
}

Output:
         int cnt = 0;
-        contentTree = new Tree<ClusterNode>();
+        contentTree = new Tree<ClusterNode>(contentIDIdType);
         contentTree.setUseDefaultComparator(false);


Input:
public void packBody(MethodGen gen) {
    HashMap map = new HashMap();
    InstructionList fresh = gen.getInstructionList();
    for (InstructionHandle ih = getBody().getStart(); ih != null; ih = ih.getNext()) {
        if (Range.isRangeHandle(ih)) {
            continue;
        }
        Instruction i = ih.getInstruction();
        Instruction c = i.copy();
        if (c instanceof BranchInstruction)
            map.put(ih, fresh.append((BranchInstruction) c));
        else
            map.put(ih, fresh.append(c));
    }
    InstructionHandle ih = getBody().getStart();
    InstructionHandle jh = fresh.getStart();
    LinkedList exnList = new LinkedList();
    Map localVariableStarts = new HashMap();
    Map localVariableEnds = new HashMap();
    int currLine = -1;
    while (ih != null) {
        if (map.get(ih) == null) {
            Range r = Range.getRange(ih);
            if (r instanceof ExceptionRange) {
                ExceptionRange er = (ExceptionRange) r;
                if (er.getStart() == ih) {
                    insertHandler(er, exnList);
                }
            } else {
            }
            ih = ih.getNext();
        } else {
            Instruction i = ih.getInstruction();
            Instruction j = jh.getInstruction();
            if (i instanceof BranchInstruction) {
                BranchInstruction bi = (BranchInstruction) i;
                BranchInstruction bj = (BranchInstruction) j;
                InstructionHandle itarget = bi.getTarget();
                bj.setTarget(remap(itarget, map));
                if (bi instanceof Select) {
                    InstructionHandle[] itargets = ((Select) bi).getTargets();
                    InstructionHandle[] jtargets = ((Select) bj).getTargets();
                    for (int k = itargets.length - 1; k >= 0; k--) {
                        jtargets[k] = remap(itargets[k], map);
                        jtargets[k].addTargeter(bj);
                    }
                }
            }
            InstructionTargeter[] targeters = ih.getTargeters();
            if (targeters != null) {
                for (int k = targeters.length - 1; k >= 0; k--) {
                    InstructionTargeter targeter = targeters[k];
                    if (targeter instanceof LineNumberTag) {
                        int line = ((LineNumberTag) targeter).getLineNumber();
                        if (line != currLine) {
                            gen.addLineNumber(jh, line);
                            currLine = line;
                        }
                    } else if (targeter instanceof LocalVariableTag) {
                        LocalVariableTag lvt = (LocalVariableTag) targeter;
                        if (i instanceof LocalVariableInstruction) {
                            int index = ((LocalVariableInstruction) i).getIndex();
                            if (lvt.getSlot() == index) {
                                if (localVariableStarts.get(lvt) == null) {
                                    localVariableStarts.put(lvt, jh);
                                }
                                localVariableEnds.put(lvt, jh);
                            }
                        }
                    }
                }
            }
            ih = ih.getNext();
            jh = jh.getNext();
        }
    }
    for (Iterator iter = exnList.iterator(); iter.hasNext(); ) {
        ExceptionRange r = (ExceptionRange) iter.next();
        if (r.isEmpty())
            continue;
        gen.addExceptionHandler(remap(r.getRealStart(), map), remap(r.getRealEnd(), map), remap(r.getHandler(), map), (r.getCatchType() == null) ? null : (ObjectType) BcelWorld.makeBcelType(r.getCatchType()));
    }
    gen.removeLocalVariables();
    for (Iterator iter = localVariableStarts.keySet().iterator(); iter.hasNext(); ) {
        LocalVariableTag tag = (LocalVariableTag) iter.next();
        gen.addLocalVariable(tag.getName(), BcelWorld.makeBcelType(tag.getType()), tag.getSlot(), (InstructionHandle) localVariableStarts.get(tag), (InstructionHandle) localVariableEnds.get(tag));
    }
}

Output:
                 if (er.getStart() == ih) {
-                    insertHandler(er, exnList);
+                    if (!er.isEmpty()) {
+                        insertHandler(er, exnList);
+                    }
                 }


Input:
private boolean validateScalarParameter(ScalarParameterHandle paramHandle) throws ParameterValidationException {
    String paramName = paramHandle.getName();
    Object paramValue = runValues.get(paramName);
    String type = paramHandle.getDataType();
    if (paramValue == null) {
        if (!paramHandle.isRequired())
            return true;
        throw new ParameterValidationException(MessageConstants.PARAMETER_IS_NULL_EXCEPTION, new String[] { paramName });
    }
    String source = paramHandle.getValidate();
    if (source != null && source.length() != 0) {
        try {
            Object result = executionContext.evaluate(source);
            if (!(result instanceof Boolean) || !((Boolean) result).booleanValue()) {
                throw new ParameterValidationException(MessageConstants.PARAMETER_VALIDATION_SCRIPT_RESULT_ERROR, new String[] { paramName });
            }
        } catch (ParameterValidationException pve) {
            throw pve;
        } catch (BirtException ex) {
            throw new ParameterValidationException(ex);
        }
    }
    String paramType = paramHandle.getParamType();
    if (DesignChoiceConstants.SCALAR_PARAM_TYPE_MULTI_VALUE.equals(paramType)) {
        if (paramValue instanceof Object[]) {
            boolean isValid = true;
            Object[] paramValueList = (Object[]) paramValue;
            for (int i = 0; i < paramValueList.length; i++) {
                if (paramValueList[i] != null) {
                    if (!validateParameterValueType(paramName, paramValueList[i], type, paramHandle)) {
                        isValid = false;
                    }
                }
            }
            return isValid;
        }
        throw new ParameterValidationException(MessageConstants.PARAMETER_TYPE_IS_INVALID_EXCEPTION, new String[] { paramName, "String_Node_Str", paramValue.getClass().getName() });
    } else {
        return validateParameterValueType(paramName, paramValue, type, paramHandle);
    }
}

Output:
             if (!(result instanceof Boolean) || !((Boolean) result).booleanValue()) {
-                throw new ParameterValidationException(MessageConstants.PARAMETER_VALIDATION_SCRIPT_RESULT_ERROR, new String[] { paramName });
+                throw new ParameterValidationException(MessageConstants.PARAMETER_VALIDATION_FAILURE, new String[] { paramName });
             }


Input:
private void selectRootObject(Properties params) {
    IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
    if (page != null) {
        String perId = page.getPerspective().getId();
        if ((!"String_Node_Str".equals(perId) || null != perId) && perId.equalsIgnoreCase(PERSPECTIVE_DI_ID)) {
            IRepositoryView view = RepositoryManagerHelper.getRepositoryView();
            if (view != null) {
                Object type = params.get("String_Node_Str");
                if (ERepositoryObjectType.PROCESS.name().equals(type)) {
                    IRepositoryNode processNode = ((ProjectRepositoryNode) view.getRoot()).getRootRepositoryNode(ERepositoryObjectType.PROCESS);
                    if (processNode != null) {
                        setWorkbenchPart(view);
                        final StructuredViewer viewer = view.getViewer();
                        if (viewer instanceof TreeViewer) {
                            ((TreeViewer) viewer).expandToLevel(processNode, 1);
                        }
                        viewer.setSelection(new StructuredSelection(processNode));
                    }
                }
            }
        }
    }
}

Output:
 private void selectRootObject(Properties params) {
-    IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
-    if (page != null) {
-        String perId = page.getPerspective().getId();
-        if ((!"String_Node_Str".equals(perId) || null != perId) && perId.equalsIgnoreCase(PERSPECTIVE_DI_ID)) {
-            IRepositoryView view = RepositoryManagerHelper.getRepositoryView();
-            if (view != null) {
-                Object type = params.get("String_Node_Str");
-                if (ERepositoryObjectType.PROCESS.name().equals(type)) {
-                    IRepositoryNode processNode = ((ProjectRepositoryNode) view.getRoot()).getRootRepositoryNode(ERepositoryObjectType.PROCESS);
-                    if (processNode != null) {
-                        setWorkbenchPart(view);
-                        final StructuredViewer viewer = view.getViewer();
-                        if (viewer instanceof TreeViewer) {
-                            ((TreeViewer) viewer).expandToLevel(processNode, 1);
-                        }
-                        viewer.setSelection(new StructuredSelection(processNode));
-                    }
+    IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+    if (null == workbenchWindow) {
+        return;
+    }
+    IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
+    if (null == workbenchPage) {
+        return;
+    }
+    IPerspectiveDescriptor currentPerspective = workbenchPage.getPerspective();
+    if (!IBrandingConfiguration.PERSPECTIVE_DI_ID.equals(currentPerspective.getId())) {
+        try {
+            workbenchWindow.getWorkbench().showPerspective(IBrandingConfiguration.PERSPECTIVE_DI_ID, workbenchWindow);
+            workbenchPage = workbenchWindow.getActivePage();
+        } catch (WorkbenchException e) {
+            ExceptionHandler.process(e);
+            return;
+        }
+    }
+    IRepositoryView view = RepositoryManagerHelper.getRepositoryView();
+    if (view != null) {
+        Object type = params.get("String_Node_Str");
+        if (ERepositoryObjectType.PROCESS.name().equals(type)) {
+            IRepositoryNode processNode = ((ProjectRepositoryNode) view.getRoot()).getRootRepositoryNode(ERepositoryObjectType.PROCESS);
+            if (processNode != null) {
+                setWorkbenchPart(view);
+                final StructuredViewer viewer = view.getViewer();
+                if (viewer instanceof TreeViewer) {
+                    ((TreeViewer) viewer).expandToLevel(processNode, 1);
                 }


Input:
public void ajustHeight(Widget aChild, int aValue) {
    if (aChild != null) {
        aChild.setPixelSize(Sizer.getWidgetWidth(aChild), aValue);
    }
}

Output:
     if (aChild != null) {
-        aChild.setPixelSize(Sizer.getWidgetWidth(aChild), aValue);
+        if (aChild.getParent() instanceof PlatypusFieldSet)
+            aChild.getParent().setPixelSize(Sizer.getWidgetWidth(aChild), aValue);
+        else
+            aChild.setPixelSize(Sizer.getWidgetWidth(aChild), aValue);
     }


Input:
public Result delete(byte[] key) {
    if (key == null) {
        return Result.getFailed(KernelErrorCode.NULL_PARAMETER);
    }
    batchDelete.add(key);
    return Result.getSuccess();
}

Output:
     }
-    batchDelete.add(key);
+    batchList.add(Maps.immutableEntry(key, (byte[]) null));
     return Result.getSuccess();


Input:
public Subscription monitor(Consumer<? super T> action) {
    monitors.add(action);
    if (getValue() != null)
        action.accept(getValue());
    return () -> monitors.remove(action);
}

Output:
     monitors.add(action);
-    if (getValue() != null)
-        action.accept(getValue());
+    action.accept(getValue());
     return () -> monitors.remove(action);


Input:
private ExchangeClient getSharedClient(URL url) {
    String key = url.getAddress();
    ReferenceCountExchangeClient client = referenceClientMap.get(key);
    if (client != null) {
        if (!client.isClosed()) {
            client.incrementAndGetCount();
            return client;
        } else {
            referenceClientMap.remove(key);
        }
    }
    ExchangeClient exchagneclient = initClient(url);
    client = new ReferenceCountExchangeClient(exchagneclient, ghostClientMap);
    referenceClientMap.put(key, client);
    ghostClientMap.remove(key);
    return client;
}

Output:
     }
-    ExchangeClient exchagneclient = initClient(url);
-    client = new ReferenceCountExchangeClient(exchagneclient, ghostClientMap);
-    referenceClientMap.put(key, client);
-    ghostClientMap.remove(key);
-    return client;
+    synchronized (key.intern()) {
+        ExchangeClient exchangeClient = initClient(url);
+        client = new ReferenceCountExchangeClient(exchangeClient, ghostClientMap);
+        referenceClientMap.put(key, client);
+        ghostClientMap.remove(key);
+        return client;
+    }
 }


Input:
public void onTestActionStart(TestCase testCase, TestAction testAction) {
    if (!testAction.getClass().equals(SleepAction.class)) {
        LOG.debug(testCase.getName() + "String_Node_Str" + StringUtils.arrayToCommaDelimitedString(getParameters(testCase)) + "String_Node_Str" + testAction.getName() + "String_Node_Str" + (StringUtils.hasText(testAction.getDescription()) ? testAction.getDescription() : "String_Node_Str"));
        executionService.createTestAction(testCase, testAction);
    }
}

Output:
 public void onTestActionStart(TestCase testCase, TestAction testAction) {
-    if (!testAction.getClass().equals(SleepAction.class)) {
+    if (!ignoreTestAction(testAction)) {
         LOG.debug(testCase.getName() + "String_Node_Str" + StringUtils.arrayToCommaDelimitedString(getParameters(testCase)) + "String_Node_Str" + testAction.getName() + "String_Node_Str" + (StringUtils.hasText(testAction.getDescription()) ? testAction.getDescription() : "String_Node_Str"));


Input:
public void add(double lat, double lon, long time, T t, Optional<Long> expiryTime) {
    String hash = GeoHash.encodeHash(lat, lon);
    for (int i = 1; i <= hash.length(); i++) {
        long key = Base32.decodeBase32(hash.substring(0, i));
        if (map.get(key) == null) {
            map.put(key, new ConcurrentSkipListMap<Long, Info<T>>());
        }
        map.get(key).put(time, new Info<T>(key, lat, lon, time, t));
    }
}

Output:
     String hash = GeoHash.encodeHash(lat, lon);
-    for (int i = 1; i <= hash.length(); i++) {
-        long key = Base32.decodeBase32(hash.substring(0, i));
-        if (map.get(key) == null) {
-            map.put(key, new ConcurrentSkipListMap<Long, Info<T>>());
-        }
-        map.get(key).put(time, new Info<T>(key, lat, lon, time, t));
-    }
+    addToMap(map, lat, lon, time, t, hash);
+    addToMapById(lat, lon, time, t, id, hash);
 }


Input:
public void createSimpleA() {
    DynamicType simpleTypeA = dynamicHelper.getType("String_Node_Str");
    Assert.assertNotNull(simpleTypeA);
    DynamicEntity a = simpleTypeA.newDynamicEntity();
    assertNotNull(a);
    assertEquals(((Number) a.get("String_Node_Str")).intValue(), 0);
    assertFalse(a.isSet("String_Node_Str"));
    assertFalse(a.isSet("String_Node_Str"));
    assertFalse(a.isSet("String_Node_Str"));
    DynamicType typeC = dynamicHelper.getType("String_Node_Str");
    assertEquals(a.get("String_Node_Str").getClass(), typeC.newDynamicEntity().getClass());
    DynamicEntity c = a.<DynamicEntity>get("String_Node_Str");
    assertNotNull(c);
    assertEquals(((Number) c.get("String_Node_Str")).doubleValue(), 0.0);
    assertFalse(c.isSet("String_Node_Str"));
}

Output:
     assertEquals(a.get("String_Node_Str").getClass(), typeC.newDynamicEntity().getClass());
-    DynamicEntity c = a.<DynamicEntity>get("String_Node_Str");
+    DynamicEntity c = a.get("String_Node_Str");
     assertNotNull(c);


Input:
public List<Var> tryPiggyBack(Counters<Var> increments, RefCountType type, boolean decrement) {
    List<Var> result = new ArrayList<Var>();
    for (RefCount startIncr : startIncrements) {
        if (startIncr.type == type) {
            long incr = increments.getCount(startIncr.var);
            if ((decrement && incr < 0) || (!decrement && incr > 0)) {
                addConstantStartIncrement(startIncr.var, type, Arg.createIntLit(incr));
                result.add(startIncr.var);
            }
        }
    }
    return result;
}

Output:
             long incr = increments.getCount(startIncr.var);
-            if ((decrement && incr < 0) || (!decrement && incr > 0)) {
+            if ((dir == RCDir.DECR && incr < 0) || (dir == RCDir.INCR && incr > 0)) {
                 addConstantStartIncrement(startIncr.var, type, Arg.createIntLit(incr));


Input:
public Plan getPlan(String... args) {
    if (args.length != 3) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    int noSubTasks = Integer.parseInt(args[0]);
    String edgeInput = args[1];
    String output = args[2];
    DataSourceContract<Edge, PactNull> edges = new DataSourceContract<Edge, PactNull>(EdgeListInFormat.class, edgeInput);
    edges.setFormatParameter("String_Node_Str", "String_Node_Str");
    edges.setDegreeOfParallelism(noSubTasks);
    edges.setOutputContract(UniqueKey.class);
    MapContract<Edge, PactNull, PactString, Edge> assignKeys = new MapContract<Edge, PactNull, PactString, Edge>(AssignKeys.class, "String_Node_Str");
    assignKeys.setDegreeOfParallelism(noSubTasks);
    ReduceContract<PactString, Edge, Edge, EdgeList> buildTriads = new ReduceContract<PactString, Edge, Edge, EdgeList>(BuildTriads.class, "String_Node_Str");
    buildTriads.setDegreeOfParallelism(noSubTasks);
    MatchContract<Edge, EdgeList, PactNull, PactNull, EdgeList> closeTriads = new MatchContract<Edge, EdgeList, PactNull, PactNull, EdgeList>(CloseTriads.class, "String_Node_Str");
    closeTriads.setDegreeOfParallelism(noSubTasks);
    closeTriads.getStubParameters().setString(PactCompiler.HINT_LOCAL_STRATEGY, PactCompiler.HINT_LOCAL_STRATEGY_SORT);
    DataSinkContract<PactNull, EdgeList> triangles = new DataSinkContract<PactNull, EdgeList>(EdgeListOutFormat.class, output);
    triangles.setDegreeOfParallelism(noSubTasks);
    triangles.setInput(closeTriads);
    closeTriads.setSecondInput(edges);
    closeTriads.setFirstInput(buildTriads);
    buildTriads.setInput(assignKeys);
    assignKeys.setInput(edges);
    return new Plan(triangles, "String_Node_Str");
}

Output:
 public Plan getPlan(String... args) {
-    if (args.length != 3) {
-        throw new IllegalArgumentException("String_Node_Str");
-    }
-    int noSubTasks = Integer.parseInt(args[0]);
-    String edgeInput = args[1];
-    String output = args[2];
+    int noSubTasks = (args.length > 0 ? Integer.parseInt(args[0]) : 1);
+    String edgeInput = (args.length > 1 ? args[1] : "String_Node_Str");
+    String output = (args.length > 2 ? args[2] : "String_Node_Str");
     DataSourceContract<Edge, PactNull> edges = new DataSourceContract<Edge, PactNull>(EdgeListInFormat.class, edgeInput);


Input:
public Retrieve visitRetrieve(cqlParser.RetrieveContext ctx) {
    String model = parseString(ctx.topic().namedTypeSpecifier().modelIdentifier());
    String topic = parseString(ctx.topic().namedTypeSpecifier().identifier());
    ClassType classType = resolveTopic(model, topic);
    NamedType namedType = classType;
    if (namedType == null) {
        namedType = (NamedType) resolveTypeName(model, topic);
        if (namedType == null) {
            throw new IllegalArgumentException(String.format("String_Node_Str", topic));
        }
    }
    Retrieve retrieve = of.createRetrieve().withDataType(dataTypeToQName((DataType) namedType)).withTemplateId(classType != null ? classType.getIdentifier() : topic);
    if (ctx.valueset() != null) {
        if (ctx.valuesetPathIdentifier() != null) {
            retrieve.setCodeProperty(parseString(ctx.valuesetPathIdentifier()));
        } else if (classType != null && classType.getPrimaryCodePath() != null) {
            retrieve.setCodeProperty(classType.getPrimaryCodePath());
        }
        List<String> identifiers = (List<String>) visit(ctx.valueset());
        retrieve.setCodes(resolveQualifiedIdentifier(identifiers));
    }
    retrieves.add(retrieve);
    retrieve.setResultType(new ListType((DataType) namedType));
    return retrieve;
}

Output:
     if (namedType == null) {
-        namedType = (NamedType) resolveTypeName(model, topic);
-        if (namedType == null) {
-            throw new IllegalArgumentException(String.format("String_Node_Str", topic));
-        }
+        throw new IllegalArgumentException(String.format("String_Node_Str", topic));
     }


Input:
public void init() {
    loadConfigration();
    accountService = NulsContext.getServiceBean(AccountService.class);
    List<Account> list = this.accountService.getAccountList();
    boolean noneAccount = list == null || list.isEmpty();
    if (this.partakePacking && noneAccount) {
        Account account = this.accountService.createAccount("String_Node_Str");
        this.accountService.setDefaultAccount(account.getAddress().getBase58());
        NulsContext.LOCAL_ADDRESS_LIST.add(account.getAddress().getBase58());
    }
    blockCacheManager = BlockCacheManager.getInstance();
    blockCacheManager.init();
    consensusCacheManager = ConsensusCacheManager.getInstance();
    consensusCacheManager.init();
    confirmingTxCacheManager = ConfirmingTxCacheManager.getInstance();
    confirmingTxCacheManager.init();
    receivedTxCacheManager = ReceivedTxCacheManager.getInstance();
    receivedTxCacheManager.init();
    TaskManager.createAndRunThread(NulsConstant.MODULE_ID_CONSENSUS, "String_Node_Str", this);
}

Output:
     if (this.partakePacking && noneAccount) {
-        Account account = this.accountService.createAccount("String_Node_Str");
+        Account account = this.accountService.createAccount(PocConsensusConstant.DEFAULT_WALLET_PASSWORD);
         this.accountService.setDefaultAccount(account.getAddress().getBase58());


Input:
private void setMemPhaseResourceUsage(List<TaskOutputDetails> taskDetails, Map<Long, IntervalStats> statsMap, JobOutput jobOutput, String jobID, PhaseType phase) throws UnknownHostException {
    IntervalStats intervalStats;
    List<Float> cpuPer;
    List<Float> memPer;
    float maxPhaseMem = 0;
    float totalPhaseCpu = 0;
    int interval = 0;
    Map<NodeSystemStats, Float> memStatsMap = new HashMap<NodeSystemStats, Float>();
    int minStartPoint = -1, maxEndPoint = 0;
    YamlLoader yamlLoader = (YamlLoader) loader;
    YamlConfig yamlConfig = (YamlConfig) yamlLoader.getYamlConfiguration();
    Remoter remoter = RemotingUtil.getRemoter(yamlLoader, null);
    CommandWritableBuilder builder = new CommandWritableBuilder();
    String remoteHadoop = RemotingUtil.getHadoopHome(remoter, yamlConfig) + File.separator;
    String user = yamlConfig.getMaster().getUser();
    SupportedHadoopDistributions hadoopVersion = RemotingUtil.getHadoopVersion(yamlConfig);
    String logsHistory = changeLogHistoryPathAccToHadoopVersion(remoteHadoop, hadoopVersion, user);
    String command = jobID + RemotingConstants.SINGLE_SPACE + logsHistory;
    builder.addCommand(command, false, null, CommandType.FS).setApiInvokeHints(ApiInvokeHintsEnum.GET_HADOOP_CONFIG);
    String configFilePath = (String) remoter.fireCommandAndGetObjectResponse(builder.getCommandWritable());
    String destinationReceiveDir = RemotingUtil.copyAndGetHadoopConfigurationFilePath(configFilePath, loader);
    for (TaskOutputDetails tod : taskDetails) {
        String location = convertHostNameToIP(tod.getLocation());
        float mem = tod.getResourceUsageMetrics().getPhysicalMemoryUsage();
        minStartPoint = setMinStartPoint(minStartPoint, tod.getStartPoint());
        long start = minStartPoint;
        maxEndPoint = setMaxEndPoint(maxEndPoint, tod.getEndPoint());
        long end = maxEndPoint;
        long startPt = Math.max(start, DELAY_INTERVAL);
        float memoryStats = 0.0f;
        String jvmChildOpts = null;
        if (PhaseType.REDUCE.equals(phase)) {
            jvmChildOpts = RemotingUtil.parseConfiguration(destinationReceiveDir, "String_Node_Str");
            if (jvmChildOpts == null) {
                jvmChildOpts = RemotingUtil.parseConfiguration(destinationReceiveDir, "String_Node_Str");
            }
        } else {
            jvmChildOpts = RemotingUtil.parseConfiguration(destinationReceiveDir, "String_Node_Str");
            if (jvmChildOpts == null) {
                jvmChildOpts = RemotingUtil.parseConfiguration(destinationReceiveDir, "String_Node_Str");
            }
        }
        if (jvmChildOpts != null) {
            int childOptsVal = ConfigurationUtil.getJavaOptsinMB(jvmChildOpts);
            memoryStats = ((mem / (childOptsVal * 1024 * 1024)) * 100);
            int avg = (int) (tod.getEndPoint() - startPt) / 2;
            interval = (int) (avg + startPt);
            maxPhaseMem = setMaxPhaseMemory(memoryStats, maxPhaseMem);
        }
    }
    if (statsMap.containsKey(interval)) {
        intervalStats = statsMap.get(interval);
        cpuPer = intervalStats.getCpuStats();
        memPer = intervalStats.getMemStats();
    } else {
        intervalStats = new IntervalStats();
        cpuPer = new ArrayList<Float>();
        memPer = new ArrayList<Float>();
    }
    setIntervalStats(statsMap, 0.0f, maxPhaseMem, intervalStats, cpuPer, memPer, interval);
}

Output:
     String configFilePath = (String) remoter.fireCommandAndGetObjectResponse(builder.getCommandWritable());
-    String destinationReceiveDir = RemotingUtil.copyAndGetHadoopConfigurationFilePath(configFilePath, loader);
+    String fileName = configFilePath.substring(configFilePath.lastIndexOf(File.separator) + 1);
+    configFilePath = configFilePath.substring(0, configFilePath.lastIndexOf(File.separator) + 1);
+    String configurationFilePath = RemotingUtil.copyAndGetConfigurationFilePath(loader, configFilePath, fileName) + File.separator + fileName;
     for (TaskOutputDetails tod : taskDetails) {


Input:
private void parseGroup(XMLExtendedStreamReader reader, ModelNode op, boolean wildcard) throws XMLStreamException {
    parseAttributes(reader, op, attributesByGroup.get(reader.getLocalName()), wildcard);
    if (reader.hasNext()) {
        if (reader.nextTag() == START_ELEMENT && attributeElements.containsKey(reader.getLocalName())) {
            AttributeDefinition ad = attributeElements.get(reader.getLocalName());
            ad.getParser().parseElement(ad, reader, op);
            ParseUtils.requireNoContent(reader);
        } else if (reader.getEventType() != END_ELEMENT) {
            throw ParseUtils.unexpectedElement(reader);
        }
    }
}

Output:
 private void parseGroup(XMLExtendedStreamReader reader, ModelNode op, boolean wildcard) throws XMLStreamException {
-    parseAttributes(reader, op, attributesByGroup.get(reader.getLocalName()), wildcard);
-    if (reader.hasNext()) {
-        if (reader.nextTag() == START_ELEMENT && attributeElements.containsKey(reader.getLocalName())) {
+    Map<String, AttributeDefinition> groupAttrs = attributesByGroup.get(reader.getLocalName());
+    parseAttributes(reader, op, groupAttrs, wildcard);
+    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
+        String attrName = reader.getLocalName();
+        if (attributeElements.containsKey(attrName) && groupAttrs.containsKey(attrName)) {
             AttributeDefinition ad = attributeElements.get(reader.getLocalName());


Input:
private static AFPChain splitBlocksByTopology(AFPChain a, Atom[] ca1, Atom[] ca2) throws StructureException {
    int[][][] optAln = a.getOptAln();
    int blockNum = a.getBlockNum();
    int[] optLen = a.getOptLen();
    List<Integer> newBlkLen = new ArrayList<Integer>();
    boolean blockChanged = false;
    for (int blk = 0; blk < blockNum; blk++) {
        int currLen = 1;
        for (int pos = 1; pos < optLen[blk]; pos++) {
            if (optAln[blk][0][pos] <= optAln[blk][0][pos - 1] || optAln[blk][1][pos] <= optAln[blk][1][pos - 1]) {
                newBlkLen.add(currLen);
                currLen = 0;
                blockChanged = true;
            }
            currLen++;
        }
        if (optLen[blk] < 2) {
            newBlkLen.add(optLen[blk]);
        } else {
            newBlkLen.add(currLen);
        }
    }
    if (!blockChanged) {
        return a;
    }
    List<int[][]> blocks = new ArrayList<int[][]>(newBlkLen.size());
    int oldBlk = 0;
    int pos = 0;
    for (int blkLen : newBlkLen) {
        if (blkLen == optLen[oldBlk]) {
            assert (pos == 0);
            blocks.add(optAln[oldBlk]);
        } else {
            int[][] newBlock = new int[2][blkLen];
            assert (pos + blkLen <= optLen[oldBlk]);
            for (int i = 0; i < blkLen; i++) {
                newBlock[0][i] = optAln[oldBlk][0][pos + i];
                newBlock[1][i] = optAln[oldBlk][1][pos + i];
            }
            pos += blkLen;
            blocks.add(newBlock);
            if (pos == blkLen) {
                oldBlk++;
                pos = 0;
            }
        }
    }
    int[][][] newOptAln = blocks.toArray((int[][][]) null);
    int[] newBlockLens = new int[newBlkLen.size()];
    for (int i = 0; i < newBlkLen.size(); i++) {
        newBlockLens[i] = newBlkLen.get(i);
    }
    return replaceOptAln(a, ca1, ca2, blocks.size(), newBlockLens, newOptAln);
}

Output:
             blocks.add(newBlock);
-            if (pos == blkLen) {
+            if (pos == optLen[oldBlk]) {
                 oldBlk++;


Input:
public int load(final MediaPlayer player, final Context context) {
    try {
        player.setDataSource(mAssetFd.getFileDescriptor(), mAssetFd.getStartOffset(), mAssetFd.getLength());
    } catch (Exception e) {
        Log.e(TAG, e.getMessage());
        return 0;
    }
    return 1;
}

Output:
     } catch (Exception e) {
-        Log.e(TAG, e.getMessage());
+        Log.e(TAG, "String_Node_Str" + e.getMessage());
         return 0;


Input:
public void receive(Event[] events) {
    EventPrinter.print(events);
    for (Event event : events) {
        switch(count.incrementAndGet()) {
            case 1:
                junit.framework.Assert.assertEquals(55.6f, event.getData(1));
                break;
            case 2:
                junit.framework.Assert.assertEquals(56.6f, event.getData(1));
                break;
            case 3:
                junit.framework.Assert.assertEquals(57.6f, event.getData(1));
                break;
            default:
                Assert.fail();
        }
    }
}

Output:
             case 1:
-                junit.framework.Assert.assertEquals(55.6f, event.getData(1));
+                Assert.assertEquals(55.6f, event.getData(1));
                 break;


Input:
protected DateTimeFormat getDayOfMonthFormatter() {
    return dayOfMonthFormatter;
}

Output:
 protected DateTimeFormat getDayOfMonthFormatter() {
-    return dayOfMonthFormatter;
+    return DateTimeFormat.getFormat("String_Node_Str");
 }


Input:
public void testUnregisterService() throws Exception {
    IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
    IRemoteServiceRegistration reg = registerService(adapters[0], IConcatService.class.getName(), createService(), 1500);
    assertNotNull(reg);
    assertNotNull(reg.getContainerID());
    reg.unregister();
}

Output:
 public void testUnregisterService() throws Exception {
-    IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
-    IRemoteServiceRegistration reg = registerService(adapters[0], IConcatService.class.getName(), createService(), 1500);
+    final IRemoteServiceContainerAdapter[] adapters = getRemoteServiceAdapters();
+    final IRemoteServiceRegistration reg = registerService(adapters[0], IConcatService.class.getName(), createService(), 1500);
     assertNotNull(reg);


Input:
public MiniHBaseCluster startMiniHBaseCluster(final int numMasters, final int numSlaves) throws IOException, InterruptedException {
    createRootDir();
    Configuration c = new Configuration(this.conf);
    this.hbaseCluster = new MiniHBaseCluster(c, numMasters, numSlaves);
    HTable t = new HTable(c, HConstants.META_TABLE_NAME);
    ResultScanner s = t.getScanner(new Scan());
    while (s.next() != null) {
        continue;
    }
    s.close();
    LOG.info("String_Node_Str");
    return this.hbaseCluster;
}

Output:
     this.hbaseCluster = new MiniHBaseCluster(c, numMasters, numSlaves);
-    HTable t = new HTable(c, HConstants.META_TABLE_NAME);
+    HTable t;
+    int regionAvailableTries = 0;
+    while (true) {
+        regionAvailableTries++;
+        try {
+            t = new HTable(c, HConstants.META_TABLE_NAME);
+            break;
+        } catch (NotServingRegionException e) {
+            if (regionAvailableTries > 10) {
+                throw new RuntimeException("String_Node_Str" + regionAvailableTries + "String_Node_Str");
+            } else {
+                Thread.sleep(50);
+            }
+        }
+    }
     ResultScanner s = t.getScanner(new Scan());


Input:
public static Iterator getColumnDataBindings(ReportItemHandle itemHandle, boolean unique) {
    if (itemHandle.getDataSet() != null || itemHandle.getCube() != null) {
        return itemHandle.columnBindingsIterator();
    }
    DesignElementHandle handle = getBindingHolder(itemHandle);
    if (handle instanceof ReportItemHandle) {
        Map<String, ComputedColumnHandle> bindingMap = new LinkedHashMap<String, ComputedColumnHandle>();
        ArrayList<ComputedColumnHandle> list = new ArrayList<ComputedColumnHandle>();
        Iterator i = ((ReportItemHandle) handle).columnBindingsIterator();
        while (i.hasNext()) {
            ComputedColumnHandle cch = (ComputedColumnHandle) i.next();
            list.add(cch);
            bindingMap.put(cch.getName(), cch);
        }
        if (handle != itemHandle) {
            i = itemHandle.columnBindingsIterator();
            while (i.hasNext()) {
                ComputedColumnHandle cch = (ComputedColumnHandle) i.next();
                list.add(cch);
                bindingMap.put(cch.getName(), cch);
            }
        }
        if (unique) {
            return bindingMap.values().iterator();
        } else
            return list.iterator();
    }
    return null;
}

Output:
     }
-    DesignElementHandle handle = getBindingHolder(itemHandle);
-    if (handle instanceof ReportItemHandle) {
-        Map<String, ComputedColumnHandle> bindingMap = new LinkedHashMap<String, ComputedColumnHandle>();
-        ArrayList<ComputedColumnHandle> list = new ArrayList<ComputedColumnHandle>();
-        Iterator i = ((ReportItemHandle) handle).columnBindingsIterator();
+    ReportItemHandle handle = getBindingHolder(itemHandle);
+    if (handle == null) {
+        return null;
+    }
+    Map<String, ComputedColumnHandle> bindingMap = new LinkedHashMap<String, ComputedColumnHandle>();
+    ArrayList<ComputedColumnHandle> list = new ArrayList<ComputedColumnHandle>();
+    Iterator i = handle.columnBindingsIterator();
+    while (i.hasNext()) {
+        ComputedColumnHandle cch = (ComputedColumnHandle) i.next();
+        list.add(cch);
+        bindingMap.put(cch.getName(), cch);
+    }
+    if (handle != itemHandle) {
+        i = itemHandle.columnBindingsIterator();
         while (i.hasNext()) {