Input:
protected Node fromConfigNode(ConfigNode cNode, Rectangle bounds, Map<String, ConfigLeaf> leavesById_OUT) {
    if (cNode instanceof ConfigSplit) {
        ConfigSplit cSplit = (ConfigSplit) cNode;
        int divPixels = splitPane.getDividerSize();
        int totalDivs = max(0, cSplit.childNodes.size() - 1);
        int totalContentPixels = (cSplit.isRow ? bounds.width : bounds.height) - totalDivs * divPixels;
        double totalContent = 0;
        for (ConfigNode cChild : cSplit.childNodes) {
            totalContent += cChild.extent;
        }
        int divsSoFar = 0;
        int startPixel = 0;
        double contentSoFar = 0;
        List<Node> children = newArrayList();
        for (ConfigNode cChild : cSplit.childNodes) {
            if (!children.isEmpty()) {
                int xDiv = (cSplit.isRow ? startPixel : 0);
                int yDiv = (cSplit.isRow ? 0 : startPixel);
                int wDiv = (cSplit.isRow ? divPixels : bounds.width);
                int hDiv = (cSplit.isRow ? bounds.height : divPixels);
                Divider divider = new Divider();
                divider.setBounds(new Rectangle(xDiv, yDiv, wDiv, hDiv));
                children.add(divider);
                startPixel += divPixels;
                divsSoFar++;
            }
            int endPixel = iround(((contentSoFar + cChild.extent) / totalContent) * totalContentPixels) + divsSoFar * divPixels;
            int xChild = (cSplit.isRow ? startPixel : 0);
            int yChild = (cSplit.isRow ? 0 : startPixel);
            int wChild = (cSplit.isRow ? endPixel - startPixel : bounds.width);
            int hChild = (cSplit.isRow ? bounds.height : endPixel - startPixel);
            Node child = fromConfigNode(cChild, new Rectangle(xChild, yChild, wChild, hChild), leavesById_OUT);
            children.add(child);
            startPixel = endPixel;
            contentSoFar += cChild.extent;
        }
        Split split = (cSplit.isRow ? new RowSplit() : new ColSplit());
        split.setChildren(children);
        split.setBounds(bounds);
        return split;
    } else if (cNode instanceof ConfigLeaf) {
        ConfigLeaf cLeaf = (ConfigLeaf) cNode;
        String leafId = nextLeafId();
        leavesById_OUT.put(leafId, cLeaf);
        Leaf leaf = new Leaf(leafId);
        leaf.setBounds(bounds);
        return leaf;
    } else {
        throw new RuntimeException("String_Node_Str" + cNode.getClass().getName());
    }
}

Output:
             if (!children.isEmpty()) {
-                int xDiv = (cSplit.isRow ? startPixel : 0);
-                int yDiv = (cSplit.isRow ? 0 : startPixel);
+                int xDiv = (cSplit.isRow ? startPixel : 0) + bounds.x;
+                int yDiv = (cSplit.isRow ? 0 : startPixel) + bounds.y;
                 int wDiv = (cSplit.isRow ? divPixels : bounds.width);


Input:
private void updateCertificate(EbicsCertificate cert) {
    if (cert == null) {
        return;
    }
    String pem = cert.getPemString();
    if (pem == null) {
        return;
    }
    try {
        X509Certificate certificate = certificateService.convertToCertificate(pem);
        certificateService.updateCertificate(certificate, cert);
    } catch (IOException | CertificateEncodingException e) {
        e.printStackTrace();
    }
}

Output:
         X509Certificate certificate = certificateService.convertToCertificate(pem);
-        certificateService.updateCertificate(certificate, cert);
+        certificateService.updateCertificate(certificate, cert, false);
     } catch (IOException | CertificateEncodingException e) {


Input:
public boolean shouldShowExcerpt() {
    return isJetpack && useExcerpt;
}

Output:
 public boolean shouldShowExcerpt() {
-    return isJetpack && useExcerpt;
+    return isJetpack && useExcerpt && hasExcerpt();
 }


Input:
public Integer getPlayOrder() {
    int matchNumber = getMatchNumber(), setNumber = getSetNumber();
    return type.getPlayOrder() * 1000000 + matchNumber * 1000 + setNumber;
}

Output:
     int matchNumber = getMatchNumber(), setNumber = getSetNumber();
-    return type.getPlayOrder() * 1000000 + matchNumber * 1000 + setNumber;
+    return getType().getPlayOrder() * 1000000 + matchNumber * 1000 + setNumber;
 }


Input:
public final int computeTicks(IDisplayServer xs, Label la, int iLabelLocation, int iOrientation, double dStart, double dEnd, boolean bConsiderStartLabel, boolean bConsiderEndLabel, AllAxes aax) throws ChartException {
    boolean bMaxIsNotIntegralMultipleOfStep = false;
    int nTicks = 0;
    double dLength = 0;
    double dTickGap = 0;
    int iDirection = (iScaleDirection == AUTO) ? ((iOrientation == HORIZONTAL) ? FORWARD : BACKWARD) : iScaleDirection;
    if (bConsiderStartLabel || bConsiderEndLabel) {
        computeAxisStartEndShifts(xs, la, iOrientation, iLabelLocation, aax);
        if (!bLabelWithinAxes && bConsiderStartLabel) {
            double dNewStart = dStart + dStartShift * iDirection;
            if (dEnd > dStart && dNewStart > dEnd - 1) {
                dNewStart = dEnd - 1;
            } else if (dEnd < dStart && dNewStart < dEnd + 1) {
                dNewStart = dEnd + 1;
            }
            dStartShift = (dNewStart - dStart) / iDirection;
            dStart = dNewStart;
        }
        if (bConsiderEndLabel) {
            double dNewEnd = dEnd + dEndShift * -iDirection;
            if (dEnd > dStart && dNewEnd < dStart + 1) {
                dNewEnd = dStart + 1;
            } else if (dEnd < dStart && dNewEnd > dStart - 1) {
                dNewEnd = dStart - 1;
            }
            dEndShift = (dNewEnd - dEnd) / -iDirection;
            dEnd = dNewEnd;
        }
    }
    this.dStart = dStart;
    this.dEnd = dEnd;
    if (isSetFactor()) {
        double step = Methods.asDouble(getStep()).doubleValue();
        dTickGap = step / getFactor();
        int stepNum = (int) (Math.abs(dStart - dEnd) / dTickGap);
        AxisTickCoordinates atc = new AxisTickCoordinates(stepNum + 1, dStart, dStart < dEnd ? dStart + dTickGap * stepNum : dStart - dTickGap * stepNum, dTickGap * iDirection, true);
        setTickCordinates(atc);
        checkTickLabelsVisibility(xs, la, iLabelLocation);
        return stepNum + 1;
    }
    nTicks = getTickCount();
    dLength = Math.abs(dStart - dEnd);
    if (!bCategoryScale && (iType & NUMERICAL) == NUMERICAL && (iType & LINEAR) == LINEAR) {
        double dMax = asDouble(oMaximum).doubleValue();
        double dMin = asDouble(oMinimum).doubleValue();
        double dStep = asDouble(oStep).doubleValue();
        bMaxIsNotIntegralMultipleOfStep = !ChartUtil.mathEqual(dMax / dStep, (int) (dMax / dStep));
        if (bStepFixed && oStepNumber != null) {
            dTickGap = dLength / (oStepNumber.intValue()) * iDirection;
        } else {
            double dStepSize = asDouble(oStep).doubleValue();
            dTickGap = Math.min(Math.abs(dStepSize / (dMax - dMin) * dLength), dLength) * iDirection;
        }
    } else {
        if (isTickBetweenCategories()) {
            dTickGap = dLength / (nTicks - 1) * iDirection;
        } else {
            dTickGap = dLength / (nTicks - 2) * iDirection;
        }
    }
    if (nTicks > TICKS_MAX && bStepFixed && !bCategoryScale) {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", Messages.getResourceBundle(rtc.getULocale()));
    }
    AxisTickCoordinates atc = new AxisTickCoordinates(nTicks, dStart, dEnd, dTickGap, !bCategoryScale || isTickBetweenCategories());
    setTickCordinates(null);
    setEndPoints(dStart, dEnd);
    setTickCordinates(atc);
    if (bStepFixed && oStepNumber == null && (nTicks > 2) && bMaxIsNotIntegralMultipleOfStep) {
        if (!checkFit(xs, la, iLabelLocation)) {
            nTicks--;
            AxisTickCoordinates atc1 = new AxisTickCoordinates(nTicks, dStart, dEnd, dTickGap, !bCategoryScale || isTickBetweenCategories());
            setTickCordinates(null);
            setTickCordinates(atc1);
        }
    }
    checkTickLabelsVisibility(xs, la, iLabelLocation);
    return nTicks;
}

Output:
         setTickCordinates(atc);
-        checkTickLabelsVisibility(xs, la, iLabelLocation);
+        checkTickLabelsVisibility(xs, la, iLabelLocation, iOrientation);
         return stepNum + 1;


Input:
public PlanarImage executeTransformOperation(PlanarImage image) {
    BufferedImage bi = image.getAsBufferedImage();
    Graphics2D graphics = (Graphics2D) bi.getGraphics();
    for (int i = 0; i < instructions.size(); i++) {
        ImageOperation instr = ((ImageOperation) instructions.elementAt(i));
        if (instr instanceof DrawOperation) {
            PlanarImage op = ((DrawOperation) instr).executeDrawOperation();
            log("String_Node_Str" + xloc + "String_Node_Str" + yloc);
            graphics.drawImage(op.getAsBufferedImage(), null, xloc, yloc);
        } else if (instr instanceof TransformOperation) {
            PlanarImage op = ((TransformOperation) instr).executeTransformOperation(null);
            BufferedImage child = op.getAsBufferedImage();
            log("String_Node_Str" + xloc + "String_Node_Str" + yloc);
            graphics.drawImage(child, null, xloc, yloc);
            PlanarImage test = PlanarImage.wrapRenderedImage(bi);
        }
    }
    image = PlanarImage.wrapRenderedImage(bi);
    return image;
}

Output:
             graphics.drawImage(child, null, xloc, yloc);
-            PlanarImage test = PlanarImage.wrapRenderedImage(bi);
+            PlanarImage.wrapRenderedImage(bi);
         }


