Input:
protected static <C, R extends Message> R syncCall(SERVICES service, UserCredentials userCreds, Auth auth, Options options, UUIDResolver uuidResolver, UUIDIterator it, boolean uuidIteratorHasAddresses, boolean delayNextTry, int maxRetries, C callRequest, ReusableBuffer buffer, CallGenerator<C, R> callGen) throws PosixErrorException, IOException, InternalServerErrorException, AddressToUUIDNotFoundException {
    int maxTries = maxRetries;
    int attempt = 0;
    R response = null;
    try {
        while (++attempt <= maxTries || maxTries == 0) {
            RPCResponse<R> r = null;
            try {
                InetSocketAddress server;
                if (uuidIteratorHasAddresses) {
                    server = getInetSocketAddressFromAddress(it.getUUID(), service);
                } else {
                    String address = uuidResolver.uuidToAddress(it.getUUID());
                    server = getInetSocketAddressFromAddress(address, service);
                }
                r = callGen.executeCall(server, auth, userCreds, callRequest);
                response = r.get();
                if (r.getData() != null) {
                    if (buffer != null) {
                        buffer.put(r.getData());
                    }
                    BufferPool.free(r.getData());
                }
            } catch (PBRPCException pbe) {
                if (pbe.getErrorType().equals(ErrorType.REDIRECT)) {
                    assert (pbe.getRedirectToServerUUID() != null);
                    if (Logging.isInfo()) {
                        String error;
                        if (uuidIteratorHasAddresses) {
                            error = "String_Node_Str" + it.getUUID() + "String_Node_Str" + pbe.getRedirectToServerUUID() + "String_Node_Str" + attempt;
                        } else {
                            error = "String_Node_Str" + it.getUUID() + "String_Node_Str" + pbe.getRedirectToServerUUID() + "String_Node_Str" + attempt;
                        }
                        Logging.logMessage(Logging.LEVEL_INFO, Category.misc, pbe, error);
                    }
                    if (maxTries != 0 && attempt == maxTries) {
                        maxTries++;
                    }
                    it.markUUIDAsFailed(it.getUUID());
                    continue;
                }
                if (((attempt < maxTries || maxTries == 0) || (attempt == maxTries && delayNextTry)) && (pbe.getErrorType().equals(ErrorType.IO_ERROR) || pbe.getErrorType().equals(ErrorType.INTERNAL_SERVER_ERROR))) {
                    if (attempt == 1 && maxTries != 1) {
                        String retriesLeft = (maxTries == 0) ? ("String_Node_Str") : (String.valueOf(maxTries - attempt));
                        Logging.logMessage(Logging.LEVEL_ERROR, Category.misc, pbe, "String_Node_Str" + "String_Node_Str" + "String_Node_Str", it.getUUID(), retriesLeft, options.getRetryDelay_s());
                    }
                    it.markUUIDAsFailed(it.getUUID());
                    continue;
                } else {
                    throw pbe;
                }
            } catch (IOException ioe) {
                if (((attempt < maxTries || maxTries == 0) || (attempt == maxTries && delayNextTry))) {
                    if (attempt == 1 && maxTries != 1) {
                        String retriesLeft = (maxTries == 0) ? ("String_Node_Str") : (String.valueOf(maxTries - attempt));
                        Logging.logMessage(Logging.LEVEL_ERROR, Category.misc, ioe, "String_Node_Str" + "String_Node_Str" + "String_Node_Str", it.getUUID(), retriesLeft, options.getRetryDelay_s(), ioe.getMessage());
                        if (Logging.isDebug()) {
                            Logging.logError(Logging.LEVEL_DEBUG, null, ioe);
                        }
                    }
                    it.markUUIDAsFailed(it.getUUID());
                    continue;
                } else {
                    throw ioe;
                }
            } catch (InterruptedException ie) {
                if (options.getInterruptSignal() == 0) {
                    if (Logging.isDebug()) {
                        Logging.logMessage(Logging.LEVEL_DEBUG, Category.misc, ie, "String_Node_Str");
                    }
                    break;
                }
                throw new IOException();
            } finally {
                if (r != null) {
                    r.freeBuffers();
                }
            }
            return response;
        }
    } catch (PBRPCException e) {
        handleErrorAfterMaxTriesExceeded(e, it);
    }
    return null;
}