Input:
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
    Permanent creature = ((EntersTheBattlefieldEvent) event).getTarget();
    Map<String, Integer> spellX = (Map<String, Integer>) game.getState().getValue("String_Node_Str" + source.getSourceId());
    MageObject sourceObject = source.getSourceObject(game);
    if (sourceObject != null && creature != null && spellX != null) {
        String key = event.getSourceId().toString() + (game.getState().getZoneChangeCounter(event.getSourceId()) - 1);
        int xValue = spellX.get(key);
        if (xValue > 0) {
            creature.addCounters(CounterType.P1P1.createInstance(xValue), source, game);
            game.informPlayers(sourceObject.getLogName() + "String_Node_Str" + creature.getLogName() + "String_Node_Str" + xValue + "String_Node_Str" + (xValue > 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
        }
        spellX.remove(key);
    }
    return false;
}

Output:
         if (xValue > 0) {
-            creature.addCounters(CounterType.P1P1.createInstance(xValue), source, game);
+            creature.addCounters(CounterType.P1P1.createInstance(xValue), source, game, event.getAppliedEffects());
             game.informPlayers(sourceObject.getLogName() + "String_Node_Str" + creature.getLogName() + "String_Node_Str" + xValue + "String_Node_Str" + (xValue > 1 ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");


Input:
private void initAccessory(UsbAccessory accessory) {
    FileDescriptor fd = null;
    try {
        fd = UsbManager.getInstance(this).openAccessory(accessory).getFileDescriptor();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
        finish();
    } catch (NullPointerException e) {
        e.printStackTrace();
        finish();
    }
    mFout = new FileOutputStream(fd);
    mFin = new FileInputStream(fd);
    mADKReader = new ADKReader(mFin, new UIUpdater());
    mADKWriter = new ADKWriter(mFout);
    widgetsAvailable(true);
    mADKReader.start();
}

Output:
     mFin = new FileInputStream(fd);
-    mADKReader = new ADKReader(mFin, new UIUpdater());
+    mADKReader = new ADKReader(mFin, new UIUpdater(), this, accessory);
     mADKWriter = new ADKWriter(mFout);


Input:
public void onFailure(Throwable t) {
    if (t instanceof HazelcastClientNotActiveException) {
        shutdownLatch.countDown();
    }
    errorLatch.countDown();
}

Output:
 public void onFailure(Throwable t) {
-    if (t instanceof HazelcastClientNotActiveException) {
+    if (t.getCause() instanceof HazelcastClientNotActiveException) {
         shutdownLatch.countDown();


Input:
public void testLocalVar7() {
    String contents = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    int offset = contents.indexOf("String_Node_Str");
    assertType(contents, offset, offset + 1, "String_Node_Str");
    offset = contents.indexOf("String_Node_Str", offset + 1);
    assertType(contents, offset, offset + 1, "String_Node_Str");
    offset = contents.indexOf("String_Node_Str", offset + 1);
    assertType(contents, offset, offset + 1, "String_Node_Str");
    offset = contents.indexOf("String_Node_Str", offset + 1);
    assertType(contents, offset, offset + 1, "String_Node_Str");
}

Output:
 public void testLocalVar7() {
-    String contents = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+    String contents = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
     int offset = contents.indexOf("String_Node_Str");


Input:
public static boolean arraysEqual(Object[] a, Object[] b) {
    if (a.length != b.length)
        return false;
    else {
        for (int i = 0; i < a.length; ++i) if (!a[i].equals(b[i]))
            return false;
        return true;
    }
}

Output:
 public static boolean arraysEqual(Object[] a, Object[] b) {
-    if (a.length != b.length)
-        return false;
-    else {
-        for (int i = 0; i < a.length; ++i) if (!a[i].equals(b[i]))
-            return false;
-        return true;
-    }
+    return arrayRegionsEqual(a, 0, a.length, b, 0, b.length);
 }


Input:
private static void onViaEmbeddable(Attribute column, Object entity, Metamodel metamodel, Map<String, Object> valueMap) throws InstantiationException, IllegalAccessException {
    EmbeddableType embeddable = metamodel.embeddable(((AbstractAttribute) column).getBindableJavaType());
    Field embeddedField = (Field) column.getJavaMember();
    Object embeddedDocumentObject = null;
    if (column.isCollection()) {
        Class embeddedObjectClass = PropertyAccessorHelper.getGenericClass(embeddedField);
        embeddedDocumentObject = valueMap.get(((AbstractAttribute) column).getJPAColumnName());
        if (embeddedDocumentObject != null) {
            Collection embeddedCollection = getCollectionFromDocumentList(metamodel, (List<Map<String, Object>>) embeddedDocumentObject, embeddedField.getType(), embeddedObjectClass, embeddable.getAttributes());
            PropertyAccessorHelper.set(entity, embeddedField, embeddedCollection);
        }
    } else {
        Object obj = PropertyAccessorHelper.getObject(entity, (Field) column.getJavaMember());
        if (obj == null) {
            obj = ((AbstractAttribute) column).getBindableJavaType().newInstance();
        }
        embeddedDocumentObject = valueMap.get(((AbstractAttribute) column).getJPAColumnName());
        PropertyAccessorHelper.set(entity, embeddedField, getObjectFromDocument(metamodel, (Map<String, Object>) embeddedDocumentObject, embeddable.getAttributes(), obj));
    }
}

Output:
         embeddedDocumentObject = valueMap.get(((AbstractAttribute) column).getJPAColumnName());
-        PropertyAccessorHelper.set(entity, embeddedField, getObjectFromDocument(metamodel, (Map<String, Object>) embeddedDocumentObject, embeddable.getAttributes(), obj));
+        if (embeddedDocumentObject != null)
+            PropertyAccessorHelper.set(entity, embeddedField, getObjectFromDocument(metamodel, (Map<String, Object>) embeddedDocumentObject, embeddable.getAttributes(), obj));
     }


Input:
public static long store_sms(Context context, Message sms, long thread_id) {
    try {
        ContentValues values = new ContentValues();
        values.put("String_Node_Str", sms.getSender());
        values.put("String_Node_Str", sms.getBody());
        values.put("String_Node_Str", false);
        values.put("String_Node_Str", isRight(context, sms.getSender()) ? 2 : 1);
        values.put("String_Node_Str", 32);
        if (thread_id != -1)
            values.put("String_Node_Str", thread_id);
        values.put("String_Node_Str", sms.getDateNormalize());
        Uri uri_id = context.getContentResolver().insert(Uri.parse("String_Node_Str"), values);
        if (uri_id != null)
            return Long.parseLong(uri_id.toString().substring(14));
    } catch (Exception ex) {
        Toast.makeText(context, "String_Node_Str" + ex.toString(), Toast.LENGTH_LONG).show();
    }
    return -1;
}

Output:
         values.put("String_Node_Str", false);
-        values.put("String_Node_Str", isRight(context, sms.getSender()) ? 2 : 1);
+        values.put("String_Node_Str", (!PhoneNumberUtils.compare(phoneContact, sms.getSender())) ? 2 : 1);
         values.put("String_Node_Str", 32);


Input:
private Button createButton(Composite parent, String label, SelectionListener listener) {
    Button button = new Button(parent, SWT.PUSH);
    button.setText(label);
    button.addSelectionListener(listener);
    GridData gd = new GridData();
    gd.widthHint = defaultButtonWidth;
    button.setLayoutData(gd);
    return button;
}

Output:
     button.setText(label);
-    button.addSelectionListener(listener);
+    if (listener != null)
+        button.addSelectionListener(listener);
     GridData gd = new GridData();


Input:
public void setItems(ObservableList<TurboIssue> issues) {
    this.issues = issues;
    refreshItems();
}

Output:
     this.issues = issues;
-    refreshItems();
+    this.issues.addListener(new WeakListChangeListener<TurboIssue>(createIssuesListener()));
 }


Input:
protected void addAccessor(MappingAccessor accessor) {
    if (accessor != null) {
        accessor.addConverters();
        if (accessor.isEmbeddedId()) {
            getProject().addIdClass(accessor.getReferenceClassName());
        }
        addPotentialEmbeddableAccessor(accessor.getReferenceClass(), accessor.getClassAccessor());
        if (accessor.isMappedKeyMapAccessor()) {
            MappedKeyMapAccessor mapAccessor = (MappedKeyMapAccessor) accessor;
            MetadataClass mapKeyClass = mapAccessor.getMapKeyClass();
            if (mapKeyClass == null || mapKeyClass.equals(void.class)) {
                mapKeyClass = accessor.getAccessibleObject().getMapKeyClass(getDescriptor());
                if (mapKeyClass == null) {
                    throw ValidationException.unableToDetermineMapKeyClass(accessor.getAttributeName(), accessor.getJavaClass());
                } else {
                    mapAccessor.setMapKeyClass(mapKeyClass);
                }
            }
            addPotentialEmbeddableAccessor(mapKeyClass, accessor.getClassAccessor());
        }
        getDescriptor().addAccessor(accessor);
    }
}

Output:
             if (mapKeyClass == null || mapKeyClass.equals(void.class)) {
-                mapKeyClass = accessor.getAccessibleObject().getMapKeyClass(getDescriptor());
-                if (mapKeyClass == null) {
-                    throw ValidationException.unableToDetermineMapKeyClass(accessor.getAttributeName(), accessor.getJavaClass());
-                } else {
-                    mapAccessor.setMapKeyClass(mapKeyClass);
-                }
+                mapKeyClass = accessor.getMapKeyReferenceClass();
+                mapAccessor.setMapKeyClass(mapKeyClass);
             }


Input:
private LinkedList _scheduleConnectedActors(LinkedList actorList) throws NotSchedulableException {
    LinkedList readyToScheduleActorList = new LinkedList();
    LinkedList newSchedule = new LinkedList();
    Map waitingTokens = new TreeMap(new NamedObjComparator());
    Map firingsRemainingVector = new TreeMap(new NamedObjComparator());
    firingsRemainingVector.putAll(_firingvector);
    LinkedList unscheduledActorList = new LinkedList();
    unscheduledActorList.addAll(actorList);
    try {
        Iterator schedulableEntities = actorList.iterator();
        while (schedulableEntities.hasNext()) {
            Actor a = (Actor) schedulableEntities.next();
            Iterator ainputports = a.inputPortList().iterator();
            while (ainputports.hasNext()) {
                IOPort ainputport = (IOPort) ainputports.next();
                int[] tokencount = new int[ainputport.getWidth()];
                for (int channel = 0; channel < tokencount.length; channel++) tokencount[channel] = 0;
                waitingTokens.put(ainputport, tokencount);
            }
        }
        schedulableEntities = actorList.iterator();
        while (schedulableEntities.hasNext()) {
            Actor a = (Actor) schedulableEntities.next();
            Iterator aoutputports = a.outputPortList().iterator();
            while (aoutputports.hasNext()) {
                IOPort aOutputPort = (IOPort) aoutputports.next();
                int count = getTokenInitProduction(aOutputPort);
                if (_debugging)
                    _debug("String_Node_Str" + count + "String_Node_Str" + aOutputPort);
                if (count > 0) {
                    _simulateTokensCreated(aOutputPort, count, actorList, readyToScheduleActorList, waitingTokens);
                }
            }
        }
        StaticSchedulingDirector dir = (StaticSchedulingDirector) getContainer();
        CompositeActor ca = (CompositeActor) (dir.getContainer());
        Iterator inputPorts = ca.inputPortList().iterator();
        while (inputPorts.hasNext()) {
            IOPort port = (IOPort) inputPorts.next();
            _simulateExternalInputs(port, actorList, waitingTokens);
        }
        schedulableEntities = actorList.iterator();
        while (schedulableEntities.hasNext()) {
            Actor a = (Actor) schedulableEntities.next();
            int inputCount = _countUnfulfilledInputs(a, actorList, waitingTokens);
            if (inputCount == 0)
                readyToScheduleActorList.addFirst((ComponentEntity) a);
            if (_debugging)
                _debug("String_Node_Str" + ((ComponentEntity) a).getName() + "String_Node_Str" + inputCount + "String_Node_Str");
        }
        while (readyToScheduleActorList.size() > 0) {
            if (_debugging)
                _debug("String_Node_Str");
            Iterator ports = waitingTokens.keySet().iterator();
            while (ports.hasNext()) {
                IOPort port = (IOPort) ports.next();
                int[] tokencount = (int[]) waitingTokens.get(port);
                if (_debugging) {
                    _debug("String_Node_Str" + port.getFullName());
                    _debug("String_Node_Str" + tokencount.length);
                }
                for (int channel = 0; channel < tokencount.length; channel++) if (_debugging)
                    _debug("String_Node_Str" + channel + "String_Node_Str" + tokencount[channel] + "String_Node_Str");
            }
            if (_debugging) {
                _debug("String_Node_Str");
                Iterator actorsLeft = readyToScheduleActorList.iterator();
                while (actorsLeft.hasNext()) {
                    Entity e = (Entity) actorsLeft.next();
                    _debug(e.getFullName());
                }
                _debug("String_Node_Str");
                actorsLeft = unscheduledActorList.iterator();
                while (actorsLeft.hasNext()) {
                    Entity e = (Entity) actorsLeft.next();
                    _debug(e.getFullName());
                }
            }
            ComponentEntity currentActor = (ComponentEntity) readyToScheduleActorList.getFirst();
            while (readyToScheduleActorList.remove(currentActor)) ;
            if (_debugging) {
                _debug("String_Node_Str" + currentActor.getName());
            }
            _simulateInputConsumption(currentActor, waitingTokens);
            newSchedule.addLast(currentActor);
            Iterator aOutputPorts = ((Actor) currentActor).outputPortList().iterator();
            while (aOutputPorts.hasNext()) {
                IOPort aOutputPort = (IOPort) aOutputPorts.next();
                int count = getTokenProductionRate(aOutputPort);
                _simulateTokensCreated(aOutputPort, count, unscheduledActorList, readyToScheduleActorList, waitingTokens);
            }
            int firingsRemaining = ((Integer) firingsRemainingVector.get(currentActor)).intValue();
            firingsRemaining -= 1;
            firingsRemainingVector.put(currentActor, new Integer(firingsRemaining));
            if (_debugging) {
                _debug(currentActor.getName() + "String_Node_Str" + firingsRemaining + "String_Node_Str");
            }
            if (firingsRemaining < 0)
                throw new IllegalStateException("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
            else {
                if (firingsRemaining == 0) {
                    _debug("String_Node_Str" + currentActor);
                    while (readyToScheduleActorList.remove(currentActor)) ;
                    while (unscheduledActorList.remove(currentActor)) ;
                    _debug("String_Node_Str");
                    Iterator actorsLeft = readyToScheduleActorList.iterator();
                    while (actorsLeft.hasNext()) {
                        Entity e = (Entity) actorsLeft.next();
                        if (_debugging)
                            _debug(e.getFullName());
                    }
                } else {
                    int inputCount = _countUnfulfilledInputs((Actor) currentActor, unscheduledActorList, waitingTokens);
                    if (inputCount < 1 && unscheduledActorList.contains(currentActor))
                        readyToScheduleActorList.addLast(currentActor);
                }
            }
        }
    } catch (IllegalActionException iae) {
        throw new InternalErrorException("String_Node_Str" + "String_Node_Str" + iae.getMessage());
    } finally {
        if (_debugging)
            _debug("String_Node_Str");
    }
    if (unscheduledActorList.size() > 0) {
        String s = new String("String_Node_Str");
        Iterator actors = unscheduledActorList.iterator();
        while (actors.hasNext()) {
            Entity actor = (Entity) actors.next();
            s += actor.getFullName() + "String_Node_Str";
        }
        throw new NotSchedulableException(s);
    }
    Iterator eschedule = newSchedule.iterator();
    if (_debugging) {
        _debug("String_Node_Str");
        while (eschedule.hasNext()) {
            _debug(((ComponentEntity) eschedule.next()).toString());
        }
    }
    return newSchedule;
}

Output:
                 if (firingsRemaining == 0) {
-                    _debug("String_Node_Str" + currentActor);
+                    if (_debugging) {
+                        _debug("String_Node_Str" + currentActor);
+                    }
                     while (readyToScheduleActorList.remove(currentActor)) ;


Input:
public ExtendedTooltip getToolTip() {
    ExtendedTooltip tip = new ExtendedTooltip(true);
    byte[] avatarImage = metaContact.getAvatar();
    if (avatarImage != null && avatarImage.length > 0)
        tip.setImage(new ImageIcon(avatarImage));
    tip.setTitle(metaContact.getDisplayName());
    loadTooltip(tip);
    return tip;
}

Output:
     ExtendedTooltip tip = new ExtendedTooltip(true);
-    byte[] avatarImage = metaContact.getAvatar();
-    if (avatarImage != null && avatarImage.length > 0)
-        tip.setImage(new ImageIcon(avatarImage));
+    tip.setImage(getScaledAvatar(false, 30, 30));
     tip.setTitle(metaContact.getDisplayName());


Input:
private static File getBasePath(String base) {
    try {
        Enumeration<URL> urls = new ClassLoader() {
        }.getResources(base);
        File file = null;
        if (null != urls && urls.hasMoreElements()) {
            URL url = urls.nextElement();
            if (url != null) {
                String path = url.getFile();
                try {
                    path = URLDecoder.decode(path, Charset.defaultCharset().name());
                } catch (Exception e) {
                }
                file = new File(path);
            }
        }
        if (null == file)
            file = Files.findFile(base);
        if (null == file)
            return null;
        try {
            if (file.isDirectory())
                return file;
        } catch (SecurityException e) {
        }
        return file.getParentFile();
    } catch (IOException e) {
    }
    return null;
}

Output:
                 String path = url.getFile();
-                try {
-                    path = URLDecoder.decode(path, Charset.defaultCharset().name());
-                } catch (Exception e) {
-                }
+                path = decodePath(path);
                 file = new File(path);


Input:
protected void createIndexesOnColumns(EntityMetadata m, String tableName, String poolName, List<Column> columns, Class columnType) {
    Object pooledConnection = null;
    try {
        Cassandra.Client api = null;
        pooledConnection = getPooledConection(persistenceUnit);
        api = getConnection(pooledConnection);
        KsDef ksDef = api.describe_keyspace(m.getSchema());
        List<CfDef> cfDefs = ksDef.getCf_defs();
        CfDef columnFamilyDefToUpdate = null;
        boolean isUpdatable = false;
        for (CfDef cfDef : cfDefs) {
            if (cfDef.getName().equals(tableName)) {
                columnFamilyDefToUpdate = cfDef;
                break;
            }
        }
        if (columnFamilyDefToUpdate == null) {
            throw new PersistenceException("String_Node_Str");
        }
        List<ColumnDef> columnMetadataList = columnFamilyDefToUpdate.getColumn_metadata();
        List<String> indexList = new ArrayList<String>();
        if (columnMetadataList != null) {
            for (ColumnDef columnDef : columnMetadataList) {
                indexList.add(Bytes.toUTF8(columnDef.getName()));
            }
        }
        for (Column column : columns) {
            ColumnDef columnDef = new ColumnDef();
            columnDef.setName(column.getName());
            columnDef.setValidation_class(CassandraValidationClassMapper.getValidationClass(columnType));
            columnDef.setIndex_type(IndexType.KEYS);
            if (!indexList.contains(Bytes.toUTF8(column.getName()))) {
                isUpdatable = true;
                columnFamilyDefToUpdate.addToColumn_metadata(columnDef);
            }
        }
        if (isUpdatable) {
            columnFamilyDefToUpdate.setKey_validation_class(CassandraValidationClassMapper.getValidationClass(m.getIdAttribute().getJavaType()));
            api.system_update_column_family(columnFamilyDefToUpdate);
        }
    } catch (InvalidRequestException e) {
        log.warn("String_Node_Str" + tableName + "String_Node_Str" + e);
    } catch (SchemaDisagreementException e) {
        log.warn("String_Node_Str" + tableName + "String_Node_Str" + e);
    } catch (TException e) {
        log.warn("String_Node_Str" + tableName + "String_Node_Str" + e);
    } catch (NotFoundException e) {
        log.warn("String_Node_Str" + tableName + "String_Node_Str" + e);
    } catch (PropertyAccessException e) {
        log.warn("String_Node_Str" + tableName + "String_Node_Str" + e);
    } finally {
        releaseConnection(pooledConnection);
    }
}

Output:
         Cassandra.Client api = null;
-        pooledConnection = getPooledConection(persistenceUnit);
+        pooledConnection = getConection(persistenceUnit);
         api = getConnection(pooledConnection);


Input:
private String getNextPrefix() {
    return "String_Node_Str" + prefixCounter++;
}

Output:
 private String getNextPrefix() {
-    return "String_Node_Str" + prefixCounter++;
+    return BASE_PREFIX + prefixCounter++;
 }


Input:
private void waitForTheTableToEnable(String cluster, String table) throws BlurException {
    LOG.info("String_Node_Str" + table + "String_Node_Str");
    while (true) {
        if (_clusterStatus.isEnabled(true, cluster, table)) {
            return;
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            LOG.error("String_Node_Str" + table + "String_Node_Str", e);
            throw new BException("String_Node_Str" + table + "String_Node_Str", e);
        }
    }
}

Output:
     while (true) {
-        if (_clusterStatus.isEnabled(true, cluster, table)) {
+        if (_clusterStatus.isEnabled(false, cluster, table)) {
             return;


Input:
public static AidToNavigationReport fromEncodedMessage(EncodedAISMessage encodedMessage) {
    if (!encodedMessage.isValid())
        throw new InvalidEncodedMessage(encodedMessage);
    if (!encodedMessage.getMessageType().equals(AISMessageType.AidToNavigationReport))
        throw new UnsupportedMessageType(encodedMessage.getMessageType().getCode());
    Integer repeatIndicator = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(6, 8));
    MMSI sourceMmsi = MMSI.valueOf(DecoderImpl.convertToUnsignedLong(encodedMessage.getBits(8, 38)));
    AidType aidType = AidType.fromInteger(DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(38, 43)));
    String name = DecoderImpl.convertToString(encodedMessage.getBits(43, 163));
    Boolean positionAccurate = DecoderImpl.convertToBoolean(encodedMessage.getBits(163, 164));
    Float longitude = DecoderImpl.convertToFloat(encodedMessage.getBits(164, 192)) / 600000f;
    Float latitude = DecoderImpl.convertToFloat(encodedMessage.getBits(192, 219)) / 600000f;
    Integer toBow = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(219, 228));
    Integer toStern = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(228, 237));
    Integer toPort = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(237, 243));
    Integer toStarboard = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(243, 249));
    PositionFixingDevice positionFixingDevice = PositionFixingDevice.fromInteger(DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(249, 253)));
    Integer second = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(253, 259));
    Boolean offPosition = DecoderImpl.convertToBoolean(encodedMessage.getBits(259, 260));
    String regionalUse = DecoderImpl.convertToBitString(encodedMessage.getBits(260, 268));
    Boolean raimFlag = DecoderImpl.convertToBoolean(encodedMessage.getBits(268, 269));
    Boolean virtualAid = DecoderImpl.convertToBoolean(encodedMessage.getBits(269, 270));
    Boolean assignedMode = DecoderImpl.convertToBoolean(encodedMessage.getBits(270, 271));
    String nameExtension = DecoderImpl.convertToString(encodedMessage.getBits(272, 361));
    return new AidToNavigationReport(repeatIndicator, sourceMmsi, aidType, name, positionAccurate, latitude, longitude, toBow, toStern, toStarboard, toPort, positionFixingDevice, second, offPosition, regionalUse, raimFlag, virtualAid, assignedMode, nameExtension);
}

Output:
     Boolean assignedMode = DecoderImpl.convertToBoolean(encodedMessage.getBits(270, 271));
-    String nameExtension = DecoderImpl.convertToString(encodedMessage.getBits(272, 361));
-    return new AidToNavigationReport(repeatIndicator, sourceMmsi, aidType, name, positionAccurate, latitude, longitude, toBow, toStern, toStarboard, toPort, positionFixingDevice, second, offPosition, regionalUse, raimFlag, virtualAid, assignedMode, nameExtension);
+    int spare1 = DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(271, 272));
+    String nameExtension = null;
+    int spare2 = 0;
+    if (encodedMessage.getNumberOfBits() > 272) {
+        int extraBits = encodedMessage.getNumberOfBits() - 272;
+        int extraChars = extraBits / 6;
+        int extraBitsOfChars = extraChars * 6;
+        nameExtension = DecoderImpl.convertToString(encodedMessage.getBits(272, 272 + extraBitsOfChars));
+        spare2 = (extraBits == extraBitsOfChars) ? 0 : DecoderImpl.convertToUnsignedInteger(encodedMessage.getBits(272 + extraBitsOfChars, encodedMessage.getNumberOfBits()));
+    }
+    return new AidToNavigationReport(repeatIndicator, sourceMmsi, aidType, name, positionAccurate, latitude, longitude, toBow, toStern, toStarboard, toPort, positionFixingDevice, second, offPosition, regionalUse, raimFlag, virtualAid, assignedMode, spare1, nameExtension, spare2);
 }


Input:
public void refresh(IElementParameter param, boolean checkErrorsWhenViewRefreshed) {
    final String name2 = param.getName();
    Text labelText = (Text) hashCurControls.get(name2);
    Object value = param.getValue();
    if (labelText == null || labelText.isDisposed()) {
        return;
    }
    boolean valueChanged = false;
    if (value == null) {
        labelText.setText("String_Node_Str");
    } else {
        if (!value.equals(labelText.getText())) {
            labelText.setText((String) value);
            valueChanged = true;
        }
    }
    if (checkErrorsWhenViewRefreshed || valueChanged) {
        checkErrorsForPropertiesOnly(labelText);
    }
    fixedCursorPosition(param, labelText, value, valueChanged);
}

Output:
     if (value == null) {
-        labelText.setText("String_Node_Str");
+        labelText.setText(TalendQuoteUtils.addQuotes("String_Node_Str"));
     } else {


Input:
public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
    FileDialog fd = new FileDialog(shell.getShell(), SWT.SAVE);
    fd.setFilterExtensions(new String[] { "String_Node_Str" });
    fd.setText("String_Node_Str");
    String filename = fd.open();
    if (filename == null)
        return;
    File file = new File(filename);
    try {
        log.info(file.toURL());
    } catch (MalformedURLException e1) {
        log.error(e1.getMessage(), e1);
    }
    XSDDesc xsdDesc = buildUp(filename, LOCAL, 0);
    include(xsdDesc);
    getButton(IDialogConstants.OK_ID).setEnabled(true);
    tableViewer.refresh();
}

Output:
     fd.setFilterExtensions(new String[] { "String_Node_Str" });
-    fd.setText("String_Node_Str");
+    fd.setText(Messages.getString("String_Node_Str"));
     String filename = fd.open();


Input:
public static void main(String[] args) throws IOException {
    if (args.length < 5) {
        System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
        return;
    }
    int index = 0;
    String inputPrefix = args[index++].trim();
    String inputSuffix = args[index++].trim();
    String subPrefix = args[index++].trim();
    String outputPrefix = args[index++].trim();
    String inputFiles = args[index++].trim();
    BufferedReader in = null;
    try {
        in = new BufferedReader(new FileReader(inputFiles));
        String inputFileName;
        while ((inputFileName = in.readLine()) != null) {
            String xmlSuffix = inputFileName.replaceFirst("String_Node_Str", inputSuffix);
            String xmlInputFile = inputPrefix + _FILESEPARATOR + xmlSuffix;
            String pathToNCFile = subPrefix + _FILESEPARATOR + inputFileName;
            String[] subdirs = inputFileName.split(_FILESEPARATOR);
            String componentName = subdirs[subdirs.length - 1];
            componentName = componentName.replaceFirst("String_Node_Str", "String_Node_Str");
            String momlSuffix = inputFileName.replaceFirst("String_Node_Str", "String_Node_Str");
            String momlOutputFile = outputPrefix + _FILESEPARATOR + momlSuffix;
            try {
                if (new NDReader().parse(xmlInputFile)) {
                    System.out.println("String_Node_Str" + xmlInputFile);
                } else {
                    System.out.println("String_Node_Str" + xmlInputFile);
                }
                try {
                    generateComponent(pathToNCFile, componentName, momlOutputFile);
                } catch (Exception ex) {
                    System.err.println("String_Node_Str" + momlOutputFile + "String_Node_Str" + ex);
                }
            } catch (SAXException ex) {
                System.err.println("String_Node_Str" + xmlInputFile + "String_Node_Str");
            } catch (FileNotFoundException ex) {
                System.err.println("String_Node_Str" + xmlInputFile + "String_Node_Str");
            } catch (Exception ex) {
                System.err.println("String_Node_Str" + xmlInputFile + "String_Node_Str" + ex);
            }
        }
    } catch (IOException ex) {
        System.err.println("String_Node_Str" + inputFiles);
        System.err.println("String_Node_Str" + ex);
    } finally {
        if (in != null) {
            in.close();
        }
    }
}

Output:
     try {
-        in = new BufferedReader(new FileReader(inputFiles));
+        in = new BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(inputFiles), java.nio.charset.Charset.defaultCharset()));
         String inputFileName;