Output:
             } catch (IOException ioe) {
-                if (((attempt < maxTries || maxTries == 0) || (attempt == maxTries && delayNextTry))) {
+                if ((attempt < maxTries || maxTries == 0) || (attempt == maxTries && delayNextTry)) {
                     if (attempt == 1 && maxTries != 1) {


Input:
public void setData(Object obj, int[] intPayload, float[] floatPayload, String[] stringPayload, IndexInPayload index) throws IllegalAccessException {
    for (Field member : intMember) {
        intPayload[index.intIndex] = member.getInt(obj);
        index.intIndex++;
    }
    for (Field member : floatMember) {
        floatPayload[index.floatIndex] = member.getFloat(obj);
        index.floatIndex++;
    }
    for (Field member : booleanMember) {
        if (member.getBoolean(obj))
            floatPayload[index.intIndex] = 1;
        else
            floatPayload[index.intIndex] = 0;
        index.intIndex++;
    }
    for (Field member : stringMember) {
        stringPayload[index.stringIndex] = (String) member.get(obj);
        index.stringIndex++;
    }
    for (Field member : enumMember) {
        intPayload[index.intIndex] = ((Enum) member.get(obj)).ordinal();
        index.intIndex++;
    }
    for (Field member : gameProfileMember) {
        GameProfile profile = (GameProfile) member.get(obj);
        UUID profileID = profile.getId();
        if (profileID == null)
            profileID = new UUID(0, 0);
        intPayload[index.intIndex] = (int) profileID.getMostSignificantBits() >>> 32;
        intPayload[index.intIndex + 1] = (int) profileID.getMostSignificantBits();
        intPayload[index.intIndex + 2] = (int) profileID.getLeastSignificantBits() >>> 32;
        intPayload[index.intIndex + 3] = (int) profileID.getLeastSignificantBits();
        index.intIndex += 4;
        stringPayload[index.stringIndex] = profile.getName();
        index.stringIndex++;
    }
    for (ClassMap submap : objectMember) {
        Object source = submap.field.get(obj);
        if (source == null) {
            intPayload[index.intIndex] = 0;
            index.intIndex++;
            index.intIndex += submap.intSize;
            index.floatIndex += submap.floatSize;
            index.stringIndex += submap.stringSize;
        } else {
            intPayload[index.intIndex] = 1;
            index.intIndex++;
            submap.setData(source, intPayload, floatPayload, stringPayload, index);
        }
    }
}

Output:
             profileID = new UUID(0, 0);
-        intPayload[index.intIndex] = (int) profileID.getMostSignificantBits() >>> 32;
+        intPayload[index.intIndex] = (int) (profileID.getMostSignificantBits() >>> 32);
         intPayload[index.intIndex + 1] = (int) profileID.getMostSignificantBits();


Input:
public void goTo(Vector2 pf, ActionCallback cb) {
    EngineLogger.debug(MessageFormat.format("String_Node_Str", pf.x, pf.y));
    Vector2 p0 = getPosition();
    ArrayList<Vector2> walkingPath = null;
    PixTileMap bgMap = scene.getBackgroundMap();
    if (bgMap != null)
        walkingPath = bgMap.findPath(scene, p0, pf);
    if (walkingPath == null || walkingPath.size() == 0) {
        if (cb != null)
            cb.onEvent();
        return;
    }
    TweenManager manager = TweenManagerSingleton.getInstance();
    manager.killTarget(this);
    WalkTween t = new WalkTween();
    t.start(this, walkingPath, walkingSpeed, cb);
    manager.add(t);
}

Output:
         if (cb != null)
-            cb.onEvent();
+            ActionCallbackQueue.add(cb);
         return;


Input:
public void onNewMerge(Record record) {
    if (record.getRelatedIds().size() > 1) {
        LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str" + record.getRelatedIds().size() + "String_Node_Str");
    } else {
        LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str");
    }
    if (LOGGER.isDebugEnabled()) {
        StringBuilder messageBuilder = new StringBuilder();
        for (Attribute attribute : record.getAttributes()) {
            messageBuilder.append("String_Node_Str").append(attribute.getLabel()).append("String_Node_Str").append(attribute.getValue()).append("String_Node_Str");
        }
        LOGGER.debug(messageBuilder.toString());
    }
}

Output:
 public void onNewMerge(Record record) {
-    if (record.getRelatedIds().size() > 1) {
-        LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str" + record.getRelatedIds().size() + "String_Node_Str");
-    } else {
-        LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str");
+    if (LOGGER.isInfoEnabled()) {
+        if (record.getRelatedIds().size() > 1) {
+            LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str" + record.getRelatedIds().size() + "String_Node_Str");
+        } else {
+            LOGGER.info("String_Node_Str" + record.getId() + "String_Node_Str");
+        }
     }


Input:
public void onConnectionStateChange(ConnectionStateChange change) {
    if (change.getCurrentState() == ConnectionState.CONNECTED) {
        for (String message : queuedSubscribeMessages) {
            connection.sendMessage(message);
            queuedSubscribeMessages.remove(message);
        }
    }
}

Output:
     if (change.getCurrentState() == ConnectionState.CONNECTED) {
-        for (String message : queuedSubscribeMessages) {
-            connection.sendMessage(message);
-            queuedSubscribeMessages.remove(message);
+        for (InternalChannel channel : queuedChannels.keySet()) {
+            String subscribeMessage = queuedChannels.get(channel);
+            connection.sendMessage(subscribeMessage);
+            queuedChannels.remove(channel);
+            channel.updateState(ChannelState.SUBSCRIBE_SENT);
         }


Input:
private void initializeResultClass(DataEngineImpl dataEngine, Map appContext) throws DataException {
    try {
        IResultMetaData leftMetaData = this.leftQueryResults.getResultMetaData();
        IResultMetaData rightMetaData = this.rightQueryResults.getResultMetaData();
        JointResultMetadata meta = getJointResultMetadata(leftMetaData, rightMetaData);
        resultClass = meta.getResultClass();
    } catch (BirtException be) {
        throw DataException.wrap(be);
    }
}

Output:
     try {
-        IResultMetaData leftMetaData = this.leftQueryResults.getResultMetaData();
-        IResultMetaData rightMetaData = this.rightQueryResults.getResultMetaData();
+        IResultMetaData leftMetaData = this.leftResultMetaData;
+        IResultMetaData rightMetaData = this.rightResultMetaData;
         JointResultMetadata meta = getJointResultMetadata(leftMetaData, rightMetaData);


Input:
public String getResponseHeader(String name) {
    return resHeaders.get(name);
}

Output:
 public String getResponseHeader(String name) {
-    return resHeaders.get(name);
+    return resHeaders.get(normalizeHeaderName(name));
 }


Input:
protected void addNewGeneration(GenerationType generation, Long activityId, Long entityId, Connection connection) throws IngestException, SQLException {
    TupleData tuple = new TupleData();
    tuple.addAttribute("String_Node_Str", activityId, TableAttributeData.DataType.LONG);
    tuple.addAttribute("String_Node_Str", entityId, TableAttributeData.DataType.LONG);
    tuple.addAttribute("String_Node_Str", generation.getLocation(), TableAttributeData.DataType.STRING);
    tuple.addAttribute("String_Node_Str", KomaduUtils.getTimestamp(generation.getTimestamp()), TableAttributeData.DataType.TIMESTAMP);
    Long generationId = insertTuple("String_Node_Str", tuple, "String_Node_Str", connection);
    if (generation.getAttributes() != null) {
        addAttributes("String_Node_Str", "String_Node_Str", generationId, generation.getAttributes().getAttributeArray(), connection);
    }
}

Output:
     tuple.addAttribute("String_Node_Str", entityId, TableAttributeData.DataType.LONG);
-    tuple.addAttribute("String_Node_Str", generation.getLocation(), TableAttributeData.DataType.STRING);
-    tuple.addAttribute("String_Node_Str", KomaduUtils.getTimestamp(generation.getTimestamp()), TableAttributeData.DataType.TIMESTAMP);
+    if (generation.isSetLocation())
+        tuple.addAttribute("String_Node_Str", generation.getLocation(), TableAttributeData.DataType.STRING);
+    if (generation.isSetTimestamp())
+        tuple.addAttribute("String_Node_Str", KomaduUtils.getTimestamp(generation.getTimestamp()), TableAttributeData.DataType.TIMESTAMP);
     Long generationId = insertTuple("String_Node_Str", tuple, "String_Node_Str", connection);


Input:
public static void main(String[] args) throws ConfigurationException, DaoException, InterruptedException {
    Env env = EnvBuilder.envFromArgs(args);
    dao = env.getConfigurator().get(LocalLinkDao.class);
    LocalPageDao lpDao = env.getConfigurator().get(LocalPageDao.class);
    for (LocalPage p : (Iterable<LocalPage>) lpDao.get(new DaoFilter().setRedirect(false).setDisambig(false))) {
        localIds.add(p.toLocalId());
        if (localIds.size() % 100000 == 0) {
            System.err.println("String_Node_Str" + localIds);
        }
    }
    List<Worker> workers = new ArrayList<Worker>();
    long start = System.currentTimeMillis();
    for (int i = 0; i < WpThreadUtils.getMaxThreads(); i++) {
        Worker worker = new Worker();
        worker.start();
        workers.add(worker);
    }
    for (Worker worker : workers) {
        System.out.println("String_Node_Str" + worker);
        worker.join();
    }
    System.out.println("String_Node_Str" + (System.currentTimeMillis() - start) + "String_Node_Str" + numRows.get() + "String_Node_Str" + numCells.get());
}

Output:
         if (localIds.size() % 100000 == 0) {
-            System.err.println("String_Node_Str" + localIds);
+            System.err.println("String_Node_Str" + localIds.size());
         }


Input:
public void restoreClicked(ActionEvent event) {
    if (Main.bitcoin.wallet().getBalance().value > 0) {
        informationalAlert("String_Node_Str", "String_Node_Str" + "String_Node_Str");
        return;
    }
    if (aesKey != null) {
        informationalAlert("String_Node_Str", "String_Node_Str");
    }
    log.info("String_Node_Str", wordsArea.getText(), datePicker.getValue());
    informationalAlert("String_Node_Str", "String_Node_Str");
    overlayUI.done();
    long birthday = datePicker.getValue().atStartOfDay().toEpochSecond(ZoneOffset.UTC);
    DeterministicSeed seed = new DeterministicSeed(Splitter.on(' ').splitToList(wordsArea.getText()), null, "String_Node_Str", birthday);
    Main.bitcoin.addListener(new Service.Listener() {
        public void terminated(Service.State from) {
            uncheck(() -> Main.instance.initBitcoin(seed));
            Main.bitcoin.startAsync();
        }
    }, Platform::runLater);
    Main.bitcoin.stopAsync();
}

Output:
     DeterministicSeed seed = new DeterministicSeed(Splitter.on(' ').splitToList(wordsArea.getText()), null, "String_Node_Str", birthday);
-    Main.bitcoin.addListener(new Service.Listener() {
-        public void terminated(Service.State from) {
-            uncheck(() -> Main.instance.initBitcoin(seed));
-            Main.bitcoin.startAsync();
-        }
-    }, Platform::runLater);
-    Main.bitcoin.stopAsync();
+    Main.restartBitcoinJ(seed);
 }


Input:
private int claimCapacity(final AtomicBuffer buffer, final int requiredCapacity) {
    final long head = headVolatile(buffer);
    final int headIndex = (int) head & mask;
    long tail;
    int tailIndex;
    int padding;
    do {
        tail = tailVolatile(buffer);
        final int availableCapacity = capacity - (int) (tail - head);
        if (requiredCapacity > availableCapacity) {
            return INSUFFICIENT_CAPACITY;
        }
        padding = 0;
        tailIndex = (int) tail & mask;
        final int bufferEndSize = capacity - tailIndex;
        if (requiredCapacity > bufferEndSize) {
            if (requiredCapacity > headIndex) {
                return INSUFFICIENT_CAPACITY;
            }
            padding = bufferEndSize;
        }
    } while (!buffer.compareAndSetLong(tailCounterIndex, tail, tail + requiredCapacity + padding));
    if (0 != padding) {
        writePaddingRecord(buffer, tailIndex, padding - HEADER_LENGTH);
        tailIndex = 0;
    }
    return tailIndex;
}

Output:
 private int claimCapacity(final AtomicBuffer buffer, final int requiredCapacity) {
-    final long head = headVolatile(buffer);
+    final int capacity = this.capacity;
+    final long head = buffer.getLongVolatile(headCounterIndex);
     final int headIndex = (int) head & mask;


Input:
void pending() throws ReplicationException {
    state.set(PENDING);
    statusListener.statusChanged(this);
}

Output:
 void pending() throws ReplicationException {
-    state.set(PENDING);
-    statusListener.statusChanged(this);
+    synchronized (state) {
+        state.set(PENDING);
+        statusListener.statusChanged(this);
+    }
 }


Input:
public String safeReadLine(InputStream in, int max) throws ValidationException {
    if (max <= 0)
        throw new ValidationAvailabilityException("String_Node_Str", "String_Node_Str");
    StringBuffer sb = new StringBuffer();
    int count = 0;
    int c;
    try {
        while ((c = in.read()) != -1) {
            sb.append((char) c);
            count++;
            if (count > max)
                throw new ValidationAvailabilityException("String_Node_Str", "String_Node_Str" + max + "String_Node_Str");
            if (c == '\n')
                break;
        }
        return sb.toString();
    } catch (IOException e) {
        throw new ValidationAvailabilityException("String_Node_Str", "String_Node_Str", e);
    }
}

Output:
     try {
-        while ((c = in.read()) != -1) {
+        while (true) {
+            c = in.read();
+            if (c == -1)
+                return null;
+            if (c == '\n' || c == '\r')
+                break;
             sb.append((char) c);


Input:
public Map<UUID, Sentence> generateSentenceIdToSectionMap() {
    if (this.sectionIdToSectionMap == null)
        this.generateSectionIdToSectionMap();
    if (this.sentIdToSentenceMap != null)
        return new HashMap<>(this.sentIdToSentenceMap);
    else {
        final Map<UUID, Sentence> toRet = new HashMap<>();
        List<Section> sectList = new ArrayList<>(this.sectionIdToSectionMap.values());
        for (Section s : sectList) if (s.isSetSentenceSegmentationList())
            for (SentenceSegmentation ss : s.getSentenceSegmentationList()) if (ss.isSetSentenceList())
                for (Sentence st : ss.getSentenceList()) toRet.put(st.getUuid(), st);
        this.sentIdToSentenceMap = toRet;
        return new HashMap<>(toRet);
    }
}

Output:
         List<Section> sectList = new ArrayList<>(this.sectionIdToSectionMap.values());
-        for (Section s : sectList) if (s.isSetSentenceSegmentationList())
-            for (SentenceSegmentation ss : s.getSentenceSegmentationList()) if (ss.isSetSentenceList())
-                for (Sentence st : ss.getSentenceList()) toRet.put(st.getUuid(), st);
+        for (Section s : sectList) for (Sentence st : s.getSentenceList()) toRet.put(st.getUuid(), st);
         this.sentIdToSentenceMap = toRet;


Input:
public static void logEvent(StructuredDataMessage msg, Level level) {
    logger.log(marker, FQCN, level, msg, null);
}

Output:
 public static void logEvent(StructuredDataMessage msg, Level level) {
-    logger.log(marker, FQCN, level, msg, null);
+    logger.log(EVENT_MARKER, FQCN, level, msg, null);
 }


Input:
public void invoke_UpdateEntry() {
    assertEquals(0, cacheWriter.getWriteCount());
    assertEquals(0, cacheWriter.getDeleteCount());
    cache.put(1, "String_Node_Str");
    cache.invokeEntryProcessor(1, new Cache.EntryProcessor<Integer, String, Void>() {

        public Void process(Cache.MutableEntry<Integer, String> entry, Object... arguments) {
            entry.setValue("String_Node_Str");
            return null;
        }
    });
    assertEquals(2, cacheWriter.getWriteCount());
    assertEquals(0, cacheWriter.getDeleteCount());
    assertTrue(cacheWriter.containsKey(1));
    assertEquals("String_Node_Str", cacheWriter.get(1));
}

Output:
     cache.put(1, "String_Node_Str");
-    cache.invokeEntryProcessor(1, new Cache.EntryProcessor<Integer, String, Void>() {
+    cache.invoke(1, new Cache.EntryProcessor<Integer, String, Void>() {


Input:
public boolean canAccessTarget(Entitlement target, Access action) {
    return target.getOwner().getKey().equals(consumer.getOwner().getKey());
}

Output:
 public boolean canAccessTarget(Entitlement target, Access action) {
-    return target.getOwner().getKey().equals(consumer.getOwner().getKey());
+    return target.getConsumer().getUuid().equals(consumer.getUuid());
 }


Input:
private Object getValueForFieldIfAvailable(List<Field> targetFields, Field fieldToBeInjected) {
    InjectionState injectionState = testedField.injectionState;
    injectionState.setTypeOfInjectionPoint(fieldToBeInjected.getGenericType());
    String targetFieldName = fieldToBeInjected.getName();
    MockedType mockedType;
    if (withMultipleTargetFieldsOfSameType(targetFields, fieldToBeInjected)) {
        mockedType = injectionState.findInjectableByTypeAndName(targetFieldName);
    } else {
        mockedType = injectionState.findInjectableByTypeAndOptionallyName(targetFieldName);
    }
    if (mockedType != null) {
        return injectionState.getValueToInject(mockedType);
    }
    KindOfInjectionPoint kindOfInjectionPoint = isAnnotated(fieldToBeInjected);
    if (fullInjection != null) {
        if (testedField.requireDIAnnotation && kindOfInjectionPoint == KindOfInjectionPoint.NotAnnotated) {
            return null;
        }
        Object newInstance = fullInjection.newInstance(this, fieldToBeInjected);
        if (newInstance != null) {
            return newInstance;
        }
    }
    if (kindOfInjectionPoint == KindOfInjectionPoint.WithValue) {
        return getValueFromAnnotation(fieldToBeInjected);
    }
    if (kindOfInjectionPoint == KindOfInjectionPoint.Required) {
        String fieldType = fieldToBeInjected.getGenericType().toString();
        fieldType = TYPE_NAME.matcher(fieldType).replaceAll("String_Node_Str");
        String kindOfInjectable = fullInjection == null ? "String_Node_Str" : "String_Node_Str";
        throw new IllegalStateException("String_Node_Str" + kindOfInjectable + "String_Node_Str" + fieldToBeInjected.getDeclaringClass().getSimpleName() + '#' + fieldToBeInjected.getName() + "String_Node_Str" + fieldType);
    }
    return null;
}

Output:
     if (fullInjection != null) {
-        if (testedField.requireDIAnnotation && kindOfInjectionPoint == KindOfInjectionPoint.NotAnnotated) {
+        if (requireDIAnnotation && kindOfInjectionPoint == KindOfInjectionPoint.NotAnnotated) {
             return null;


Input:
public static final MoveList getMoves(final Piece p, final MoveList list) {
    Position home = p.getPosition();
    int x = home.getX();
    int y = home.getY();
    while (x >= 0 && y >= 0) {
        x--;
        y--;
        Position pos = new Position(x, y);
        if (!list.addMove(new Move(home, pos))) {
            break;
        }
        if (!p.getBoard().isFree(pos)) {
            break;
        }
    }
    x = home.getX();
    y = home.getY();
    while (x < p.getBoard().getWidth() && y < p.getBoard().getHeight()) {
        x++;
        y++;
        Position pos = new Position(x, y);
        if (!list.addCapture(new Move(home, pos))) {
            break;
        }
        if (!p.getBoard().isFree(pos)) {
            break;
        }
    }
    x = home.getX();
    y = home.getY();
    while (x >= 0 && y < p.getBoard().getHeight()) {
        x--;
        y++;
        Position pos = new Position(x, y);
        if (!list.addCapture(new Move(home, pos))) {
            break;
        }
        if (!p.getBoard().isFree(pos)) {
            break;
        }
    }
    x = home.getX();
    y = home.getY();
    while (x < p.getBoard().getWidth() && y >= 0) {
        x++;
        y--;
        Position pos = new Position(x, y);
        if (!list.addCapture(new Move(home, pos))) {
            break;
        }
        if (!p.getBoard().isFree(pos)) {
            break;
        }
    }
    return list;
}

Output:
         Position pos = new Position(x, y);
-        if (!list.addMove(new Move(home, pos))) {
+        if (!list.addCapture(new Move(home, pos))) {
             break;


Input:
public void markDirty() {
    if (editorPart != null)
        editorPart.markDirty();
    DataModelMainPage page = ((DataModelMainPage) getEditor().findPage(DataModelMainPage.class.getName()));
    if (!page.isDirty())
        page.markDirty();
}

Output:
     if (!page.isDirty())
-        page.markDirty();
+        page.markDirtyWithoutCommit();
 }


Input:
private void rebuildSeparators() {
    insertedSeparators = new Barcode();
    separators = new SimpleTree<GroupSeparator>();
    insertedSeparators.add(0, SOURCE_ELEMENT, source.size());
    for (BarcodeIterator i = grouper.getBarcode().iterator(); i.hasNextColour(Grouper.UNIQUE); ) {
        i.nextColour(Grouper.UNIQUE);
        int groupIndex = i.getColourIndex(Grouper.UNIQUE);
        int sourceIndex = i.getIndex();
        insertedSeparators.add(groupIndex + sourceIndex, SEPARATOR, 1);
        Element<GroupSeparator> node = separators.add(groupIndex, new GroupSeparator(), 1);
        node.get().setNode(node);
        node.get().setLimit(defaultLimit);
    }
    for (int i = 0; i < separators.size(); i++) {
        separators.get(i).get().updateCachedValues();
    }
}

Output:
         node.get().setNode(node);
-        node.get().setLimit(defaultLimit);
+        node.get().applyLimit(defaultLimit, false);
     }


Input:
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    int oldVersion = in.readInt();
    _clauseType = in.readInt();
    _matchRefinementName = in.readUTF();
    _thenColumnOffsets = ArrayUtil.readIntArray(in);
    _resultSetFieldName = in.readUTF();
    _actionMethodName = in.readUTF();
    _thenAction = (ConstantAction) in.readObject();
}

Output:
     _clauseType = in.readInt();
-    _matchRefinementName = in.readUTF();
+    _matchRefinementName = (String) in.readObject();
     _thenColumnOffsets = ArrayUtil.readIntArray(in);


Input:
public String toString() {
    if (size() <= 0) {
        return "String_Node_Str";
    }
    StringBuilder buffer = new StringBuilder(size() * 28);
    buffer.append("String_Node_Str").append("String_Node_Str" + mSelection.size()).append("String_Node_Str" + mSelection).append("String_Node_Str" + mProvisionalSelection.size()).append("String_Node_Str" + mProvisionalSelection).append("String_Node_Str");
    return buffer.toString();
}

Output:
 public String toString() {
-    if (size() <= 0) {
-        return "String_Node_Str";
-    }
-    StringBuilder buffer = new StringBuilder(size() * 28);
-    buffer.append("String_Node_Str").append("String_Node_Str" + mSelection.size()).append("String_Node_Str" + mSelection).append("String_Node_Str" + mProvisionalSelection.size()).append("String_Node_Str" + mProvisionalSelection).append("String_Node_Str");
-    return buffer.toString();
+    return "String_Node_Str" + lowerLimit + "String_Node_Str" + upperLimit + "String_Node_Str";
 }


Input:
public void testProcess(final String phrase, final List<Result> resultList) {
    final NerResultSet result = namedEntityAnalyser.process(phrase);
    final Map<NameType, Set<String>> mappedResult = result.getMappedResult();
    for (final Result r : resultList) {
        assertTrue(mappedResult.containsKey(r.type), "String_Node_Str" + r.phrase + "String_Node_Str" + r.type + "String_Node_Str" + mappedResult + "String_Node_Str");
        final Set<String> phrases = mappedResult.get(r.type);
        assertNotNull(phrases.remove(r.phrase), "String_Node_Str" + r.phrase + "String_Node_Str" + phrases + "String_Node_Str");
        if (phrases.isEmpty())
            mappedResult.remove(r.type);
    }
    assertTrue(mappedResult.isEmpty(), "String_Node_Str" + mappedResult);
    for (int i = 0; i < result.phrases.get(0).size(); i++) {
        final Phrase p = result.phrases.get(0).get(i);
        final Result r = resultList.get(i);
        assertEquals(p.score, r.scores, "String_Node_Str" + p.phraseString() + "String_Node_Str" + Arrays.toString(r.scores) + "String_Node_Str" + Arrays.toString(p.score) + "String_Node_Str");
        assertEquals(p.attachedWordMap, r.attachedWordMap);
    }
}

Output:
     assertTrue(mappedResult.isEmpty(), "String_Node_Str" + mappedResult);
-    for (int i = 0; i < result.phrases.get(0).size(); i++) {
-        final Phrase p = result.phrases.get(0).get(i);
+    final List<Phrase> flat = new ArrayList<>();
+    for (final List<Phrase> l : result.phrases) {
+        for (final Phrase p : l) {
+            flat.add(p);
+        }
+    }
+    for (int i = 0; i < flat.size(); i++) {
+        final Phrase p = flat.get(i);
         final Result r = resultList.get(i);


Input:
public void onInteract(PlayerInteractEvent e) {
    if (e.getAction() != Action.RIGHT_CLICK_BLOCK)
        return;
    Block b = e.getClickedBlock();
    SlimefunItem item = BlockStorage.check(b);
    if (item != null) {
        if (item.getName().equals("String_Node_Str")) {
            e.setCancelled(true);
            Item stack = findItem(b);
            if (stack == null) {
                insertItem(e.getPlayer(), b);
            } else if (!removed_items.contains(stack.getUniqueId())) {
                final UUID uuid = stack.getUniqueId();
                removed_items.add(uuid);
                SlimefunStartup.instance.getServer().getScheduler().scheduleSyncDelayedTask(SlimefunStartup.instance, new Runnable() {
                    public void run() {
                        removed_items.remove(uuid);
                    }
                }, 30L);
                stack.remove();
                e.getPlayer().getInventory().addItem(fixItemStack(stack.getItemStack(), stack.getCustomName()));
                e.getPlayer().playSound(b.getLocation(), Sound.ENTITY_ITEM_PICKUP, 1F, 1F);
                PlayerInventory.update(e.getPlayer());
            }
        } else if (item.getName().equals("String_Node_Str")) {
            e.setCancelled(true);
            ItemStack catalyst = e.getPlayer().getInventory().getItemInMainHand();
            List<Block> pedestals = Pedestals.getPedestals(b);
            if (!altars.contains(e.getClickedBlock())) {
                altars.add(e.getClickedBlock());
                if (pedestals.size() == 8) {
                    if (catalyst != null && !catalyst.getType().equals(Material.AIR)) {
                        List<ItemStack> input = new ArrayList<ItemStack>();
                        for (Block pedestal : pedestals) {
                            Item stack = findItem(pedestal);
                            if (stack != null)
                                input.add(fixItemStack(stack.getItemStack(), stack.getCustomName()));
                        }
                        ItemStack result = Pedestals.getRecipeOutput(catalyst, input);
                        if (result != null) {
                            List<ItemStack> consumed = new ArrayList<ItemStack>();
                            consumed.add(catalyst);
                            PlayerInventory.consumeItemInHand(e.getPlayer());
                            Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunStartup.instance, new RitualAnimation(altars, b, b.getLocation().add(0.5, 1.3, 0.5), result, pedestals, consumed), 10L);
                        } else {
                            altars.remove(e.getClickedBlock());
                            Messages.local.sendTranslation(e.getPlayer(), "String_Node_Str", true);
                        }
                    } else {
                        altars.remove(e.getClickedBlock());
                        Messages.local.sendTranslation(e.getPlayer(), "String_Node_Str", true);
                    }
                } else {
                    altars.remove(e.getClickedBlock());
                    Messages.local.sendTranslation(e.getPlayer(), "String_Node_Str", true, new Variable("String_Node_Str", String.valueOf(pedestals.size())));
                }
            }
        }
    }
}

Output:
             e.setCancelled(true);
-            ItemStack catalyst = e.getPlayer().getInventory().getItemInMainHand();
+            ItemStack catalyst = new CustomItem(e.getPlayer().getInventory().getItemInMainHand(), 1);
             List<Block> pedestals = Pedestals.getPedestals(b);


Input:
public Observable<Void> call(Void qbVoid) {
    authorized = true;
    notifyLogout(QMAuthService.this);
    return observable;
}

Output:
 public Observable<Void> call(Void qbVoid) {
-    authorized = true;
+    authorized = false;
     notifyLogout(QMAuthService.this);


Input:
protected NCellStyle importCellStyle(CellStyle poiCellStyle) {
    NCellStyle cellStyle = null;
    if ((cellStyle = importedStyle.get(poiCellStyle.getIndex())) == null) {
        cellStyle = book.createCellStyle(true);
        importedStyle.put(poiCellStyle.getIndex(), cellStyle);
        String dataFormat = null;
        if ((dataFormat = BuiltinFormats.getBuiltinFormat(poiCellStyle.getDataFormat())) == null) {
            dataFormat = poiCellStyle.getDataFormatString();
        }
        if (dataFormat == null) {
            dataFormat = NCellStyle.FORMAT_GENERAL;
        }
        cellStyle.setDataFormat(dataFormat);
        cellStyle.setWrapText(poiCellStyle.getWrapText());
        cellStyle.setLocked(poiCellStyle.getLocked());
        cellStyle.setAlignment(convertAlignment(poiCellStyle.getAlignment()));
        cellStyle.setVerticalAlignment(convertVerticalAlignment(poiCellStyle.getVerticalAlignment()));
        cellStyle.setFillColor(book.createColor(BookHelper.colorToBackgroundHTML(workbook, poiCellStyle.getFillForegroundColorColor())));
        cellStyle.setBorderLeft(convertBorderType(poiCellStyle.getBorderLeft()));
        cellStyle.setBorderTop(convertBorderType(poiCellStyle.getBorderTop()));
        cellStyle.setBorderRight(convertBorderType(poiCellStyle.getBorderRight()));
        cellStyle.setBorderBottom(convertBorderType(poiCellStyle.getBorderBottom()));
        cellStyle.setBorderLeftColor(book.createColor(BookHelper.colorToBorderHTML(workbook, poiCellStyle.getLeftBorderColorColor())));
        cellStyle.setBorderTopColor(book.createColor(BookHelper.colorToBorderHTML(workbook, poiCellStyle.getTopBorderColorColor())));
        cellStyle.setBorderRightColor(book.createColor(BookHelper.colorToBorderHTML(workbook, poiCellStyle.getRightBorderColorColor())));
        cellStyle.setBorderBottomColor(book.createColor(BookHelper.colorToBorderHTML(workbook, poiCellStyle.getBottomBorderColorColor())));
        cellStyle.setHidden(poiCellStyle.getHidden());
        cellStyle.setFillPattern(convertPoiFillPattern(poiCellStyle.getFillPattern()));
        cellStyle.setFont(importFont(poiCellStyle));
    }
    return cellStyle;
}

Output:
     NCellStyle cellStyle = null;
-    if ((cellStyle = importedStyle.get(poiCellStyle.getIndex())) == null) {
+    short idx = poiCellStyle.getIndex();
+    if ((cellStyle = importedStyle.get(idx)) == null) {
         cellStyle = book.createCellStyle(true);


Input:
public void secureMode(InventoryClickEvent event, TraderStatus trader, StockItem si, InventoryTrait sr) {
    if (event.getWhoClicked() instanceof Player) {
        Player p = (Player) event.getWhoClicked();
        DecimalFormat f = new DecimalFormat("String_Node_Str");
        if (trader.getStatus().equals(Status.PLAYER_SELL) || trader.getStatus().equals(Status.PLAYER_SELL_AMOUT)) {
            if (trader.getStatus().equals(Status.PLAYER_SELL_AMOUT))
                si = trader.getStockItem();
            else
                si = sr.itemForSell(event.getSlot());
            if (si != null) {
                if (event.isShiftClick()) {
                    if (si.hasMultipleAmouts() && trader.getStatus().equals(Status.PLAYER_SELL_AMOUT)) {
                        if (econ.has(p.getName(), si.getPrice(event.getSlot()))) {
                            if (!event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 14)) && !event.getCurrentItem().getType().equals(Material.AIR)) {
                                econ.withdrawPlayer(p.getName(), si.getPrice(event.getSlot()));
                                p.getInventory().addItem(event.getCurrentItem());
                                p.sendMessage(ChatColor.GOLD + "String_Node_Str" + event.getCurrentItem().getAmount() + "String_Node_Str" + f.format(si.getPrice(event.getSlot())) + "String_Node_Str");
                            }
                        } else {
                            p.sendMessage(ChatColor.GOLD + "String_Node_Str");
                        }
                    } else {
                        if (econ.has(p.getName(), si.getPrice())) {
                            econ.withdrawPlayer(p.getName(), si.getPrice());
                            p.getInventory().addItem(si.getItemStack());
                            p.sendMessage(ChatColor.GOLD + "String_Node_Str" + si.getItemStack().getAmount() + "String_Node_Str" + f.format(si.getPrice()) + "String_Node_Str");
                        } else {
                            p.sendMessage(ChatColor.GOLD + "String_Node_Str");
                        }
                    }
                } else {
                    if (trader.getStatus().equals(Status.PLAYER_SELL_AMOUT)) {
                        if (event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 14)) && (event.getSlot() == trader.getInventory().getSize() - 1)) {
                            trader.getInventory().clear();
                            sr.inventoryView(trader.getInventory(), Status.PLAYER_SELL);
                            trader.setStatus(Status.PLAYER_SELL);
                            trader.setStockItem(null);
                        } else {
                            if (!event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 14)) && !event.getCurrentItem().getType().equals(Material.AIR))
                                p.sendMessage(ChatColor.GOLD + "String_Node_Str" + f.format(si.getPrice(event.getSlot())) + "String_Node_Str");
                        }
                    } else if (trader.getStatus().equals(Status.PLAYER_SELL)) {
                        if (si.hasMultipleAmouts()) {
                            if (trader.getStatus().equals(Status.PLAYER_SELL)) {
                                trader.getInventory().clear();
                                InventoryTrait.setInventoryWith(trader.getInventory(), si);
                                trader.setStatus(Status.PLAYER_SELL_AMOUT);
                                trader.setStockItem(si);
                            }
                        } else {
                            p.sendMessage(ChatColor.GOLD + "String_Node_Str" + f.format(si.getPrice()) + "String_Node_Str");
                        }
                    }
                }
            } else if (event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 5)) && (event.getSlot() == trader.getInventory().getSize() - 1)) {
                trader.getInventory().clear();
                sr.inventoryView(trader.getInventory(), Status.PLAYER_BUY);
                trader.setStatus(Status.PLAYER_BUY);
                trader.setStockItem(null);
            }
        } else if (trader.getStatus().equals(Status.PLAYER_BUY)) {
            si = sr.wantItemBuy(event.getSlot());
            if (si != null) {
                if (si.getItemStack().getType().equals(event.getCursor().getType()) && si.getItemStack().getData().equals(event.getCursor().getData())) {
                    econ.depositPlayer(p.getName(), si.getPrice() * event.getCursor().getAmount());
                    p.sendMessage(ChatColor.GOLD + "String_Node_Str" + event.getCursor().getAmount() + "String_Node_Str" + f.format(si.getPrice() * event.getCursor().getAmount()) + "String_Node_Str");
                    event.setCursor(new ItemStack(Material.AIR));
                } else {
                    if (!event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 3)) && !event.getCurrentItem().getType().equals(Material.AIR))
                        p.sendMessage(ChatColor.GOLD + "String_Node_Str" + f.format(si.getPrice()) + "String_Node_Str");
                }
            } else {
                if (event.getCurrentItem().equals(new ItemStack(Material.WOOL, 1, (short) 0, (byte) 3)) && (event.getSlot() == trader.getInventory().getSize() - 1)) {
                    trader.getInventory().clear();
                    sr.inventoryView(trader.getInventory(), Status.PLAYER_SELL);
                    trader.setStatus(Status.PLAYER_SELL);
                    trader.setStockItem(null);
                }
            }
        }
    }
}

Output:
         DecimalFormat f = new DecimalFormat("String_Node_Str");
-        if (trader.getStatus().equals(Status.PLAYER_SELL) || trader.getStatus().equals(Status.PLAYER_SELL_AMOUT)) {
+        boolean top = event.getView().convertSlot(event.getRawSlot()) == event.getRawSlot();
+        if (trader.getStatus().equals(Status.PLAYER_SELL) || trader.getStatus().equals(Status.PLAYER_SELL_AMOUT) && top) {
             if (trader.getStatus().equals(Status.PLAYER_SELL_AMOUT))


Input:
public boolean canEdit(String email, TravelExpense travelExpense) {
    return email != null && travelExpense.getReport().getEmployee().getEmail().equals(email) && travelExpense.getReport().getStatus() != Report.Status.APPROVED && travelExpense.getReport().getStatus() != Report.Status.SUBMITTED;
}

Output:
 public boolean canEdit(String email, TravelExpense travelExpense) {
-    return email != null && travelExpense.getReport().getEmployee().getEmail().equals(email) && travelExpense.getReport().getStatus() != Report.Status.APPROVED && travelExpense.getReport().getStatus() != Report.Status.SUBMITTED;
+    return email != null && email.equals(travelExpense.getReport().getEmployee().getEmail()) && travelExpense.getReport().getStatus() != Report.Status.APPROVED && travelExpense.getReport().getStatus() != Report.Status.SUBMITTED;
 }


Input:
public void onReceiveResult(int resultCode, Bundle resultData) {
    if (resultCode == ProviderAPI.PROVIDER_OK) {
        mConfigState.setAction(PROVIDER_SET);
        try {
            String provider_json_string = preferences.getString(Provider.KEY, "String_Node_Str");
            if (!provider_json_string.isEmpty())
                selected_provider.define(new JSONObject(provider_json_string));
        } catch (JSONException e) {
            e.printStackTrace();
        }
        if (preferences.getBoolean(Constants.ALLOWED_ANON, false)) {
            mConfigState.putExtra(SERVICES_RETRIEVED, true);
            downloadVpnCertificate();
        } else {
            mProgressBar.incrementProgressBy(1);
            hideProgressBar();
            showProviderDetails();
        }
    } else if (resultCode == ProviderAPI.PROVIDER_NOK) {
        hideProgressBar();
        preferences.edit().remove(Provider.KEY).apply();
        setting_up_provider = false;
        String reason_to_fail = resultData.getString(ProviderAPI.ERRORS);
        showDownloadFailedDialog(reason_to_fail);
    } else if (resultCode == ProviderAPI.CORRECTLY_DOWNLOADED_CERTIFICATE) {
        mProgressBar.incrementProgressBy(1);
        hideProgressBar();
        showProviderDetails();
    } else if (resultCode == ProviderAPI.INCORRECTLY_DOWNLOADED_CERTIFICATE) {
        hideProgressBar();
        cancelSettingUpProvider();
        Toast.makeText(getApplicationContext(), R.string.provider_problem, Toast.LENGTH_LONG).show();
    } else if (resultCode == AboutActivity.VIEWED) {
    }
}

Output:
         hideProgressBar();
-        cancelSettingUpProvider();
+        setResult(RESULT_CANCELED, mConfigState);
         Toast.makeText(getApplicationContext(), R.string.provider_problem, Toast.LENGTH_LONG).show();


Input:
private void processAssociatedTerms(AtlasGlossaryCategory newObj, AtlasGlossaryCategory existing, RelationshipOperation op) throws AtlasBaseException {
    Set<AtlasRelatedTermHeader> newTerms = newObj.getTerms();
    Set<AtlasRelatedTermHeader> existingTerms = existing.getTerms();
    switch(op) {
        case CREATE:
            if (DEBUG_ENABLED) {
                LOG.debug("String_Node_Str", existing.getDisplayName(), Objects.nonNull(newTerms) ? newTerms.size() : "String_Node_Str");
            }
            createTermCategorizationRelationships(existing, newTerms);
            break;
        case UPDATE:
            if (CollectionUtils.isEmpty(existingTerms)) {
                if (DEBUG_ENABLED) {
                    LOG.debug("String_Node_Str", existing.getDisplayName(), Objects.nonNull(newTerms) ? newTerms.size() : "String_Node_Str");
                }
                createTermCategorizationRelationships(existing, newTerms);
                break;
            }
            if (CollectionUtils.isEmpty(newTerms)) {
                if (DEBUG_ENABLED) {
                    LOG.debug("String_Node_Str", existing.getDisplayName(), existingTerms.size());
                }
                deleteTermCategorizationRelationships(existing, existingTerms);
                break;
            }
            Set<AtlasRelatedTermHeader> toCreate = newTerms.stream().filter(c -> Objects.isNull(c.getRelationGuid())).collect(Collectors.toSet());
            createTermCategorizationRelationships(existing, toCreate);
            Set<AtlasRelatedTermHeader> toUpdate = newTerms.stream().filter(c -> Objects.nonNull(c.getRelationGuid()) && existingTerms.contains(c)).collect(Collectors.toSet());
            updateTermCategorizationRelationships(existing, toUpdate);
            Set<AtlasRelatedTermHeader> toDelete = existingTerms.stream().filter(c -> !toCreate.contains(c) && !toUpdate.contains(c)).collect(Collectors.toSet());
            deleteTermCategorizationRelationships(existing, toDelete);
            break;
        case DELETE:
            deleteTermCategorizationRelationships(existing, existingTerms);
            break;
    }
}

Output:
             }
-            createTermCategorizationRelationships(existing, newTerms);
+            createTermCategorizationRelationships(existing, newTerms.values());
             break;


Input:
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    if (mDataNotSet)
        return;
    mXAxisRenderer.renderAxis(mDrawCanvas);
    if (mDrawWeb)
        mRenderer.drawExtras(mDrawCanvas);
    mYAxisRenderer.renderLimitLines(mDrawCanvas);
    mRenderer.drawData(mDrawCanvas);
    if (mHighlightEnabled && valuesToHighlight())
        mRenderer.drawHighlighted(mDrawCanvas, mIndicesToHightlight);
    mYAxisRenderer.renderAxis(mDrawCanvas);
    mRenderer.drawValues(mDrawCanvas);
    mLegendRenderer.renderLegend(mDrawCanvas, mLegend);
    drawDescription();
    drawMarkers();
    canvas.drawBitmap(mDrawBitmap, 0, 0, mDrawPaint);
}

Output:
         return;
-    mXAxisRenderer.renderAxis(mDrawCanvas);
+    mXAxisRenderer.renderAxisLabels(mDrawCanvas);
     if (mDrawWeb)


Input:
private synchronized void open() {
    File dir = new File(directory);
    if (!dir.isAbsolute())
        dir = new File(System.getProperty("String_Node_Str"), directory);
    dir.mkdirs();
    try {
        String pathname;
        if (rotatable) {
            pathname = dir.getAbsolutePath() + File.separator + prefix + dateStamp + suffix;
        } else {
            pathname = dir.getAbsolutePath() + File.separator + prefix + suffix;
        }
        currentLogFile = new File(pathname);
        writer = new PrintWriter(new FileWriter(pathname, true), true);
        if (currentLogFile.length() == 0) {
            writer.println("String_Node_Str" + pattern);
            writer.println("String_Node_Str");
            writer.println("String_Node_Str" + ServerInfo.getServerInfo());
        }
    } catch (IOException e) {
        writer = null;
        currentLogFile = null;
    }
}

Output:
         dir = new File(System.getProperty("String_Node_Str"), directory);
-    dir.mkdirs();
+    if (!dir.mkdirs() && !dir.isDirectory()) {
+        log.log(Level.SEVERE, sm.getString("String_Node_Str", dir));
+    }
     try {


Input:
public static String getIndicatorPercentValue(Indicator indicator) {
    try {
        double userCount = NumberFormat.getInstance().parse(getIndicatorValue(indicator)).doubleValue();
        double count = Double.valueOf(indicator.getCount());
        return computePercent(userCount, count);
    } catch (NumberFormatException e) {
        log.warn("String_Node_Str" + indicator.getName(), e);
        return null;
    } catch (ParseException e) {
        log.warn("String_Node_Str" + indicator.getName(), e);
        return null;
    }
}

Output:
     try {
-        double userCount = NumberFormat.getInstance().parse(getIndicatorValue(indicator)).doubleValue();
-        double count = Double.valueOf(indicator.getCount());
-        return computePercent(userCount, count);
+        String indicatorValue = getIndicatorValue(indicator);
+        if (indicatorValue != null) {
+            double userCount = NumberFormat.getInstance().parse(indicatorValue).doubleValue();
+            double count = Double.valueOf(indicator.getCount());
+            return computePercent(userCount, count);
+        }
     } catch (NumberFormatException e) {


Input:
protected ClassLoader addCustomConfsJarIfNeeded(ClassLoader baseLoader, HadoopServiceProperties serviceProperties) {
    ClassLoader classLoader = baseLoader;
    if (serviceProperties.isUseCustomConfs()) {
        String clusterId = serviceProperties.getRelativeHadoopClusterId();
        if (baseLoader instanceof DynamicClassLoader && clusterId != null) {
            String customConfsJarName = HadoopParameterUtil.getConfsJarDefaultName(clusterId);
            try {
                classLoader = DynamicClassLoader.createNewOneBaseLoader((DynamicClassLoader) baseLoader, new String[] { customConfsJarName }, null);
            } catch (MalformedURLException e) {
                ExceptionHandler.process(e);
            }
        }
    }
    return classLoader;
}

Output:
     if (serviceProperties.isUseCustomConfs()) {
-        String clusterId = serviceProperties.getRelativeHadoopClusterId();
-        if (baseLoader instanceof DynamicClassLoader && clusterId != null) {
-            String customConfsJarName = HadoopParameterUtil.getConfsJarDefaultName(clusterId);
-            try {
-                classLoader = DynamicClassLoader.createNewOneBaseLoader((DynamicClassLoader) baseLoader, new String[] { customConfsJarName }, null);
-            } catch (MalformedURLException e) {
-                ExceptionHandler.process(e);
+        String clusterLabel = serviceProperties.getRelativeHadoopClusterLabel();
+        if (classLoader instanceof DynamicClassLoader && clusterLabel != null) {
+            String customConfsJarName = HadoopParameterUtil.getConfsJarDefaultName(clusterLabel);
+            boolean confFileExist = false;
+            Set<String> libraries = ((DynamicClassLoader) classLoader).getLibraries();
+            for (String lib : libraries) {
+                if (customConfsJarName.equals(lib)) {
+                    confFileExist = true;
+                    break;
+                }
+            }
+            if (!confFileExist) {
+                try {
+                    classLoader = DynamicClassLoader.createNewOneBaseLoader((DynamicClassLoader) baseLoader, new String[] { customConfsJarName }, null);
+                } catch (MalformedURLException e) {
+                    ExceptionHandler.process(e);
+                }
             }


Input:
public void generateLoadMessagesService(Collection<CellDescription> cells) {
    CellResourceManager crm = AppContext.getManager(CellResourceManager.class);
    SecurityManager security = AppContext.getManager(SecurityManager.class);
    ResourceMap rm = new ResourceMap();
    Map<CellID, CellDescription> granted = new HashMap<CellID, CellDescription>();
    Map<CellID, CellDescription> check = new HashMap<CellID, CellDescription>();
    for (CellDescription cell : cells) {
        Resource resource = crm.getCellResource(cell.getCellID());
        if (resource == null) {
            granted.put(cell.getCellID(), cell);
        } else {
            Resource r = new CellIDResource(cell.getCellID(), resource);
            rm.put(r.getId(), new ActionMap(r, new ViewAction()));
            check.put(cell.getCellID(), cell);
        }
    }
    if (check.size() > 0) {
        SecureTask checkLoad = new LoadCellsTask(check, granted, this);
        security.doSecure(rm, checkLoad);
    } else {
        sendLoadMessages(cells);
    }
}

Output:
     ResourceMap rm = new ResourceMap();
-    Map<CellID, CellDescription> granted = new HashMap<CellID, CellDescription>();
-    Map<CellID, CellDescription> check = new HashMap<CellID, CellDescription>();
+    Map<CellID, CellDescription> cellsMap = new LinkedHashMap<CellID, CellDescription>();
     for (CellDescription cell : cells) {


Input:
public void setModel(TreeModel model) throws Exception {
    _model = model;
    syncModel();
    initDataListener();
}

Output:
 public void setModel(TreeModel model) throws Exception {
-    _model = model;
-    syncModel();
-    initDataListener();
+    if (model != null) {
+        if (_model != model) {
+            if (_model != null) {
+                _model.removeTreeDataListener(_dataListener);
+            } else {
+                getItems().clear();
+            }
+            _model = model;
+            initDataListener();
+        }
+        syncModel();
+    } else if (_model != null) {
+        _model.removeTreeDataListener(_dataListener);
+        _model = null;
+        getItems().clear();
+    }
 }


Input:
static final BranchHandle getBranchHandle(BranchInstruction i) {
    if (bh_list == null)
        return new BranchHandle(i);
    else {
        BranchHandle bh = bh_list;
        bh_list = (BranchHandle) bh.next;
        bh.setInstruction(i);
        return bh;
    }
}

Output:
 static final BranchHandle getBranchHandle(BranchInstruction i) {
-    if (bh_list == null)
-        return new BranchHandle(i);
-    else {
-        BranchHandle bh = bh_list;
-        bh_list = (BranchHandle) bh.next;
-        bh.setInstruction(i);
-        return bh;
-    }
+    return new BranchHandle(i);
 }


Input:
public void save(File jar) throws IOException {
    try (JarOutputStream output = new JarOutputStream(new FileOutputStream(jar))) {
        for (String name : classes.keySet()) {
            byte[] data = recaf.asm.toBytes(classes.get(name));
            output.putNextEntry(new JarEntry(name.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str"));
            output.write(data);
            output.closeEntry();
        }
        for (String name : resources.keySet()) {
            output.putNextEntry(new JarEntry(name));
            output.write(resources.get(name));
            output.closeEntry();
        }
    }
}

Output:
     try (JarOutputStream output = new JarOutputStream(new FileOutputStream(jar))) {
-        for (String name : classes.keySet()) {
-            byte[] data = recaf.asm.toBytes(classes.get(name));
-            output.putNextEntry(new JarEntry(name.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str"));
+        for (Entry<String, ClassNode> entry : classes.entrySet()) {
+            byte[] data = recaf.asm.toBytes(entry.getValue());
+            output.putNextEntry(new JarEntry(entry.getKey().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str"));
             output.write(data);


Input:
private boolean writeToFile(String key, Bitmap bitmap) {
    if (bitmap == null || StringHelper.isEmpty(key)) {
        return false;
    }
    String filename = StringHelper.md5(key) + "String_Node_Str";
    File file = new File(IOHelper.getImageCacheDir(mContext), filename);
    if (App.DEBUG) {
        Log.i(TAG, "String_Node_Str" + filename);
    }
    return ImageHelper.writeToFile(file, bitmap);
}

Output:
     if (App.DEBUG) {
-        Log.i(TAG, "String_Node_Str" + filename);
+        Log.d(TAG, "String_Node_Str" + filename);
     }


Input:
public void nextRound(Round round) {
    if (round instanceof StartRound) {
        if (((StartRound) round).getStartPacket().areAllSold()) {
            beginStartRound();
        } else {
            startOperatingRound(runIfStartPacketIsNotCompletelySold());
        }
        numOfORs.set(10);
    } else if (round instanceof StockRound) {
        relativeORNumber.set(1);
        orControl.startedFromStockRound();
        startOperatingRound(true);
    } else if (round instanceof OperatingRound_1880) {
        if ((orControl.isFinalOperatingRoundSequence()) && (getRelativeORNumber() == 3)) {
            finishGame();
        } else if (getRoot().getCompanyManager().getNextUnfinishedStartPacket() != null) {
            beginStartRound();
        } else if (orControl.isExitingToStockRound() == true) {
            startStockRound();
        } else {
            orControl.startedFromOperatingRound();
            relativeORNumber.add(1);
            startOperatingRound(true);
        }
    }
}

Output:
     } else if (round instanceof OperatingRound_1880) {
-        if ((orControl.isFinalOperatingRoundSequence()) && (getRelativeORNumber() == 3)) {
+        if (orControl.getFinalOperatingRoundSequenceNumber() > 3) {
             finishGame();


Input:
public static List<ILeafElement> trimLeafElementsFirstAndSanitize(List<ILeafElement> leafElements) {
    List<ILeafElement> waitingLeafs = new ArrayList<>(leafElements);
    while (waitingLeafs.size() > 0 && waitingLeafs.get(0) instanceof Text) {
        Text text = (Text) waitingLeafs.get(0);
        trimLeafElementFirst(text);
        if (text.getText().length() == 0) {
            waitingLeafs.remove(0);
        } else {
            break;
        }
    }
    int pos = 0;
    while (pos < waitingLeafs.size() - 1) {
        if (waitingLeafs.get(pos) instanceof Text) {
            Text first = (Text) waitingLeafs.get(pos);
            if (first.getText().length() > 0 && isNonLineBreakSpace(first.getText().charAt(first.getText().length() - 1))) {
                while (pos + 1 < waitingLeafs.size() && waitingLeafs.get(pos + 1) instanceof Text) {
                    Text second = (Text) waitingLeafs.get(pos + 1);
                    if (second.getText().length() > 0 && isNonLineBreakSpace(second.getText().charAt(0))) {
                        int secondPos = 0;
                        while (secondPos < second.getText().length() && isNonLineBreakSpace(second.getText().charAt(secondPos))) {
                            secondPos++;
                        }
                        second.setText(second.getText().substring(secondPos));
                    }
                    if (second.getText().length() == 0) {
                        waitingLeafs.remove(pos + 1);
                    } else {
                        break;
                    }
                }
            }
        }
        pos++;
    }
    return waitingLeafs;
}

Output:
 public static List<ILeafElement> trimLeafElementsFirstAndSanitize(List<ILeafElement> leafElements) {
-    List<ILeafElement> waitingLeafs = new ArrayList<>(leafElements);
-    while (waitingLeafs.size() > 0 && waitingLeafs.get(0) instanceof Text) {
-        Text text = (Text) waitingLeafs.get(0);
-        trimLeafElementFirst(text);
-        if (text.getText().length() == 0) {
-            waitingLeafs.remove(0);
-        } else {
-            break;
-        }
-    }
+    ArrayList<ILeafElement> waitingLeafs = new ArrayList<ILeafElement>(leafElements);
+    trimSubList(waitingLeafs, 0, waitingLeafs.size(), false);
     int pos = 0;


Input:
private LogisticRegressionParams initOrRecoverParams(MasterContext<LogisticRegressionParams, LogisticRegressionParams> context) {
    LOG.info("String_Node_Str");
    LogisticRegressionParams params = null;
    try {
        Path modelPath = new Path(context.getProps().getProperty(CommonConstants.GUAGUA_OUTPUT));
        LR existingModel = (LR) CommonUtils.loadModel(modelConfig, columnConfigList, modelPath, ShifuFileUtils.getFileSystemBySourceType(this.modelConfig.getDataSet().getSource()));
        if (existingModel == null) {
            params = initWeights();
            LOG.info("String_Node_Str");
        } else {
            params = initModelParams(existingModel);
            LOG.info("String_Node_Str", modelPath);
        }
    } catch (IOException e) {
        throw new GuaguaRuntimeException(e);
    }
    return params;
}

Output:
         Path modelPath = new Path(context.getProps().getProperty(CommonConstants.GUAGUA_OUTPUT));
-        LR existingModel = (LR) CommonUtils.loadModel(modelConfig, columnConfigList, modelPath, ShifuFileUtils.getFileSystemBySourceType(this.modelConfig.getDataSet().getSource()));
+        LR existingModel = (LR) CommonUtils.loadModel(modelConfig, modelPath, ShifuFileUtils.getFileSystemBySourceType(this.modelConfig.getDataSet().getSource()));
         if (existingModel == null) {


Input:
public final void parameters(final String[] par, final SnipeData v) {
    for (int _i = 0; _i < par.length; _i++) {
        final String _param = par[_i];
        try {
            if (_param.equalsIgnoreCase("String_Node_Str")) {
                v.sendMessage(ChatColor.BLUE + "String_Node_Str");
                v.sendMessage(ChatColor.GREEN + "String_Node_Str" + ChatColor.BLUE + "String_Node_Str");
            } else if (_param.equalsIgnoreCase("String_Node_Str")) {
                if ((_i + 1) >= par.length) {
                    v.sendMessage(ChatColor.RED + "String_Node_Str");
                    continue;
                }
                int _tmp = Integer.parseInt(par[++_i]);
                if (_tmp < WATER_LEVEL_MIN) {
                    v.sendMessage(ChatColor.RED + "String_Node_Str");
                    continue;
                }
                this.waterLevel = _tmp;
                v.sendMessage(ChatColor.BLUE + "String_Node_Str" + ChatColor.GREEN + (waterLevel + 1));
            }
        } catch (Exception _e) {
            v.sendMessage(ChatColor.RED + String.format("String_Node_Str", _param));
            _e.printStackTrace();
        }
    }
}

Output:
                 int _tmp = Integer.parseInt(par[++_i]);
-                if (_tmp < WATER_LEVEL_MIN) {
+                if (_tmp <= WATER_LEVEL_MIN) {
                     v.sendMessage(ChatColor.RED + "String_Node_Str");


Input:
public T one(Object... paramValues) {
    Filter filter = createFilter(paramValues);
    TypedQuery<T> query = createCollectionQuery(filter);
    filter.setParameters(query);
    return query.getSingleResult();
}

Output:
     Filter filter = createFilter(paramValues);
-    TypedQuery<T> query = createCollectionQuery(filter);
-    filter.setParameters(query);
-    return query.getSingleResult();
+    return createCollectionQuery(filter).getSingleResult();
 }


Input:
public void threeDistanceOnlyIteration() {
    Iterator<Vector3i> iter = new Diamond3iIterator(Vector3i.zero(), 4, 3);
    while (iter.hasNext()) {
        Vector3i next = iter.next();
        assertEquals(3, Vector3i.zero().gridDistance(next));
    }
}

Output:
 public void threeDistanceOnlyIteration() {
-    Iterator<Vector3i> iter = new Diamond3iIterator(Vector3i.zero(), 4, 3);
-    while (iter.hasNext()) {
-        Vector3i next = iter.next();
-        assertEquals(3, Vector3i.zero().gridDistance(next));
+    Set<Vector3i> iter = Sets.newHashSet(Diamond3iIterator.iterate(Vector3i.zero(), 3));
+    assertEquals(63, iter.size());
+    for (Vector3i pos : iter) {
+        assertTrue(pos.gridDistance(new Vector3i()) <= 3);
     }


Input:
public String getColumnText(Object element, int columnIndex) {
    String value = null;
    ColumnDefn defn = null;
    if (element instanceof ColumnDefn) {
        defn = (ColumnDefn) element;
    } else {
        return "String_Node_Str";
    }
    switch(columnIndex) {
        case 1:
            {
                value = defn.getColumnName();
                break;
            }
        case 2:
            {
                if (defn != newDefn)
                    value = getTypeDisplayName(defn.getDataType());
                break;
            }
        case 3:
            {
                value = defn.getAlias();
                break;
            }
        case 4:
            {
                value = defn.getDisplayName();
                break;
            }
        case 5:
            {
                value = defn.getHelpText();
                break;
            }
    }
    if (value == null) {
        value = "String_Node_Str";
    }
    return value;
}

Output:
             {
-                value = defn.getHelpText();
+                value = defn.getDisplayNameKey();
                 break;


Input:
public static void initCrafting() {
    GameRegistry.addRecipe(new ItemStack(boosterBlock), "String_Node_Str", "String_Node_Str", "String_Node_Str", 'o', Items.GLASS_BOTTLE, 'M', ModBlocks.machineFrame, 'D', Items.DIAMOND, 'E', Items.REDSTONE, 'G', Items.GOLD_INGOT, 'I', Items.IRON_INGOT);
}

Output:
 public static void initCrafting() {
-    GameRegistry.addRecipe(new ItemStack(boosterBlock), "String_Node_Str", "String_Node_Str", "String_Node_Str", 'o', Items.GLASS_BOTTLE, 'M', ModBlocks.machineFrame, 'D', Items.DIAMOND, 'E', Items.REDSTONE, 'G', Items.GOLD_INGOT, 'I', Items.IRON_INGOT);
+    MyGameReg.addRecipe(new ItemStack(boosterBlock), "String_Node_Str", "String_Node_Str", "String_Node_Str", 'o', Items.GLASS_BOTTLE, 'M', ModBlocks.machineFrame, 'D', Items.DIAMOND, 'E', Items.REDSTONE, 'G', Items.GOLD_INGOT, 'I', Items.IRON_INGOT);
 }


Input:
private void updateSummary(String key, boolean changing) {
    switch(key) {
        case Preferences.PREF_UPDATE_INTERVAL:
            updateIntervalSeekBar.setMax(Preferences.UPDATE_INTERVAL_VALUES.length - 1);
            int seekBarPosition = updateIntervalSeekBar.getValue();
            updateIntervalSeekBar.setSummary(UPDATE_INTERVAL_NAMES[seekBarPosition]);
            break;
        case Preferences.PREF_OVER_WIFI:
            overWifiSeekBar.setMax(Preferences.OVER_NETWORK_ALWAYS);
            setNetworkSeekBarSummary(overWifiSeekBar);
            enableUpdateInverval();
            break;
        case Preferences.PREF_OVER_DATA:
            overDataSeekBar.setMax(Preferences.OVER_NETWORK_ALWAYS);
            setNetworkSeekBarSummary(overDataSeekBar);
            enableUpdateInverval();
            break;
        case Preferences.PREF_UPDATE_NOTIFICATION_ENABLED:
            checkSummary(key, R.string.notify_on);
            break;
        case Preferences.PREF_THEME:
            entrySummary(key);
            if (changing) {
                Activity activity = getActivity();
                FDroidApp fdroidApp = (FDroidApp) activity.getApplication();
                fdroidApp.reloadTheme();
                fdroidApp.applyTheme(activity);
                FDroidApp.forceChangeTheme(activity);
            }
            break;
        case Preferences.PREF_SHOW_INCOMPAT_VERSIONS:
            checkSummary(key, R.string.show_incompat_versions_on);
            break;
        case Preferences.PREF_SHOW_ROOT_APPS:
            checkSummary(key, R.string.show_root_apps_on);
            break;
        case Preferences.PREF_SHOW_ANTI_FEATURE_APPS:
            checkSummary(key, R.string.show_anti_feature_apps_on);
            break;
        case Preferences.PREF_FORCE_TOUCH_APPS:
            checkSummary(key, R.string.force_touch_apps_on);
            break;
        case Preferences.PREF_LOCAL_REPO_NAME:
            textSummary(key, R.string.local_repo_name_summary);
            break;
        case Preferences.PREF_LOCAL_REPO_HTTPS:
            checkSummary(key, R.string.local_repo_https_on);
            break;
        case Preferences.PREF_LANGUAGE:
            entrySummary(key);
            if (changing) {
                Activity activity = getActivity();
                Languages.setLanguage(activity);
                RepoProvider.Helper.clearEtags(getActivity());
                UpdateService.updateNow(getActivity());
                Languages.forceChangeLanguage(activity);
            }
            break;
        case Preferences.PREF_KEEP_CACHE_TIME:
            entrySummary(key);
            if (changing && currentKeepCacheTime != Preferences.get().getKeepCacheTime()) {
                CleanCacheService.schedule(getActivity());
            }
            break;
        case Preferences.PREF_EXPERT:
            checkSummary(key, R.string.expert_on);
            boolean isExpertMode = Preferences.get().expertMode();
            for (int i = 0; i < otherPrefGroup.getPreferenceCount(); i++) {
                Preference pref = otherPrefGroup.getPreference(i);
                if (TextUtils.equals(Preferences.PREF_EXPERT, pref.getDependency())) {
                    pref.setVisible(isExpertMode);
                }
            }
            if (changing) {
                RecyclerView recyclerView = getListView();
                recyclerView.smoothScrollToPosition(recyclerView.getAdapter().getItemCount() - 1);
            }
            break;
        case Preferences.PREF_PRIVILEGED_INSTALLER:
            final CheckBoxPreference pref = (CheckBoxPreference) findPreference(Preferences.PREF_PRIVILEGED_INSTALLER);
            if (pref != null) {
                checkSummary(key, R.string.system_installer_on);
            }
            break;
        case Preferences.PREF_ENABLE_PROXY:
            SwitchPreference checkPref = (SwitchPreference) findPreference(key);
            checkPref.setSummary(R.string.enable_proxy_summary);
            break;
        case Preferences.PREF_PROXY_HOST:
            EditTextPreference textPref = (EditTextPreference) findPreference(key);
            String text = Preferences.get().getProxyHost();
            if (TextUtils.isEmpty(text) || text.equals(Preferences.DEFAULT_PROXY_HOST)) {
                textPref.setSummary(R.string.proxy_host_summary);
            } else {
                textPref.setSummary(text);
            }
            break;
        case Preferences.PREF_PROXY_PORT:
            EditTextPreference textPref2 = (EditTextPreference) findPreference(key);
            int port = Preferences.get().getProxyPort();
            if (port == Preferences.DEFAULT_PROXY_PORT) {
                textPref2.setSummary(R.string.proxy_port_summary);
            } else {
                textPref2.setSummary(String.valueOf(port));
            }
            break;
        case Preferences.PREF_KEEP_INSTALL_HISTORY:
            CheckBoxPreference p = (CheckBoxPreference) findPreference(key);
            Preference installHistory = findPreference("String_Node_Str");
            if (p.isChecked()) {
                InstallHistoryService.register(getActivity());
                installHistory.setVisible(true);
            } else {
                InstallHistoryService.unregister(getActivity());
                installHistory.setVisible(false);
            }
            break;
    }
}

Output:
         case Preferences.PREF_KEEP_INSTALL_HISTORY:
-            CheckBoxPreference p = (CheckBoxPreference) findPreference(key);
-            Preference installHistory = findPreference("String_Node_Str");
-            if (p.isChecked()) {
+            if (keepInstallHistoryPref.isChecked()) {
                 InstallHistoryService.register(getActivity());


Input:
public void fire() throws IllegalActionException {
    super.fire();
    Token result = null;
    if (A.hasToken(0) && B.hasToken(0)) {
        result = A.get(0).multiply(B.get(0));
        Precision precision = new Precision(((Parameter) getAttribute("String_Node_Str")).getExpression());
        Overflow overflow = Overflow.getName(((Parameter) getAttribute("String_Node_Str")).getExpression().toLowerCase());
        Rounding rounding = Rounding.getName(((Parameter) getAttribute("String_Node_Str")).getExpression().toLowerCase());
        Quantization quantization = new FixPointQuantization(precision, overflow, rounding);
        result = ((FixToken) result).quantize(quantization);
        if (!((FixToken) result).fixValue().getPrecision().equals(new Precision(((Parameter) getAttribute("String_Node_Str")).getExpression()))) {
            System.out.println("String_Node_Str");
        }
    }
    output.send(0, result);
}

Output:
     if (A.hasToken(0) && B.hasToken(0)) {
-        result = A.get(0).multiply(B.get(0));
-        Precision precision = new Precision(((Parameter) getAttribute("String_Node_Str")).getExpression());
-        Overflow overflow = Overflow.getName(((Parameter) getAttribute("String_Node_Str")).getExpression().toLowerCase());
-        Rounding rounding = Rounding.getName(((Parameter) getAttribute("String_Node_Str")).getExpression().toLowerCase());
-        Quantization quantization = new FixPointQuantization(precision, overflow, rounding);
-        result = ((FixToken) result).quantize(quantization);
-        if (!((FixToken) result).fixValue().getPrecision().equals(new Precision(((Parameter) getAttribute("String_Node_Str")).getExpression()))) {
-            System.out.println("String_Node_Str");
-        }
+        Token result = A.get(0).multiply(B.get(0));
+        sendOutput(output, 0, result);
     }


Input:
public void setModelContentType(String contentType) {
    Lang lang = WebContent.contentTypeToLang(contentType);
    if (lang == null)
        throw new IllegalArgumentException("String_Node_Str" + contentType + "String_Node_Str");
    if (!lang.isTriples())
        throw new IllegalArgumentException("String_Node_Str" + contentType + "String_Node_Str");
    modelContentType = contentType;
}

Output:
         throw new IllegalArgumentException("String_Node_Str" + contentType + "String_Node_Str");
-    if (!lang.isTriples())
+    if (!RDFLanguages.isTriples(lang))
         throw new IllegalArgumentException("String_Node_Str" + contentType + "String_Node_Str");


Input:
public void configurePipeline(PipelineConfigurer pipelineConfigurer) {
    String pluginId = getPluginId();
    Class<Object> driver = pipelineConfigurer.usePluginClass(config.jmsPluginType, config.jmsPluginName, pluginId, PluginProperties.builder().build());
    Preconditions.checkArgument(driver != null, "String_Node_Str");
}

Output:
     Class<Object> driver = pipelineConfigurer.usePluginClass(config.jmsPluginType, config.jmsPluginName, pluginId, PluginProperties.builder().build());
-    Preconditions.checkArgument(driver != null, "String_Node_Str");
+    Preconditions.checkArgument(driver != null, "String_Node_Str" + "String_Node_Str", config.jmsPluginName, config.jmsPluginType);
 }


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

Output:
         try {
-            if (resourceFolder != null)
-                resourceFolder = URLEncoder.encode(resourceFolder, ParameterAccessor.UTF_8_ENCODE);
+            if (resourceFolder != null) {
+                String res = URLEncoder.encode(resourceFolder, ParameterAccessor.UTF_8_ENCODE);
+                link.append(ParameterAccessor.getQueryParameterString(ParameterAccessor.PARAM_RESOURCE_FOLDER, res));
+            }
         } catch (UnsupportedEncodingException e) {


Input:
public ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str");
    }
    User user = (User) command;
    if (request.getParameter("String_Node_Str") != null) {
        mgr.removeUser(user.getUsername());
        String message = getMessageSourceAccessor().getMessage("String_Node_Str", new Object[] { user.getUsername() });
        saveMessage(request, message);
        return new ModelAndView(new RedirectView("String_Node_Str"));
    } else {
        if ("String_Node_Str".equals(request.getParameter("String_Node_Str"))) {
            String algorithm = (String) getConfiguration().get(Constants.ENC_ALGORITHM);
            if (algorithm == null) {
                if (log.isDebugEnabled()) {
                    log.debug("String_Node_Str");
                }
                algorithm = "String_Node_Str";
            }
            user.setPassword(StringUtil.encodePassword(user.getPassword(), algorithm));
        }
        try {
            mgr.saveUser(user);
        } catch (Exception e) {
            if ((e.getMessage() != null) && (e.getMessage().indexOf("String_Node_Str") != -1)) {
                log.warn("String_Node_Str" + e.getMessage());
                errors.rejectValue("String_Node_Str", "String_Node_Str", new Object[] { user.getUsername(), user.getEmail() }, "String_Node_Str");
                user.setPassword(user.getConfirmPassword());
                return showForm(request, response, errors);
            }
        }
        String message = null;
        if (!StringUtils.equals(request.getParameter("String_Node_Str"), "String_Node_Str")) {
            HttpSession session = request.getSession();
            session.setAttribute(Constants.USER_KEY, user);
            if ((RequestUtil.getCookie(request, Constants.LOGIN_COOKIE) != null) && (session.getAttribute("String_Node_Str") == null)) {
                mgr.removeLoginCookies(user.getUsername());
                String autoLogin = mgr.createLoginCookie(user.getUsername());
                RequestUtil.setCookie(response, Constants.LOGIN_COOKIE, autoLogin, request.getContextPath());
            }
            message = getMessageSourceAccessor().getMessage("String_Node_Str", new Object[] { user.getFullName() });
            saveMessage(request, message);
            return new ModelAndView(new RedirectView("String_Node_Str"));
        } else {
            String msg = null;
            if (StringUtils.isEmpty(request.getParameter("String_Node_Str"))) {
                message = getMessageSourceAccessor().getMessage("String_Node_Str", new Object[] { user.getFullName() });
                saveMessage(request, message);
                sendNewUserEmail(user);
                return showNewForm(request, response);
            } else {
                message = getMessageSourceAccessor().getMessage("String_Node_Str", new Object[] { user.getFullName() });
                saveMessage(request, message);
            }
        }
    }
    return showForm(request, response, errors);
}

Output:
                 saveMessage(request, message);
-                sendNewUserEmail(user);
+                sendNewUserEmail(user, request);
                 return showNewForm(request, response);


Input:
private void setAnnotationActions2(IMenuManager manager) {
    manager.add(setAnnotationLabelAction);
    manager.add(setAnnotationDescriptionsAction);
    manager.add(setAnnotationWriteAction);
    manager.add(setAnnotationHiddenAction);
    manager.add(setAnnotationTargetSystemsAction);
    manager.add(setAnnotationSourceSystemAction);
    java.util.List<IAvailableModel> availablemodels = AvailableModelUtil.getAvailableModels();
    for (IAvailableModel model : availablemodels) {
        model.fillContextMenu(null, manager, this, dataModelName);
    }
}

Output:
     manager.add(setAnnotationWriteAction);
-    manager.add(setAnnotationHiddenAction);
+    manager.add(setAnnotationNoAction);
     manager.add(setAnnotationTargetSystemsAction);


Input:
protected final TableViewer createStructuredViewer(Composite parent) {
    return new TableViewer(parent);
}

Output:
 protected final TableViewer createStructuredViewer(Composite parent) {
-    return new TableViewer(parent);
+    return new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION);
 }


Input:
public org.hl7.fhir.dstu2.model.PaymentReconciliation.DetailsComponent convertDetailsComponent(org.hl7.fhir.dstu3.model.PaymentReconciliation.DetailsComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.PaymentReconciliation.DetailsComponent tgt = new org.hl7.fhir.dstu2.model.PaymentReconciliation.DetailsComponent();
    copyElement(src, tgt);
    tgt.setType(convertCoding(src.getType()));
    if (src.hasRequestReference())
        tgt.setRequest((org.hl7.fhir.dstu2.model.Reference) convertType(src.getRequest()));
    if (src.hasResponseReference())
        tgt.setResponce((org.hl7.fhir.dstu2.model.Reference) convertType(src.getResponse()));
    if (src.hasSubmitterReference())
        tgt.setSubmitter((org.hl7.fhir.dstu2.model.Reference) convertType(src.getSubmitter()));
    if (src.hasPayeeReference())
        tgt.setPayee((org.hl7.fhir.dstu2.model.Reference) convertType(src.getPayee()));
    tgt.setDate(src.getDate());
    tgt.setAmount(convertMoney(src.getAmount()));
    return tgt;
}

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


Input:
public Void call(JavaPairRDD<K, M> newData) throws IOException {
    long count = newData.count();
    if (count > 0) {
        log.info("String_Node_Str", count);
        try (TopicProducer<String, U> producer = new TopicProducerImpl<>(updateBroker, updateTopic)) {
            for (U update : modelManager.buildUpdates(newData)) {
                producer.send("String_Node_Str", update);
            }
        }
    } else {
        log.debug("String_Node_Str");
    }
    return null;
}

Output:
 public Void call(JavaPairRDD<K, M> newData) throws IOException {
-    long count = newData.count();
-    if (count > 0) {
-        log.info("String_Node_Str", count);
+    if (newData.take(1).isEmpty()) {
+        log.debug("String_Node_Str");
+    } else {
+        log.info("String_Node_Str");
         try (TopicProducer<String, U> producer = new TopicProducerImpl<>(updateBroker, updateTopic)) {


Input:
public void validate(ModuleContext context, ModelObject mobj, ScribbleLogger logger) {
    GMessageTransfer elem = (GMessageTransfer) mobj;
    if (elem.getMessage() != null) {
        ValidationRule rule = ValidationRuleFactory.getValidationRule(elem.getMessage());
        if (rule != null) {
            rule.validate(context, elem.getMessage(), logger);
        }
    }
    ProtocolDecl pd = elem.getParent(ProtocolDecl.class);
    if (pd != null) {
        if (elem.getFromRole() != null) {
            if (pd.getRoleDeclaration(elem.getFromRole().getName()) == null) {
                logger.error(MessageFormat.format(ValidationMessages.getMessage("String_Node_Str"), elem.getFromRole().getName()), elem.getFromRole());
            }
        }
        java.util.List<String> toRoles = new java.util.ArrayList<String>();
        for (Role r : elem.getToRoles()) {
            if (toRoles.contains(r.getName())) {
                logger.error(MessageFormat.format(ValidationMessages.getMessage("String_Node_Str"), r.getName()), elem);
            } else {
                toRoles.add(r.getName());
            }
            if (pd.getRoleDeclaration(r.getName()) == null) {
                logger.error(MessageFormat.format(ValidationMessages.getMessage("String_Node_Str"), r.getName()), r);
            }
        }
    }
}

Output:
             if (pd.getRoleDeclaration(elem.getFromRole().getName()) == null) {
-                logger.error(MessageFormat.format(ValidationMessages.getMessage("String_Node_Str"), elem.getFromRole().getName()), elem.getFromRole());
+                logger.error(MessageFormat.format(ValidationMessages.getMessage("String_Node_Str"), elem.getFromRole().getName()), elem);
             }


Input:
public void testVararg() {
    String[] strings = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    String[] results = vararg("String_Node_Str", "String_Node_Str", "String_Node_Str");
    assertTrue(Arrays.equals(results, strings));
}

Output:
 public void testVararg() {
-    String[] strings = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
-    String[] results = vararg("String_Node_Str", "String_Node_Str", "String_Node_Str");
-    assertTrue(Arrays.equals(results, strings));
+    String[] expected = new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" };
+    String[] actual = vararg("String_Node_Str", "String_Node_Str", "String_Node_Str");
+    assertTrue(Arrays.equals(expected, actual));
+    expected = new String[] {};
+    actual = vararg();
+    assertTrue(Arrays.equals(expected, actual));
 }


Input:
public void test1() throws SoundTransformException {
    final int value = 200;
    final int twopercents = (int) (value * 2.0 / 100 - 1);
    final List<String> messages = new LinkedList<String>();
    final int[] t = new int[2000];
    for (int i = 200; i < 600; i++) {
        t[i] = (int) (value + Math.random() * twopercents - twopercents / 2);
    }
    for (int i = 800; i < 1000; i++) {
        t[i] = (int) (value + Math.random() * twopercents - twopercents / 2);
    }
    for (int i = 1100; i < 1600; i++) {
        t[i] = (int) (value + Math.random() * twopercents - twopercents / 2);
    }
    new ShapeSoundTransformation(Library.defaultPack, "String_Node_Str", t).setObservers(new PrintlnTransformObserver(), new Observer() {
        public void notify(final LogEvent logEvent) {
            messages.add(logEvent.toString());
        }
    }).transform(200000, 100, 2, 44100, 1);
    Assert.assertTrue(messages.get(0).endsWith("String_Node_Str"));
    Assert.assertTrue(messages.get(1).endsWith("String_Node_Str"));
    Assert.assertTrue(messages.get(2).endsWith("String_Node_Str"));
}

Output:
     final int value = 200;
-    final int twopercents = (int) (value * 2.0 / 100 - 1);
+    final int twopercents = (int) (value * 5.0 / 100 - 1);
     final List<String> messages = new LinkedList<String>();


Input:
private final void sendIntent(int headset) {
    if ((mHeadsetState & headset) != (mPrevHeadsetState & headset)) {
        Intent intent = new Intent(Intent.ACTION_HEADSET_PLUG);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
        int state = 0;
        int microphone = 0;
        if ((headset & HEADSETS_WITH_MIC) != 0) {
            microphone = 1;
        }
        if ((mHeadsetState & headset) != 0) {
            state = 1;
        }
        intent.putExtra("String_Node_Str", state);
        intent.putExtra("String_Node_Str", mHeadsetName);
        intent.putExtra("String_Node_Str", microphone);
        if (LOG)
            Log.v(TAG, "String_Node_Str" + state + "String_Node_Str" + mHeadsetName + "String_Node_Str" + microphone);
        ActivityManagerNative.broadcastStickyIntent(intent, null);
    }
}

Output:
         }
-        if ((mHeadsetState & headset) != 0) {
+        if ((headsetState & headset) != 0) {
             state = 1;