Input:
static void refresh(long id) {
    if (resume) {
        boolean changed = false;
        String code = queue.get(String.valueOf(id));
        if (code != null) {
            queue.remove(String.valueOf(id));
            queue.remove(code);
            data.clear();
            for (Map<String, String> map : versions) {
                if (String.valueOf(map.get("String_Node_Str")).equalsIgnoreCase(code)) {
                    changed = true;
                    String action = bible.getContext().getString(R.string.uninstall);
                    map.put("String_Node_Str", action);
                    map.put("String_Node_Str", action);
                }
                data.add(map);
            }
            if (changed) {
                adapter.notifyDataSetChanged();
                adapter.getFilter().filter(filter);
            }
        }
    }
}

Output:
             queue.remove(code);
-            data.clear();
-            for (Map<String, String> map : versions) {
-                if (String.valueOf(map.get("String_Node_Str")).equalsIgnoreCase(code)) {
-                    changed = true;
-                    String action = bible.getContext().getString(R.string.uninstall);
-                    map.put("String_Node_Str", action);
-                    map.put("String_Node_Str", action);
+            synchronized (data) {
+                data.clear();
+                for (Map<String, String> map : versions) {
+                    if (String.valueOf(map.get("String_Node_Str")).equalsIgnoreCase(code)) {
+                        changed = true;
+                        String action = bible.getContext().getString(R.string.uninstall);
+                        map.put("String_Node_Str", action);
+                        map.put("String_Node_Str", action);
+                    }
+                    data.add(map);
                 }


Input:
public void refreshRecordTypes(List<RecordType> recordTypes) throws InterruptedException {
    synchronized (monitor) {
        while (count > 0) {
            monitor.wait();
        }
        nameCacheOutOfDate = true;
        childRecordTypesOutOfDate = true;
        for (RecordType recordType : recordTypes) {
            String bucketId = AbstractSchemaCache.encodeHex(recordType.getId().getBytes());
            if (!removeFromLocalUpdateBucket(recordType.getId(), bucketId)) {
                Map<SchemaId, RecordType> bucket = buckets.get(bucketId);
                if (bucket == null) {
                    bucket = new ConcurrentHashMap<SchemaId, RecordType>();
                    buckets.put(bucketId, bucket);
                }
                bucket.put(recordType.getId(), recordType);
            }
        }
    }
}

Output:
             String bucketId = AbstractSchemaCache.encodeHex(recordType.getId().getBytes());
-            if (!removeFromLocalUpdateBucket(recordType.getId(), bucketId)) {
+            if (!removeFromLocalUpdateBucket(recordType, bucketId)) {
                 Map<SchemaId, RecordType> bucket = buckets.get(bucketId);


Input:
public void testTimeoutToOutsideNetwork() throws Exception {
    ClientConfig clientConfig = new ClientConfig();
    clientConfig.getGroupConfig().setName("String_Node_Str").setPassword("String_Node_Str");
    clientConfig.getNetworkConfig().addAddress("String_Node_Str");
    HazelcastInstance client = hazelcastFactory.newHazelcastClient(clientConfig);
    IList<Object> list = client.getList("String_Node_Str");
}

Output:
     HazelcastInstance client = hazelcastFactory.newHazelcastClient(clientConfig);
-    IList<Object> list = client.getList("String_Node_Str");
+    client.getList("String_Node_Str");
 }


Input:
public void setWaypoint(EWaypointType waypointType, ShortPoint2D position) {
    if (waypointType != EWaypointType.DESTINATION && !isTargetSet()) {
        waypointType = EWaypointType.DESTINATION;
    }
    if (isSelected()) {
        drawWaypointLine(false);
    }
    if (waypointType == EWaypointType.DESTINATION) {
        Arrays.fill(waypoints, null);
    }
    ShortPoint2D closeReachableLocation = findClosestReachablePosition(waypointType, position);
    if (closeReachableLocation != null && !isWaypointFulfillingPreconditions(waypointType, closeReachableLocation)) {
        return;
    }
    waypoints[waypointType.ordinal()] = closeReachableLocation;
    if (isSelected()) {
        drawWaypointLine(true);
    }
}

Output:
     }
-    ShortPoint2D closeReachableLocation = findClosestReachablePosition(waypointType, position);
-    if (closeReachableLocation != null && !isWaypointFulfillingPreconditions(waypointType, closeReachableLocation)) {
+    ShortPoint2D closestReachableLocation = findClosestReachablePosition(waypointType, position);
+    if (closestReachableLocation == null || !isWaypointFulfillingPreconditions(waypointType, closestReachableLocation)) {
         return;


Input:
public void execute(final ScriptEntry scriptEntry) throws CommandExecutionException {
    final List<dEntity> entities = (List<dEntity>) scriptEntry.getObject("String_Node_Str");
    final Duration duration = (Duration) scriptEntry.getObject("String_Node_Str");
    final Duration frequency = (Duration) scriptEntry.getObject("String_Node_Str");
    final Element yaw = (Element) scriptEntry.getObject("String_Node_Str");
    final Element pitch = (Element) scriptEntry.getObject("String_Node_Str");
    boolean cancel = scriptEntry.hasObject("String_Node_Str");
    final boolean infinite = scriptEntry.hasObject("String_Node_Str");
    dB.report(scriptEntry, getName(), (cancel ? aH.debugObj("String_Node_Str", cancel) : "String_Node_Str") + aH.debugObj("String_Node_Str", entities.toString()) + (infinite ? aH.debugObj("String_Node_Str", "String_Node_Str") : duration.debug()) + frequency.debug() + yaw.debug() + pitch.debug());
    for (dEntity entity : entities) {
        if (cancel) {
            rotatingEntities.remove(entity.getUUID());
        } else {
            rotatingEntities.add(entity.getUUID());
        }
    }
    if (cancel) {
        return;
    }
    BukkitRunnable task = new BukkitRunnable() {
        int ticks = 0;
        int maxTicks = duration.getTicksAsInt();
        Collection<dEntity> unusedEntities = new LinkedList<dEntity>();
        public void run() {
            if (entities.isEmpty()) {
                scriptEntry.setFinished(true);
                this.cancel();
            } else if (infinite || ticks < maxTicks) {
                for (dEntity entity : entities) {
                    if (entity.isSpawned() && rotatingEntities.contains(entity.getUUID())) {
                        NMSHandler.getInstance().getEntityHelper().rotate(entity.getBukkitEntity(), NMSHandler.getInstance().getEntityHelper().normalizeYaw(entity.getLocation().getYaw() + yaw.asFloat()), entity.getLocation().getPitch() + pitch.asFloat());
                    } else {
                        rotatingEntities.remove(entity.getUUID());
                        unusedEntities.add(entity);
                    }
                }
                if (!unusedEntities.isEmpty()) {
                    for (dEntity unusedEntity : unusedEntities) {
                        entities.remove(unusedEntity);
                    }
                    unusedEntities.clear();
                }
                ticks = (int) (ticks + frequency.getTicks());
            } else {
                scriptEntry.setFinished(true);
                this.cancel();
            }
        }
    };
    task.runTaskTimer(DenizenAPI.getCurrentInstance(), 0, frequency.getTicks());
}

Output:
 public void execute(final ScriptEntry scriptEntry) throws CommandExecutionException {
-    final List<dEntity> entities = (List<dEntity>) scriptEntry.getObject("String_Node_Str");
+    final List<dEntity> entities = new ArrayList<dEntity>((List<dEntity>) scriptEntry.getObject("String_Node_Str"));
     final Duration duration = (Duration) scriptEntry.getObject("String_Node_Str");


Input:
public Span toSpan(TraceContext context) {
    if (context == null)
        throw new NullPointerException("String_Node_Str");
    if (noop.get() == false && Boolean.TRUE.equals(context.sampled())) {
        return RealSpan.create(context, recorder);
    }
    return NoopSpan.create(context);
}

Output:
         throw new NullPointerException("String_Node_Str");
-    if (noop.get() == false && Boolean.TRUE.equals(context.sampled())) {
+    if (!noop.get() && Boolean.TRUE.equals(context.sampled())) {
         return RealSpan.create(context, recorder);


Input:
public String getPortGroupNameByNicType(HostVirtualNicType nicType) throws Exception {
    assert (nicType != null);
    VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[]) _context.getVimClient().getDynamicProperty(_mor, "String_Node_Str");
    if (netConfigs != null) {
        for (VirtualNicManagerNetConfig netConfig : netConfigs) {
            if (netConfig.getNicType().equals(nicType.toString())) {
                List<HostVirtualNic> nics = netConfig.getCandidateVnic();
                if (nics != null) {
                    for (HostVirtualNic nic : nics) {
                        return nic.getPortgroup();
                    }
                }
            }
        }
    }
    if (nicType == HostVirtualNicType.management) {
        HostNetworkInfo netInfo = getHostNetworkInfo();
        assert (netInfo != null);
        List<HostVirtualNic> nics = netInfo.getConsoleVnic();
        if (nics != null) {
            for (HostVirtualNic nic : nics) {
                return nic.getPortgroup();
            }
        }
    }
    return null;
}

Output:
     assert (nicType != null);
-    VirtualNicManagerNetConfig[] netConfigs = (VirtualNicManagerNetConfig[]) _context.getVimClient().getDynamicProperty(_mor, "String_Node_Str");
+    List<VirtualNicManagerNetConfig> netConfigs = (List<VirtualNicManagerNetConfig>) _context.getVimClient().getDynamicProperty(_mor, "String_Node_Str");
     if (netConfigs != null) {


Input:
private byte[] cropPatches() {
    FuncTracer.startFunc();
    QMatrix currShape = getCurrentShape();
    int filterW = mModel.patchModel.sampleWidth;
    int filterH = mModel.patchModel.sampleHeight;
    int patchW = filterW + SEARCH_WIN_W - 1;
    int patchH = filterH + SEARCH_WIN_H - 1;
    int shiftW = -(patchW - 1) / 2;
    int shiftH = -(patchH - 1) / 2;
    byte[] ret = new byte[mModel.numPts * patchW * patchH];
    mCropPositions = currShape;
    for (int i = 0; i < mModel.numPts; i++) {
        int centerX = (int) (currShape.get(i * 2));
        int centerY = (int) (currShape.get(i * 2 + 1));
        for (int j = 0; j < patchH; j++) {
            for (int k = 0; k < patchW; k++) {
                int posX = centerX + shiftW + k;
                int posY = centerY + shiftH + j;
                if (posX < 0 || posY < 0 || posX > mImageW || posY > mImageH) {
                    ret[i * patchW * patchH + j * patchW + k] = 0;
                } else {
                    ret[i * patchW * patchH + j * patchW + k] = (mImgGrayScaled[(int) (posY * mImageW) + posX]);
                }
            }
        }
    }
    FuncTracer.endFunc();
    return ret;
}

Output:
                 if (posX < 0 || posY < 0 || posX > mImageW || posY > mImageH) {
-                    ret[i * patchW * patchH + j * patchW + k] = 0;
+                    ret[i * patchW * patchH + j * patchW + k] = 100;
                 } else {


Input:
protected void postRead(DexFile dexFile) {
    TypeIdItem typeId = dexFile.getTypeIdItem(getValue());
    String typeDesc = dexFile.getString(typeId.getDescriptorIdx());
    setDesc(getValue() + "String_Node_Str" + typeDesc);
}

Output:
 protected void postRead(DexFile dexFile) {
-    TypeIdItem typeId = dexFile.getTypeIdItem(getValue());
-    String typeDesc = dexFile.getString(typeId.getDescriptorIdx());
-    setDesc(getValue() + "String_Node_Str" + typeDesc);
+    int index = getValue();
+    if (index > 0) {
+        TypeIdItem typeId = dexFile.getTypeIdItem(index);
+        String typeDesc = dexFile.getString(typeId.getDescriptorIdx());
+        setDesc(index + "String_Node_Str" + typeDesc);
+    } else {
+        setDesc(String.valueOf(index));
+    }
 }


Input:
public void run() {
    LOG.debug("String_Node_Str");
    timeout(3000);
    reload();
    LOG.debug("String_Node_Str");
}

Output:
     LOG.debug("String_Node_Str");
-    timeout(3000);
+    timeout(2000);
     reload();


Input:
public synchronized void close() throws IOException {
    if (in != null) {
        in.close();
    }
}

Output:
 public synchronized void close() throws IOException {
-    if (in != null) {
-        in.close();
+    try {
+        if (in != null) {
+            in.close();
+        }
+    } finally {
+        if (decompressor != null) {
+            CodecPool.returnDecompressor(decompressor);
+        }
     }


Input:
public int read(int address, boolean word, long cycles) {
    switch(address) {
        case ADC12CTL0:
            return adc12ctl0;
        case ADC12CTL1:
            return adc12ctl1;
        case ADC12IE:
            return adc12ie;
        case ADC12IFG:
            return adc12ifg;
        default:
            if (address >= ADC12MCTL0 && address <= ADC12MCTL15) {
                return adc12mctl[address - ADC12MCTL0];
            } else if (address >= ADC12MEM0) {
                int reg = address - ADC12MEM0;
                adc12ifg &= ~(1 << reg);
                if (adc12iv == reg + 6) {
                    core.flagInterrupt(adc12Vector, this, false);
                    adc12iv = 0;
                }
                return adc12mem[reg];
            }
    }
    return 0;
}

Output:
             } else if (address >= ADC12MEM0) {
-                int reg = address - ADC12MEM0;
+                int reg = (address - ADC12MEM0) / 2;
                 adc12ifg &= ~(1 << reg);


Input:
public void submit(final EvaluatorRequest req) {
    LOG.log(Level.FINEST, "String_Node_Str");
    final DriverRuntimeProtocol.ResourceRequestProto.Builder request = DriverRuntimeProtocol.ResourceRequestProto.newBuilder();
    switch(req.getSize()) {
        case MEDIUM:
            request.setResourceSize(ReefServiceProtos.SIZE.MEDIUM);
            break;
        case LARGE:
            request.setResourceSize(ReefServiceProtos.SIZE.LARGE);
            break;
        case XLARGE:
            request.setResourceSize(ReefServiceProtos.SIZE.XLARGE);
            break;
        default:
            request.setResourceSize(ReefServiceProtos.SIZE.SMALL);
    }
    request.setResourceCount(req.getNumber());
    if (req.getMegaBytes() > 0) {
        request.setMemorySize(req.getMegaBytes());
    }
    final ResourceCatalog.Descriptor descriptor = req.getDescriptor();
    if (descriptor != null) {
        if (descriptor instanceof RackDescriptor) {
            request.addRackName(descriptor.getName());
        } else if (descriptor instanceof NodeDescriptor) {
            request.addNodeName(descriptor.getName());
        }
    }
    this.futureResourceRequestHandler.get().onNext(request.build());
}

Output:
     final DriverRuntimeProtocol.ResourceRequestProto.Builder request = DriverRuntimeProtocol.ResourceRequestProto.newBuilder();
-    switch(req.getSize()) {
-        case MEDIUM:
-            request.setResourceSize(ReefServiceProtos.SIZE.MEDIUM);
-            break;
-        case LARGE:
-            request.setResourceSize(ReefServiceProtos.SIZE.LARGE);
-            break;
-        case XLARGE:
-            request.setResourceSize(ReefServiceProtos.SIZE.XLARGE);
-            break;
-        default:
-            request.setResourceSize(ReefServiceProtos.SIZE.SMALL);
+    if (null != req.getSize()) {
+        switch(req.getSize()) {
+            case MEDIUM:
+                request.setResourceSize(ReefServiceProtos.SIZE.MEDIUM);
+                break;
+            case LARGE:
+                request.setResourceSize(ReefServiceProtos.SIZE.LARGE);
+                break;
+            case XLARGE:
+                request.setResourceSize(ReefServiceProtos.SIZE.XLARGE);
+                break;
+            default:
+                request.setResourceSize(ReefServiceProtos.SIZE.SMALL);
+        }
+    } else {
+        if (req.getMegaBytes() <= 0) {
+            throw new RuntimeException("String_Node_Str");
+        }
     }


Input:
public String[] getBuyableSkills() {
    int i = 0;
    for (String s : SkillsConfig.skills) {
        if (SkillsConfig.getSingleSkill(s).getLevel() <= getLevel())
            i++;
    }
    String[] buyableSkills = new String[i];
    i = 0;
    for (String s : SkillsConfig.skills) {
        if (SkillsConfig.getSingleSkill(s).getLevel() <= getLevel()) {
            if (!skills.contains(s)) {
                buyableSkills[i] = s;
            }
            i++;
        }
    }
    return buyableSkills;
}

Output:
             if (!skills.contains(s)) {
-                buyableSkills[i] = s;
+                buyableSkills[i] = s + "String_Node_Str" + Messaging.colorizeText("String_Node_Str" + SkillsConfig.getSingleSkill(s).getId(), ChatColor.YELLOW) + "String_Node_Str";
             }


Input:
private void oldRound(PaxosMessage aMessage) {
    OldRound myOldRound = (OldRound) aMessage;
    long myCompetingNodeId = myOldRound.getNodeId();
    if (myCompetingNodeId > _nodeId) {
        _logger.info("String_Node_Str" + Long.toHexString(myCompetingNodeId) + "String_Node_Str" + Long.toHexString(_nodeId));
        notLeader();
        _stage = ABORT;
        _reason = Reasons.OTHER_LEADER;
        process();
        return;
    }
    updateRndNumber(myOldRound);
    _stage = COLLECT;
    collect();
}

Output:
     _stage = COLLECT;
-    collect();
+    process();
 }


Input:
public void shouldGetValueIfIsSetInProperties() throws Exception {
    DefaultEnvironment defaultEnvironment = new DefaultEnvironment(development());
    String value = defaultEnvironment.get("String_Node_Str", "String_Node_Str");
    assertEquals("String_Node_Str", value);
}

Output:
 public void shouldGetValueIfIsSetInProperties() throws Exception {
-    DefaultEnvironment defaultEnvironment = new DefaultEnvironment(development());
+    DefaultEnvironment defaultEnvironment = new DefaultEnvironment(EnvironmentType.DEVELOPMENT);
     String value = defaultEnvironment.get("String_Node_Str", "String_Node_Str");


Input:
public synchronized Set<CoordinateOperation> createFromCoordinateReferenceSystemCodes(final String sourceCRS, final String targetCRS) throws FactoryException {
    ArgumentChecks.ensureNonNull("String_Node_Str", sourceCRS);
    ArgumentChecks.ensureNonNull("String_Node_Str", targetCRS);
    final String label = sourceCRS + "String_Node_Str" + targetCRS;
    final CoordinateOperationSet set = new CoordinateOperationSet(owner);
    try {
        final int[] pair = toPrimaryKeys(null, null, null, sourceCRS, targetCRS);
        boolean searchTransformations = false;
        do {
            final String key, sql;
            if (searchTransformations) {
                key = "String_Node_Str";
                sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
            } else {
                key = "String_Node_Str";
                sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
            }
            final Integer targetKey = searchTransformations ? null : pair[1];
            final ResultSet result = executeQuery(key, sql, pair);
            try {
                while (result.next()) {
                    set.addAuthorityCode(getString(label, result, 1), targetKey);
                }
            } finally {
                result.close();
            }
        } while ((searchTransformations = !searchTransformations) == true);
        final String[] codes = set.getAuthorityCodes();
        if (codes.length > 1 && sort("String_Node_Str", codes)) {
            set.setAuthorityCodes(codes);
        }
    } catch (SQLException exception) {
        throw databaseFailure(CoordinateOperation.class, label, exception);
    }
    set.resolve(1);
    return set;
}

Output:
                 key = "String_Node_Str";
-                sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+                sql = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
             } else {


Input:
private Number convertStringToNumber(String strValue) {
    Number value = null;
    try {
        if (StringUtils.hasText(strValue)) {
            if (strValue.indexOf("String_Node_Str") > 0) {
                value = Double.valueOf(strValue);
            } else {
                value = Long.valueOf(strValue);
            }
        }
    } catch (NumberFormatException ne) {
        value = null;
    }
    return value;
}

Output:
         if (StringUtils.hasText(strValue)) {
-            if (strValue.indexOf("String_Node_Str") > 0) {
+            if (strValue.indexOf('.') > 0) {
                 value = Double.valueOf(strValue);


Input:
public static String getPinyinNum(String name) {
    try {
        if (name != null && name.length() != 0) {
            int len = name.length();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; i++) {
                String tmp = name.substring(i);
                char c = tmp.charAt(0);
                if (c <= '9' && c >= '0') {
                    sb.append(c);
                } else {
                    sb.append(getOneNumFromAlpha(ToPinYinUtils.getPinYin(tmp).toLowerCase().charAt(0)));
                }
            }
            return sb.toString();
        }
    } catch (BadHanyuPinyinOutputFormatCombination e) {
        e.printStackTrace();
    }
    return null;
}

Output:
                 } else {
-                    sb.append(getOneNumFromAlpha(ToPinYinUtils.getPinYin(tmp).toLowerCase().charAt(0)));
+                    if (full) {
+                        String pinyin = ToPinYinUtils.getPinYin(tmp).toLowerCase();
+                        for (int j = 0; j < pinyin.length(); j++) {
+                            sb.append(getOneNumFromAlpha(pinyin.charAt(j)));
+                        }
+                    } else {
+                        sb.append(getOneNumFromAlpha(ToPinYinUtils.getPinYin(tmp).toLowerCase().charAt(0)));
+                    }
                 }


Input:
public void widgetSelected(SelectionEvent e) {
    Shell activeShell = Display.getCurrent().getActiveShell();
    SelectDeleteProjectDialog dialog = new SelectDeleteProjectDialog(activeShell, true);
    if (dialog.open() == Dialog.OK) {
        CorePlugin.getDefault().getRepositoryLocalProviderService().resetXmiResourceSet();
        java.util.List<Object> delList = dialog.getDelList();
        if (delList.size() != 0) {
            for (Object obj : delList) {
                if (obj instanceof IProject) {
                    IProject p = (IProject) obj;
                    if (projectsMap.containsKey(p.getName())) {
                        projectsMap.remove(p.getName());
                        projectList.remove(p.getName());
                        if (projectList.getItemCount() == 0) {
                            enableOpenAndDelete(false);
                        } else if (projectList.getSelection().length == 0) {
                            projectList.select(0);
                        }
                        try {
                            setStatusArea();
                        } catch (PersistenceException e1) {
                            ExceptionHandler.process(e1);
                        }
                    }
                }
            }
        }
    }
}

Output:
                         projectsMap.remove(p.getName());
-                        projectList.remove(p.getName());
+                        String name = convertorMapper.get(p.getName());
+                        if (name != null)
+                            projectList.remove(name);
                         if (projectList.getItemCount() == 0) {


Input:
public void onBucketEmpty(final PlayerBucketEmptyEvent e) {
    if (debug) {
        plugin.getLogger().info(e.getEventName());
    }
    if (inWorld(e.getPlayer())) {
        if (VaultHelper.checkPerm(e.getPlayer(), Settings.PERMPREFIX + "String_Node_Str")) {
            return;
        }
        Player p = e.getPlayer();
        if (e.getBlockClicked() != null) {
            Island island = plugin.getGrid().getProtectedIslandAt(e.getBlockClicked().getLocation());
            if (island != null) {
                if (island.getIgsFlag(Flags.allowBreakBlocks) || island.getMembers().contains(p.getUniqueId())) {
                    if (e.getBlockClicked() != null && e.getBlockClicked().getBiome().equals(Biome.HELL) && e.getPlayer().getItemInHand().getType().equals(Material.WATER_BUCKET)) {
                        e.setCancelled(true);
                        e.getPlayer().getItemInHand().setType(Material.BUCKET);
                        e.getPlayer().playSound(e.getPlayer().getLocation(), Sound.FIZZ, 1F, 2F);
                        e.getPlayer().sendMessage(ChatColor.RED + plugin.myLocale(e.getPlayer().getUniqueId()).biomeSet.replace("String_Node_Str", "String_Node_Str"));
                    }
                    return;
                }
            } else {
                if (Settings.allowBucketUse) {
                    return;
                }
            }
            p.sendMessage(ChatColor.RED + plugin.myLocale(p.getUniqueId()).islandProtected);
            e.setCancelled(true);
        }
    }
}

Output:
         if (e.getBlockClicked() != null) {
-            Island island = plugin.getGrid().getProtectedIslandAt(e.getBlockClicked().getLocation());
+            Block dumpBlock = e.getBlockClicked().getRelative(e.getBlockFace());
+            Island island = plugin.getGrid().getProtectedIslandAt(dumpBlock.getLocation());
             if (island != null) {


Input:
public synchronized File getFile(RemoteFileDesc rfd) {
    File incDir = null;
    try {
        incDir = SettingsManager.instance().getIncompleteDirectory();
    } catch (java.io.FileNotFoundException fnfe) {
    }
    URN sha1 = rfd.getSHA1Urn();
    if (sha1 != null) {
        File file = (File) hashes.get(sha1);
        if (file != null) {
            return file;
        } else {
            for (int i = 1; ; i++) {
                file = new File(incDir, tempName(CommonUtils.convertFileName(rfd.getFileName()), rfd.getSize(), i));
                if (!hashes.values().contains(file))
                    break;
            }
            hashes.put(sha1, file);
            return file;
        }
    } else {
        return new File(incDir, tempName(rfd.getFileName(), rfd.getSize(), 0));
    }
}

Output:
             for (int i = 1; ; i++) {
-                file = new File(incDir, tempName(CommonUtils.convertFileName(rfd.getFileName()), rfd.getSize(), i));
+                file = new File(incDir, tempName(convertedName, rfd.getSize(), i));
                 if (!hashes.values().contains(file))


Input:
private void loadLogsFromDisk(BufferedReader br, IACSLogRemoteConnection logListener, LogCache cache) {
    if (br == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    String tag = null;
    LogStringBuffer buffer = new LogStringBuffer();
    int chRead;
    int bytesRead = 0;
    int logRecordsRead = 0;
    boolean lookForOpenTag = true;
    try {
        StopWatch stopWatch = new StopWatch();
        while ((chRead = br.read()) != -1) {
            bytesRead++;
            buffer.append((char) chRead);
            if (chRead == '>') {
                if (lookForOpenTag) {
                    tag = buffer.getOpeningTag();
                    if (tag.length() > 0) {
                        lookForOpenTag = false;
                        buffer.trim(tag);
                    }
                } else {
                    if (buffer.hasClosingTag(tag)) {
                        lookForOpenTag = true;
                        injectLog(buffer.toString(), logListener);
                        buffer.clear();
                        logRecordsRead++;
                        if (progressDialog != null) {
                            if (cache != null) {
                                progressDialog.updateStatus("String_Node_Str" + cache.getSize() + "String_Node_Str");
                            }
                            progressDialog.updateProgressBar(bytesRead);
                            if (progressDialog.wantsToAbort()) {
                                break;
                            }
                        }
                    }
                }
            }
        }
        System.out.println("String_Node_Str" + logRecordsRead + "String_Node_Str" + stopWatch.getLapTimeMillis() / 1000 + "String_Node_Str");
        System.out.println(ResourceChecker.getMemoryStatusMessage());
    } catch (IOException ioe) {
        System.err.println("String_Node_Str" + ioe.getMessage());
        ioe.printStackTrace(System.err);
        JOptionPane.showMessageDialog(null, "String_Node_Str" + ioe.getMessage(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        return;
    }
    if (progressDialog != null) {
        progressDialog.setVisible(false);
        progressDialog.dispose();
        progressDialog = null;
    }
    IOOperationTerminated();
}

Output:
 private void loadLogsFromDisk(BufferedReader br, IACSLogRemoteConnection logListener, LogCache cache) {
-    if (br == null) {
+    if (br == null || logListener == null) {
         throw new IllegalArgumentException("String_Node_Str");


Input:
public static boolean isEqualsWithoutOrdering(Object[] array1, Object[] array2) {
    if (array1 == null && array2 == null) {
        return true;
    }
    if (array1 == null || array2 == null) {
        return false;
    }
    if (array1.length != array2.length) {
        return false;
    }
    for (int i = 0; i < array1.length; i++) {
        boolean contains = false;
        for (int j = 0; j < array2.length; j++) {
            if (array1[i] == null && array2[i] == null) {
                contains = true;
                break;
            }
            if (array1[i] != null && array1[i].equals(array2[j])) {
                contains = true;
                break;
            }
        }
        if (!contains)
            return false;
    }
    return true;
}

Output:
         }
-        if (!contains)
+        if (!contains) {
             return false;


Input:
public Object addingService(ServiceReference arg0) {
    sc++;
    Object svc = bc.getService(arg0);
    String key = ((String[]) arg0.getProperty(Constants.OBJECTCLASS))[0];
    serviceMap.put(key, svc);
    if (thread == null && sc == services.length && !(runnable instanceof UnmanagedRunnable)) {
        if (runnable instanceof ManagedInlineRunnable) {
            runnable.run(serviceMap);
        } else {
            thread = new Thread(new Runnable() {
                public void run() {
                    runnable.run(serviceMap);
                }
            });
            thread.start();
        }
    }
    if (runnable instanceof UnmanagedRunnable) {
        return ((UnmanagedRunnable) runnable).addingService(arg0);
    }
    return svc;
}

Output:
     String key = ((String[]) arg0.getProperty(Constants.OBJECTCLASS))[0];
-    serviceMap.put(key, svc);
-    if (thread == null && sc == services.length && !(runnable instanceof UnmanagedRunnable)) {
+    if (!serviceMap.containsKey(key)) {
+        sc++;
+        serviceMap.put(key, svc);
+    }
+    if (thread == null && sc == serviceCount && !(runnable instanceof UnmanagedRunnable)) {
         if (runnable instanceof ManagedInlineRunnable) {


Input:
protected void onResume() {
    super.onResume();
    EventBus.getDefault().register(this);
}

Output:
     super.onResume();
-    EventBus.getDefault().register(this);
+    if (!EventBus.getDefault().isRegistered(this)) {
+        EventBus.getDefault().register(this);
+    }
 }


Input:
public static PieceType getKingPieceType() {
    Map<Direction, Integer> movements = Maps.newHashMap();
    for (Direction direction : Direction.values()) {
        movements.put(direction, 1);
    }
    return new PieceType("String_Node_Str", movements, null, null);
}

Output:
     }
-    return new PieceType("String_Node_Str", movements, null, null);
+    return new PieceType("String_Node_Str", movements, null);
 }


Input:
public void run() {
    try {
        IEditorPart editorPart = page.openEditor(new FileEditorInput(file), editorDescriptor.getId());
        if (editorPart instanceof AbstractTextEditor) {
            IDocumentProvider dp = DocumentProviderRegistry.getDefault().getDocumentProvider(editorPart.getEditorInput());
            AbstractTextEditor textEditor = (AbstractTextEditor) editorPart;
            IDocument document = dp.getDocument(editorPart.getEditorInput());
            if (document != null) {
                EditorListener listener = new EditorListener(document, textEditor);
                document.addDocumentListener(listener);
            }
        }
    } catch (PartInitException e) {
        e.printStackTrace();
    }
}

Output:
     } catch (PartInitException e) {
-        e.printStackTrace();
+        Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID, 0, e.getLocalizedMessage(), e));
     }


Input:
public void onDaylightChange(PlayerInteractEvent evt) {
    Player player = evt.getPlayer();
    if (evt.getAction() == Action.RIGHT_CLICK_BLOCK) {
        if (evt.getClickedBlock().getType() == Carbon.injector().daylightDetectorInvertedMat) {
            try {
                CraftBlock craftBlock = (CraftBlock) evt.getClickedBlock();
                craftBlock.setType(Material.DAYLIGHT_DETECTOR);
                Method method = CraftBlock.class.getDeclaredMethod("String_Node_Str", net.minecraft.server.v1_7_R4.Block.class);
                method.setAccessible(true);
                net.minecraft.server.v1_7_R4.Block nmsBlock = (net.minecraft.server.v1_7_R4.Block) method.invoke(craftBlock, Void.class);
                BlockDaylightDetector detector = (BlockDaylightDetector) nmsBlock;
                detector.setInverted(false);
                player.getWorld().playSound(evt.getClickedBlock().getLocation(), Sound.CLICK, 1, 1);
            } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                Logger.getLogger(BlockListener.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else if (evt.getClickedBlock().getType() == Material.DAYLIGHT_DETECTOR) {
            try {
                CraftBlock craftBlock = (CraftBlock) evt.getClickedBlock();
                craftBlock.setType(Carbon.injector().daylightDetectorInvertedMat);
                Method method = CraftBlock.class.getDeclaredMethod("String_Node_Str", net.minecraft.server.v1_7_R4.Block.class);
                method.setAccessible(true);
                net.minecraft.server.v1_7_R4.Block nmsBlock = (net.minecraft.server.v1_7_R4.Block) method.invoke(craftBlock, Void.class);
                BlockDaylightDetector detector = (BlockDaylightDetector) nmsBlock;
                detector.setInverted(true);
                player.getWorld().playSound(evt.getClickedBlock().getLocation(), Sound.CLICK, 1, 1);
            } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                Logger.getLogger(BlockListener.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

Output:
                 craftBlock.setType(Material.DAYLIGHT_DETECTOR);
-                Method method = CraftBlock.class.getDeclaredMethod("String_Node_Str", net.minecraft.server.v1_7_R4.Block.class);
+                Method method = CraftBlock.class.getDeclaredMethod("String_Node_Str");
                 method.setAccessible(true);


Input:
public void shutdown() throws MetaClientException {
    if (this.shutdown) {
        return;
    }
    this.shutdown = true;
    this.recoverManager.shutdown();
    for (final Shutdownable child : this.children) {
        child.shutdown();
    }
    try {
        this.remotingClient.stop();
    } catch (final NotifyRemotingException e) {
        throw new NetworkException("String_Node_Str", e);
    }
    if (this.zkClient != null) {
        this.zkClient.close();
    }
    if (!this.isHutdownHookCalled) {
        Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
    }
}

Output:
     this.shutdown = true;
-    this.recoverManager.shutdown();
+    if (this.recoverManager != null) {
+        this.recoverManager.shutdown();
+    }
     for (final Shutdownable child : this.children) {


Input:
public Record next() throws IOException {
    currentRowIndex++;
    if (currentRowIndex < csvHeadValue) {
        if (hasNext()) {
            return next();
        } else {
            return null;
        }
    }
    if (csvLimitValue != -1 && currentRowIndex > csvLimitValue - 1) {
        return null;
    }
    String[] values = csvReader.getValues();
    String[] analysedValues = new String[analysedColumnIndex.length];
    for (int i = 0; i < analysedColumnIndex.length; i++) {
        analysedValues[i] = values[analysedColumnIndex[i]];
    }
    return createRichRecord(analysedValues);
}

Output:
     for (int i = 0; i < analysedColumnIndex.length; i++) {
-        analysedValues[i] = values[analysedColumnIndex[i]];
+        if (values.length <= i) {
+            analysedValues[i] = StringUtils.EMPTY;
+        } else {
+            analysedValues[i] = values[analysedColumnIndex[i]];
+        }
     }


Input:
private void testBackupMigrationAndRecovery(int nodeCount, int backupCount, int mapSize) throws Exception {
    TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(nodeCount);
    final String name = MAP_NAME;
    final Config config = new Config();
    config.setProperty(GroupProperties.PROP_PARTITION_COUNT, "String_Node_Str");
    config.getMapConfig(name).setBackupCount(backupCount).setStatisticsEnabled(true);
    final HazelcastInstance[] instances = new HazelcastInstance[nodeCount];
    HazelcastInstance hz = nodeFactory.newHazelcastInstance(config);
    instances[0] = hz;
    IMap map1 = hz.getMap(name);
    for (int i = 0; i < mapSize; i++) {
        map1.put(i, "String_Node_Str" + i);
    }
    checkMapSizes(mapSize, backupCount, instances);
    for (int i = 1; i < nodeCount; i++) {
        instances[i] = nodeFactory.newHazelcastInstance(config);
        checkMapSizes(mapSize, backupCount, instances);
    }
    final Random rand = new Random();
    for (int i = 1; i < nodeCount; i++) {
        int ix;
        do {
            ix = rand.nextInt(nodeCount);
        } while (instances[ix] == null);
        TestUtil.terminateInstance(instances[ix]);
        instances[ix] = null;
        checkMapSizes(mapSize, backupCount, instances);
    }
}

Output:
         } while (instances[ix] == null);
-        TestUtil.terminateInstance(instances[ix]);
+        final CountDownLatch latch = new CountDownLatch(1);
+        instances[ix].getLifecycleService().addLifecycleListener(new LifecycleListener() {
+            public void stateChanged(LifecycleEvent event) {
+                if (event.getState().equals(LifecycleEvent.LifecycleState.SHUTDOWN)) {
+                    latch.countDown();
+                }
+            }
+        });
+        instances[ix].getLifecycleService().shutdown();
         instances[ix] = null;


Input:
private static Set<Var> unneededVars(Block block, Set<Var> stillNeeded, List<List<Var>> dependentSets) {
    HashSet<Var> toRemove = new HashSet<Var>();
    for (List<Var> dependentSet : dependentSets) {
        {
            boolean needed = false;
            for (Var v : dependentSet) {
                if (stillNeeded.contains(v)) {
                    needed = true;
                    break;
                }
            }
            if (needed) {
                for (Var v : dependentSet) {
                    stillNeeded.add(v);
                }
            }
        }
    }
    for (Var v : block.getVariables()) {
        if (!stillNeeded.contains(v)) {
            toRemove.add(v);
        }
    }
    return toRemove;
}

Output:
 private static Set<Var> unneededVars(Block block, Set<Var> stillNeeded, List<List<Var>> dependentSets) {
-    HashSet<Var> toRemove = new HashSet<Var>();
-    for (List<Var> dependentSet : dependentSets) {
-        {
-            boolean needed = false;
+    HashSet<Var> removeCandidates = new HashSet<Var>();
+    for (Var v : block.getVariables()) {
+        if (!stillNeeded.contains(v)) {
+            removeCandidates.add(v);
+        }
+    }
+    Logger logger = Logging.getSTCLogger();
+    if (logger.isTraceEnabled()) {
+        logger.trace("String_Node_Str" + removeCandidates + "String_Node_Str" + "String_Node_Str" + dependentSets);
+    }
+    boolean converged = false;
+    while (!converged && !dependentSets.isEmpty()) {
+        Iterator<List<Var>> it = dependentSets.iterator();
+        while (it.hasNext()) {
+            List<Var> dependentSet = it.next();
+            converged = true;
+            boolean hasRemoveCandidate = false;
+            boolean allRemoveCandidates = true;
             for (Var v : dependentSet) {


Input:
private PlotSettingsSubPanel getAlternateBottomPanel() {
    final AxisPanel yAxisPanel = new AxisPanel() {
        private static final long serialVersionUID = 7880175726915727283L;
        public void initialLayout() {
            addAt(minMaxPanel[0], 0, 3, 1, 1, GridBagConstraints.SOUTHWEST, GridBagConstraints.BOTH);
            addAt(minMaxPanel[1], 0, 1, 1, 1, GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH);
            addAt(minMaxLabel[0], 1, 3, 1, 1, GridBagConstraints.SOUTHEAST, GridBagConstraints.NONE);
            addAt(minMaxLabel[1], 1, 0, 1, 1, GridBagConstraints.NORTHEAST, GridBagConstraints.NONE);
            addAt(spanPanel, 0, 2, 2, 1, GridBagConstraints.EAST, GridBagConstraints.BOTH);
            addAt(axisTitle, 0, 0, 2, 1, GridBagConstraints.NORTH, GridBagConstraints.BOTH);
        }
    };
    final AxisPanel xAxisPanel = new AxisPanel() {

        private static final long serialVersionUID = 7880175726915727283L;
        public void initialLayout() {
            addAt(minMaxPanel[0], 0, 1, 2, 1, GridBagConstraints.WEST, GridBagConstraints.NONE);
            addAt(minMaxPanel[1], 2, 1, 2, 1, GridBagConstraints.EAST, GridBagConstraints.NONE);
            addAt(minMaxLabel[0], 0, 0, 1, 1, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE);
            addAt(minMaxLabel[1], 3, 0, 1, 1, GridBagConstraints.NORTHEAST, GridBagConstraints.NONE);
            addAt(spanPanel, 1, 0, 2, 1, GridBagConstraints.NORTH, GridBagConstraints.BOTH);
            addAt(axisTitle, 1, 2, 2, 1, GridBagConstraints.SOUTH, GridBagConstraints.BOTH);
        }
    };
    JPanel p1 = new JPanel();
    p1.add(new JLabel("String_Node_Str"));
    JPanel p2 = new JPanel();
    p2.add(new JLabel("String_Node_Str"));
    JPanel p3 = new JPanel();
    final AxisGroup timeGroup = new AxisGroup(new TimeAxisMinimumsPanel(), new TimeAxisMaximumsPanel(), new XAxisSpanCluster());
    final AxisGroup nonTimeGroup = new AxisGroup(new NonTimeAxisMinimumsPanel(false), new NonTimeAxisMaximumsPanel(), new YAxisSpanPanel());
    PlotSettingsPanel panel = new PlotSettingsPanel() {
        private static final long serialVersionUID = 1730870211575829997L;
        public void reset(PlotConfiguration settings, boolean hard) {
            boolean xInverted = settings.getXAxisMaximumLocation() == XAxisMaximumLocationSetting.MAXIMUM_AT_LEFT;
            boolean yInverted = settings.getYAxisMaximumLocation() == YAxisMaximumLocationSetting.MAXIMUM_AT_BOTTOM;
            switch(settings.getAxisOrientationSetting()) {
                case X_AXIS_AS_TIME:
                    xAxisPanel.setFrom(timeGroup, xInverted);
                    yAxisPanel.setFrom(nonTimeGroup, yInverted);
                    timeGroup.setTitle("String_Node_Str");
                    nonTimeGroup.setTitle("String_Node_Str");
                    break;
                case Y_AXIS_AS_TIME:
                    yAxisPanel.setFrom(timeGroup, xInverted);
                    xAxisPanel.setFrom(nonTimeGroup, yInverted);
                    timeGroup.setTitle("String_Node_Str");
                    nonTimeGroup.setTitle("String_Node_Str");
                    break;
            }
            super.reset(settings, hard);
        }
    };
    panel.setLayout(new GridBagLayout());
    panel.setBorder(TOP_PADDED_MARGINS);
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.gridx = 0;
    gbc.gridy = 1;
    gbc.gridwidth = 1;
    gbc.gridheight = 3;
    gbc.fill = GridBagConstraints.BOTH;
    gbc.insets = new Insets(2, 0, 10, 2);
    panel.add(yAxisPanel, gbc);
    gbc.gridx = 1;
    gbc.gridy = 1;
    gbc.gridwidth = 3;
    gbc.gridheight = 3;
    panel.add(imagePanel, gbc);
    gbc.gridx = 1;
    gbc.gridy = 4;
    gbc.gridwidth = 3;
    gbc.gridheight = 1;
    gbc.fill = GridBagConstraints.BOTH;
    gbc.insets = new Insets(0, 8, 0, 0);
    panel.add(xAxisPanel, gbc);
    yAxisPanel.setName("String_Node_Str");
    xAxisPanel.setName("String_Node_Str");
    return panel;
}

Output:
     };
-    final AxisPanel xAxisPanel = new AxisPanel() {
+    final AxisPanel yAxisPanel = new AxisPanel() {


Input:
public void run() {
    initializationPhase();
    referenceSetUpdate();
    while (!isStoppingConditionReached()) {
        if (restartConditionIsFulfilled()) {
            restart();
        } else {
            List<List<S>> subset = subsetGeneration();
            List<S> combinedSolutions = solutionCombination(subset);
            for (S solution : combinedSolutions) {
                S improvedSolution = improvement(solution);
                referenceSetUpdate(improvedSolution);
            }
        }
    }
}

Output:
     while (!isStoppingConditionReached()) {
-        if (restartConditionIsFulfilled()) {
+        List<List<S>> subset = subsetGeneration();
+        List<S> combinedSolutions = solutionCombination(subset);
+        for (S solution : combinedSolutions) {
+            S improvedSolution = improvement(solution);
+            referenceSetUpdate(improvedSolution);
+        }
+        if (restartConditionIsFulfilled(combinedSolutions)) {
             restart();


Input:
public BigDecimal getDecimalField(final String fieldName) {
    Object fieldValue = getField(fieldName);
    if (fieldValue == null) {
        return null;
    }
    if (fieldValue instanceof BigDecimal) {
        return (BigDecimal) fieldValue;
    }
    throw new IllegalArgumentException("String_Node_Str" + fieldName + "String_Node_Str" + dataDefinition.getPluginIdentifier() + '.' + dataDefinition.getName() + "String_Node_Str");
}

Output:
 public BigDecimal getDecimalField(final String fieldName) {
-    Object fieldValue = getField(fieldName);
+    final Object fieldValue = getField(fieldName);
     if (fieldValue == null) {


Input:
private void setStateOfMajorGrid() {
    boolean enabled;
    if (ChartUIUtil.is3DWallFloorSet(getChart())) {
        enabled = getAxisForProcessing().getMajorGrid().getLineAttributes().isSetVisible() && getAxisForProcessing().getMajorGrid().getLineAttributes().isVisible();
    } else {
        enabled = false;
    }
    lblGridStepNum.setEnabled(enabled);
    majGridStNum.setEnabled(enabled);
}

Output:
     }
-    lblGridStepNum.setEnabled(enabled);
-    majGridStNum.setEnabled(enabled);
+    if (enabled) {
+        boolean isAuto = btnMajStpNum.getSelection();
+        lblGridStepNum.setEnabled(true);
+        majGridStNum.setEnabled(true && !isAuto);
+        btnMajStpNum.setEnabled(true);
+    } else {
+        lblGridStepNum.setEnabled(false);
+        majGridStNum.setEnabled(false);
+        btnMajStpNum.setEnabled(false);
+    }
 }


Input:
public Matrix computeHessian(Vector point) {
    if (power > 1) {
        Vector a = linearFunction.computeGradient(point);
        return Matrix.generateDiagonalMatrix(a.multElementwise(a).getDenseArray()).multiply(weight * power * (power - 1) * Math.pow(linearFunction.computeValue(point), power - 2));
    } else {
        return new Matrix(point.size(), point.size());
    }
}

Output:
         Vector a = linearFunction.computeGradient(point);
-        return Matrix.generateDiagonalMatrix(a.multElementwise(a).getDenseArray()).multiply(weight * power * (power - 1) * Math.pow(linearFunction.computeValue(point), power - 2));
+        return a.outer(a).multiply(weight * power * (power - 1) * Math.pow(linearFunction.computeValue(point), power - 2));
     } else {


Input:
public static URL buildUrl(String function, Map<String, String> arguments) {
    StringBuilder sbURL = new StringBuilder(BASE_URL);
    sbURL.append(function);
    sbURL.append("String_Node_Str").append(API_VERSION);
    sbURL.append("String_Node_Str").append(APP_ID);
    sbURL.append("String_Node_Str").append(imdbLocale);
    sbURL.append("String_Node_Str").append(System.currentTimeMillis() / 1000);
    for (Map.Entry<String, String> argEntry : arguments.entrySet()) {
        sbURL.append("String_Node_Str").append(argEntry.getKey());
        sbURL.append("String_Node_Str").append(argEntry.getValue());
    }
    sbURL.append("String_Node_Str").append(SIG);
    LOG.trace("String_Node_Str", sbURL.toString());
    try {
        return new URL(sbURL.toString());
    } catch (MalformedURLException ex) {
        LOG.trace("String_Node_Str", ex.getMessage());
        return null;
    }
}

Output:
     sbURL.append("String_Node_Str").append(imdbLocale);
-    sbURL.append("String_Node_Str").append(System.currentTimeMillis() / 1000);
+    sbURL.append("String_Node_Str").append(System.currentTimeMillis() / MILLIS_PER_SECOND);
     for (Map.Entry<String, String> argEntry : arguments.entrySet()) {


Input:
private boolean createSqlQuery(String dataFilterAsString, Indicator indicator) throws ParseException, AnalysisExecutionException {
    ModelElement analyzedElement = indicator.getAnalyzedElement();
    if (analyzedElement == null) {
        return traceError("String_Node_Str" + indicator.getName());
    }
    TdColumn tdColumn = SwitchHelpers.COLUMN_SWITCH.doSwitch(indicator.getAnalyzedElement());
    if (tdColumn == null) {
        return traceError("String_Node_Str" + indicator.getName());
    }
    String colName = quote(tdColumn.getName());
    if (!belongToSameSchemata(tdColumn)) {
        StringBuffer buf = new StringBuffer();
        for (orgomg.cwm.objectmodel.core.Package schema : schemata.values()) {
            buf.append(schema.getName() + "String_Node_Str");
        }
        log.error("String_Node_Str" + colName + "String_Node_Str" + buf.toString().trim() + "String_Node_Str");
        return false;
    }
    colName = castColumn(indicator, tdColumn, colName);
    String language = dbms().getDbmsName();
    Expression sqlGenericExpression = null;
    IndicatorDefinition indicatorDefinition = indicator.getIndicatorDefinition();
    if (indicatorDefinition == null) {
        return traceError("String_Node_Str" + indicator.getName() + "String_Node_Str");
    }
    sqlGenericExpression = dbms().getSqlExpression(indicatorDefinition);
    final EClass indicatorEclass = indicator.eClass();
    if (sqlGenericExpression == null || sqlGenericExpression.getBody() == null) {
        if (IndicatorsPackage.eINSTANCE.getRegexpMatchingIndicator().equals(indicatorEclass)) {
            return traceError("String_Node_Str" + language + "String_Node_Str");
        }
        return traceError("String_Node_Str" + (indicator.getName() != null ? indicator.getName() : indicatorEclass.getName()) + "String_Node_Str" + ResourceHelper.getUUID(indicatorDefinition) + "String_Node_Str");
    }
    List<String> whereExpression = new ArrayList<String>();
    if (StringUtils.isNotBlank(dataFilterAsString)) {
        whereExpression.add(dataFilterAsString);
    }
    List<String> rangeStrings = null;
    DateGrain dateAggregationType = null;
    IndicatorParameters parameters = indicator.getParameters();
    if (parameters != null) {
        Domain bins = parameters.getBins();
        if (bins != null) {
            rangeStrings = getBinsAsGenericString(bins.getRanges(), colName);
        }
        DateParameters dateParameters = parameters.getDateParameters();
        if (dateParameters != null) {
            dateAggregationType = dateParameters.getDateAggregationType();
        }
        TextParameters textParameter = parameters.getTextParameter();
        if (textParameter != null) {
            if (textParameter.isUseNulls()) {
                colName = dbms().replaceNullsWithString(colName, "String_Node_Str");
            }
            if (textParameter.isIgnoreCase()) {
                colName = dbms().toUpperCase(colName);
            }
            if (!textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getTextIndicator().isSuperTypeOf(indicatorEclass)) {
                whereExpression.add(dbms().isNotBlank(colName));
            } else if (textParameter.isUseBlank() && IndicatorsPackage.eINSTANCE.getFrequencyIndicator().isSuperTypeOf(indicatorEclass)) {
                colName = dbms().trim(colName);
            }
        }
    }
    final ColumnSet columnSetOwner = ColumnHelper.getColumnSetOwner(tdColumn);
    String schemaName = getQuotedSchemaName(columnSetOwner);
    String table = quote(ColumnHelper.getColumnSetFullName(tdColumn));
    String catalogName = getQuotedCatalogName(columnSetOwner);
    if (catalogName == null && schemaName != null) {
        final TdSchema parentSchema = SchemaHelper.getParentSchema(columnSetOwner);
        final TdCatalog parentCatalog = CatalogHelper.getParentCatalog(parentSchema);
        catalogName = parentCatalog != null ? parentCatalog.getName() : null;
    }
    table = dbms().toQualifiedName(catalogName, schemaName, table);
    String completedSqlString = null;
    if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getMedianIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getLowerQuartileIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getUpperQuartileIndicator())) {
        completedSqlString = getCompletedStringForQuantiles(indicator, sqlGenericExpression, colName, table, whereExpression);
        completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
    } else if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || indicatorEclass.isSuperTypeOf(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator())) {
        int topN = indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator()) ? 1 : getTopN(indicator);
        if (topN <= 0) {
            topN = TOP_N;
        }
        if (rangeStrings != null) {
            completedSqlString = getUnionCompletedString(indicator, sqlGenericExpression, colName, table, whereExpression, rangeStrings);
            if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator())) {
                completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
            }
        } else if (dateAggregationType != null && !dateAggregationType.equals(DateGrain.NONE) && Java2SqlType.isDateInSQL(tdColumn.getJavaType())) {
            completedSqlString = getDateAggregatedCompletedString(sqlGenericExpression, colName, table, dateAggregationType);
            completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
            completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
        } else {
            if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getPatternFreqIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getPatternLowFreqIndicator())) {
                colName = dbms().getPatternFinderDefaultFunction(colName);
            }
            completedSqlString = dbms().fillGenericQueryWithColumnTableAndAlias(sqlGenericExpression.getBody(), colName, table, colName);
            completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
            completedSqlString = dbms().getTopNQuery(completedSqlString, topN);
        }
    } else if (IndicatorsPackage.eINSTANCE.getPatternMatchingIndicator().isSuperTypeOf(indicatorEclass)) {
        List<String> patterns = getPatterns(indicator);
        if (patterns.isEmpty()) {
            return traceError("String_Node_Str" + language + "String_Node_Str" + indicator.getName());
        }
        completedSqlString = replaceVariables(sqlGenericExpression.getBody(), colName, table, patterns);
        completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
    } else {
        completedSqlString = dbms().fillGenericQueryWithColumnsAndTable(sqlGenericExpression.getBody(), colName, table);
        completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
    }
    String finalQuery = completedSqlString;
    Expression instantiateSqlExpression = instantiateSqlExpression(language, finalQuery);
    indicator.setInstantiatedExpression(instantiateSqlExpression);
    return true;
}

Output:
         completedSqlString = addWhereToSqlStringStatement(whereExpression, completedSqlString);
-    } else if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || indicatorEclass.isSuperTypeOf(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator())) {
+    } else if (indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || indicatorEclass.isSuperTypeOf(IndicatorsPackage.eINSTANCE.getFrequencyIndicator()) || IndicatorsPackage.eINSTANCE.getFrequencyIndicator().isSuperTypeOf(indicatorEclass) || indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator())) {
         int topN = indicatorEclass.equals(IndicatorsPackage.eINSTANCE.getModeIndicator()) ? 1 : getTopN(indicator);