Input:
public Collection<Point> consumeArea(int amountOfArea, Point startPoint) {
    log.entering(className, "String_Node_Str", new Object[] { amountOfArea, startPoint });
    if (amountOfArea >= getArea()) {
        mRegionManager.removeRegion(this);
        log.exiting(className, "String_Node_Str", "String_Node_Str");
        return mPoints;
    }
    List<Point> consumablePoints = new ArrayList<Point>(amountOfArea + 8);
    Set<Point> consumablePointsCopy = new HashSet<Point>(amountOfArea + 8);
    if (isConsumable(startPoint.x, startPoint.y, null)) {
        log.finest("String_Node_Str");
        consumablePoints.add(startPoint);
    } else {
        log.info("String_Node_Str");
        log.exiting(className, "String_Node_Str");
        return consumablePoints;
    }
    BufferedImage image = mRegionManager.getDebugImage(this);
    Graphics g = image.getGraphics();
    Point lastCur = null;
    int imageID = 0;
    boolean debug = true;
    int i = 0;
    int lastIterationListSize = 0;
    Point cur = null;
    while (consumablePoints.size() < amountOfArea) {
        try {
            cur = consumablePoints.get(i);
        } catch (IndexOutOfBoundsException ide) {
            if (lastIterationListSize == consumablePoints.size()) {
                mPoints.removeAll(consumablePoints);
                assert (isContigious());
                return consumablePoints;
            }
            log.finest("String_Node_Str");
            i = 0;
            cur = consumablePoints.get(i);
            lastIterationListSize = consumablePoints.size();
        }
        if (cur == lastCur) {
        } else {
            StringBuilder name = new StringBuilder("String_Node_Str");
            if (imageID < 10)
                name.append("String_Node_Str").append(imageID).append("String_Node_Str");
            else if (imageID > 9 && imageID < 100)
                name.append("String_Node_Str").append(imageID).append("String_Node_Str");
            else if (imageID > 99 && imageID < 1000)
                name.append("String_Node_Str").append(imageID).append("String_Node_Str");
            else
                name.append(imageID).append("String_Node_Str");
            try {
                File f = new File(name.toString());
                ImageIO.write(image, "String_Node_Str", f);
            } catch (IOException e) {
                e.printStackTrace();
            }
            image = mRegionManager.getDebugImage(this);
            g = image.getGraphics();
            g.setColor(Color.GREEN);
            for (Point p : consumablePoints) g.drawLine(p.x, p.y, p.x, p.y);
            g.setColor(Color.RED);
            g.drawLine(cur.x, cur.y, cur.x, cur.y);
            lastCur = cur;
            imageID++;
        }
        g.setColor(Color.YELLOW);
        log.finest("String_Node_Str" + cur + "String_Node_Str");
        if (isConsumable(cur.x, cur.y - 1, consumablePointsCopy)) {
            consumablePoints.add(new Point(cur.x, cur.y - 1));
            consumablePointsCopy.add(consumablePoints.get(consumablePoints.size() - 1));
            if (debug)
                g.drawLine(cur.x, cur.y - 1, cur.x, cur.y - 1);
            i = 0;
            continue;
        }
        if (isConsumable(cur.x + 1, cur.y, consumablePointsCopy)) {
            consumablePoints.add(new Point(cur.x + 1, cur.y));
            consumablePointsCopy.add(consumablePoints.get(consumablePoints.size() - 1));
            if (debug)
                g.drawLine(cur.x + 1, cur.y, cur.x + 1, cur.y);
            i = 0;
            continue;
        }
        if (isConsumable(cur.x, cur.y + 1, consumablePointsCopy)) {
            consumablePoints.add(new Point(cur.x, cur.y + 1));
            consumablePointsCopy.add(consumablePoints.get(consumablePoints.size() - 1));
            if (debug)
                g.drawLine(cur.x, cur.y + 1, cur.x, cur.y + 1);
            i = 0;
            continue;
        }
        if (isConsumable(cur.x - 1, cur.y, consumablePointsCopy)) {
            consumablePoints.add(new Point(cur.x - 1, cur.y));
            consumablePointsCopy.add(consumablePoints.get(consumablePoints.size() - 1));
            if (debug)
                g.drawLine(cur.x - 1, cur.y, cur.x - 1, cur.y);
            i = 0;
            continue;
        }
        ++i;
    }
    while (consumablePoints.size() != amountOfArea) consumablePoints.remove(amountOfArea);
    mPoints.removeAll(consumablePoints);
    log.exiting(className, "String_Node_Str");
    return consumablePoints;
}

Output:
     int imageID = 0;
-    boolean debug = true;
+    boolean debug = false;
     int i = 0;


Input:
public void onKey(int primaryCode, Key key, int multiTapIndex, int[] nearByKeyCodes, boolean fromUI) {
    Log.d(TAG, "String_Node_Str" + primaryCode);
    final InputConnection ic = getCurrentInputConnection();
    switch(primaryCode) {
        case KeyCodes.ENTER:
        case KeyCodes.SPACE:
            handleSeparator(primaryCode);
            if (!mKeyboardSwitcher.isAlphabetMode()) {
                Log.d(TAG, "String_Node_Str");
                if (mAskPrefs.getSwitchKeyboardOnSpace()) {
                    Log.d(TAG, "String_Node_Str");
                    mKeyboardSwitcher.nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Alphabet);
                }
            }
            break;
        case KeyCodes.DELETE_WORD:
            if (ic == null)
                break;
            handleBackWord(ic);
            break;
        case KeyCodes.DELETE:
            if (ic == null)
                break;
            if (mInputView != null && mInputView.isShifted() && !mInputView.getKeyboard().isShiftLocked() && ((mDistinctMultiTouch && mShiftKeyState.isPressed()) || mAskPrefs.useBackword())) {
                handleBackWord(ic);
            } else {
                handleDeleteLastCharacter(false);
            }
            break;
        case KeyCodes.CLEAR_INPUT:
            if (ic != null) {
                ic.beginBatchEdit();
                commitTyped(ic);
                ic.deleteSurroundingText(Integer.MAX_VALUE, Integer.MAX_VALUE);
                ic.endBatchEdit();
            }
            break;
        case KeyCodes.CTRL:
            if ((!mDistinctMultiTouch) || (!fromUI))
                handleControl();
            break;
        case KeyCodes.SHIFT:
            if ((!mDistinctMultiTouch) || (!fromUI))
                handleShift();
            break;
        case KeyCodes.ARROW_LEFT:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_LEFT);
            break;
        case KeyCodes.ARROW_RIGHT:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_RIGHT);
            break;
        case KeyCodes.ARROW_UP:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_UP);
            break;
        case KeyCodes.ARROW_DOWN:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_DOWN);
            break;
        case KeyCodes.MOVE_HOME:
            if (Workarounds.getApiLevel() >= 11) {
                sendDownUpKeyEvents(0x0000007a);
            } else {
                if (ic != null) {
                    CharSequence textBefore = ic.getTextBeforeCursor(1024, 0);
                    if (!TextUtils.isEmpty(textBefore)) {
                        int newPosition = textBefore.length() - 1;
                        while (newPosition > 0) {
                            char chatAt = textBefore.charAt(newPosition - 1);
                            if (chatAt == '\n' || chatAt == '\r') {
                                break;
                            }
                            newPosition--;
                        }
                        if (newPosition < 0)
                            newPosition = 0;
                        ic.setSelection(newPosition, newPosition);
                    }
                }
            }
            break;
        case KeyCodes.MOVE_END:
            if (Workarounds.getApiLevel() >= 11) {
                sendDownUpKeyEvents(0x0000007b);
            } else {
                if (ic != null) {
                    CharSequence textAfter = ic.getTextAfterCursor(1024, 0);
                    if (!TextUtils.isEmpty(textAfter)) {
                        int newPosition = 1;
                        while (newPosition < textAfter.length()) {
                            char chatAt = textAfter.charAt(newPosition);
                            if (chatAt == '\n' || chatAt == '\r') {
                                break;
                            }
                            newPosition++;
                        }
                        if (newPosition > textAfter.length())
                            newPosition = textAfter.length();
                        try {
                            CharSequence textBefore = ic.getTextBeforeCursor(Integer.MAX_VALUE, 0);
                            if (!TextUtils.isEmpty(textBefore)) {
                                newPosition = newPosition + textBefore.length();
                            }
                            ic.setSelection(newPosition, newPosition);
                        } catch (Throwable e) {
                            Log.w(TAG, "String_Node_Str", e);
                        }
                    }
                }
            }
            break;
        case KeyCodes.VOICE_INPUT:
            if (mVoiceRecognitionTrigger.isInstalled()) {
                mVoiceRecognitionTrigger.startVoiceRecognition(getCurrentKeyboard().getDefaultDictionaryLocale());
            } else {
                Intent voiceInputNotInstalledIntent = new Intent(getApplicationContext(), VoiceInputNotInstalledActivity.class);
                voiceInputNotInstalledIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(voiceInputNotInstalledIntent);
            }
            break;
        case KeyCodes.CANCEL:
            if (mOptionsDialog == null || !mOptionsDialog.isShowing()) {
                handleClose();
            }
            break;
        case KeyCodes.SETTINGS:
            showOptionsMenu();
            break;
        case KeyCodes.SPLIT_LAYOUT:
        case KeyCodes.MERGE_LAYOUT:
        case KeyCodes.COMPACT_LAYOUT_TO_RIGHT:
        case KeyCodes.COMPACT_LAYOUT_TO_LEFT:
            if (getCurrentKeyboard() != null && mInputView != null) {
                mKeyboardInCondensedMode = CondenseType.fromKeyCode(primaryCode);
                AnyKeyboard currentKeyboard = getCurrentKeyboard();
                setKeyboardStuffBeforeSetToView(currentKeyboard);
                mInputView.setKeyboard(currentKeyboard);
            }
            break;
        case KeyCodes.DOMAIN:
            onText(mAskPrefs.getDomainText());
            break;
        case KeyCodes.QUICK_TEXT:
            if (mFlipQuickTextKeyAndPopupFunctionality) {
                openQuickTextPopup(key);
            } else {
                outputCurrentQuickTextKey();
            }
            break;
        case KeyCodes.QUICK_TEXT_POPUP:
            if (mFlipQuickTextKeyAndPopupFunctionality) {
                outputCurrentQuickTextKey();
            } else {
                openQuickTextPopup(key);
            }
            break;
        case KeyCodes.MODE_SYMOBLS:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Symbols);
            break;
        case KeyCodes.MODE_ALPHABET:
            if (mKeyboardSwitcher.shouldPopupForLanguageSwitch()) {
                showLanguageSelectionDialog();
            } else
                nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Alphabet);
            break;
        case KeyCodes.UTILITY_KEYBOARD:
            mInputView.openUtilityKeyboard();
            break;
        case KeyCodes.MODE_ALPHABET_POPUP:
            showLanguageSelectionDialog();
            break;
        case KeyCodes.ALT:
            nextAlterKeyboard(getCurrentInputEditorInfo());
            break;
        case KeyCodes.KEYBOARD_CYCLE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Any);
            break;
        case KeyCodes.KEYBOARD_REVERSE_CYCLE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.PreviousAny);
            break;
        case KeyCodes.KEYBOARD_CYCLE_INSIDE_MODE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.AnyInsideMode);
            break;
        case KeyCodes.KEYBOARD_MODE_CHANGE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.OtherMode);
            break;
        case KeyCodes.CLIPBOARD:
            Clipboard cp = AnyApplication.getFrankenRobot().embody(new Clipboard.ClipboardDiagram(getApplicationContext()));
            CharSequence clipboardText = cp.getText();
            if (!TextUtils.isEmpty(clipboardText)) {
                onText(clipboardText);
            }
            break;
        case KeyCodes.TAB:
            sendTab();
            break;
        case KeyCodes.ESCAPE:
            sendEscape();
            break;
        default:
            if (mKeyboardSwitcher.isRightToLeftMode()) {
                if (primaryCode == (int) ')')
                    primaryCode = (int) '(';
                else if (primaryCode == (int) '(')
                    primaryCode = (int) ')';
            }
            if (isWordSeparator(primaryCode)) {
                handleSeparator(primaryCode);
            } else {
                if (mControlKeyState.isActive() && primaryCode >= 32 && primaryCode < 127) {
                    int controlCode = primaryCode & 31;
                    Log.d(TAG, "String_Node_Str", primaryCode, controlCode);
                    if (controlCode == 9) {
                        sendTab();
                    } else {
                        ic.commitText(Character.toString((char) controlCode), 1);
                    }
                } else {
                    handleCharacter(primaryCode, key, multiTapIndex, nearByKeyCodes);
                }
                mJustAddedAutoSpace = false;
            }
            break;
    }
}

Output:
         case KeyCodes.QUICK_TEXT:
-            if (mFlipQuickTextKeyAndPopupFunctionality) {
-                openQuickTextPopup(key);
-            } else {
+            if (mDoNotFlipQuickTextKeyAndPopupFunctionality) {
                 outputCurrentQuickTextKey();


Input:
public V remove(Bytes keyBytes, K key, V expectedValue, int hash2, final long timestamp, final byte identifier) {
    lock();
    try {
        long keyLen = keyBytes.remaining();
        hashLookupLiveOnly.startSearch(hash2);
        int pos;
        while ((pos = hashLookupLiveOnly.nextPos()) >= 0) {
            long offset = offsetFromPos(pos);
            NativeBytes entry = entry(offset);
            if (!keyEquals(keyBytes, keyLen, entry))
                continue;
            entry.skip(keyLen);
            long timeStampPos = 0;
            if (canReplicate) {
                timeStampPos = entry.position();
                if (shouldTerminate(entry, timestamp, identifier))
                    return null;
                entry.skip(1);
            }
            long valueLen = readValueLen(entry);
            long entryEndAddr = entry.positionAddr() + valueLen;
            V valueRemoved = expectedValue != null || !removeReturnsNull ? readValue(entry, null, valueLen) : null;
            if (expectedValue != null && !expectedValue.equals(valueRemoved)) {
                return null;
            }
            hashLookupLiveOnly.removePrevPos();
            decrementSize();
            if (canReplicate) {
                entry.position(timeStampPos);
                entry.writeLong(timestamp);
                entry.writeByte(identifier);
                entry.writeBoolean(true);
            } else {
                free(pos, inBlocks(entryEndAddr - entryStartAddr(offset)));
            }
            notifyRemoved(offset, key, valueRemoved, pos);
            return valueRemoved;
        }
        return null;
    } finally {
        unlock();
    }
}

Output:
         hashLookupLiveOnly.startSearch(hash2);
-        int pos;
-        while ((pos = hashLookupLiveOnly.nextPos()) >= 0) {
+        for (int pos; (pos = hashLookupLiveOnly.nextPos()) >= 0; ) {
             long offset = offsetFromPos(pos);


Input:
public void onCreateClass(ClassInfo classInfo, boolean loaded) {
    if (!loaded)
        return;
    try {
        if (AppInfo.getSingleton().getClassFile(classInfo).getTime() > storage.lastModified()) {
            logger.error("String_Node_Str" + classInfo + "String_Node_Str" + storage + "String_Node_Str");
            return;
        }
        for (MethodInfo method : classInfo.getMethods()) {
            if (!method.hasCode())
                continue;
            List<SourceLineEntry> entries = sourceLineMap.get(method);
            if (entries == null)
                continue;
            applySourceInfos(method, entries);
        }
    } catch (FileNotFoundException e) {
        logger.warn("String_Node_Str", e);
    }
}

Output:
                 continue;
-            List<SourceLineEntry> entries = sourceLineMap.get(method);
+            List<SourceLineEntry> entries = sourceLineMap.get(method.getMemberID());
             if (entries == null)


Input:
public static ClassLoader callerClassLoader() {
    if (org.jikesrvm.VM.runningVM) {
        ClassLoader ans = RVMClass.getClassLoaderFromStackFrame(1);
        if (ans == BootstrapClassLoader.getBootstrapClassLoader()) {
            return null;
        } else {
            return ans;
        }
    } else {
        return null;
    }
}

Output:
     if (org.jikesrvm.VM.runningVM) {
-        ClassLoader ans = RVMClass.getClassLoaderFromStackFrame(1);
+        ClassLoader ans = RVMClass.getClassLoaderFromStackFrame(2);
         if (ans == BootstrapClassLoader.getBootstrapClassLoader()) {


Input:
public Alert getAlert() throws NoAlertPresentException {
    ContextTimeOuts timeOuts = getContextTimeOuts();
    return ComponentFactory.getComponent(AlertHandler.class, getWrappedDriver(), new Class[] { long.class }, new Object[] { getTimeOut(timeOuts.getSecsForAwaitinAlertPresent(), defaultTime) });
}

Output:
     ContextTimeOuts timeOuts = getContextTimeOuts();
-    return ComponentFactory.getComponent(AlertHandler.class, getWrappedDriver(), new Class[] { long.class }, new Object[] { getTimeOut(timeOuts.getSecsForAwaitinAlertPresent(), defaultTime) });
+    return getWebDriverEncapsulation().getComponent(AlertHandler.class, new Class[] { long.class }, new Object[] { getTimeOut(timeOuts.getSecsForAwaitinAlertPresent(), defaultTime) });
 }


Input:
protected void paintColorScale(GlimpseContext context) {
    Axis1D axis = getAxis1D(context);
    if (colorTexture != null && axis instanceof TaggedAxis1D) {
        TaggedAxis1D taggedAxis = (TaggedAxis1D) axis;
        GlimpseBounds bounds = getBounds(context);
        GL3 gl = context.getGL().getGL3();
        int height = bounds.getHeight();
        int width = bounds.getWidth();
        int count = updateCoordinateBuffers(gl, taggedAxis, width, height);
        float y1 = getColorBarMinY(height);
        float y2 = getColorBarMaxY(height);
        pathOutline.clear();
        pathOutline.addRectangle(0.5f, y1, width, y2);
        GLUtils.enableStandardBlending(gl);
        try {
            if (count > 0) {
                progTex.begin(gl);
                try {
                    progTex.setPixelOrtho(gl, bounds);
                    progTex.draw(gl, GL_TRIANGLES, colorTexture, vertexCoords, textureCoords, 0, count);
                } finally {
                    progTex.end(gl);
                }
            }
            progOutline.begin(gl);
            try {
                progOutline.setPixelOrtho(gl, bounds);
                progOutline.setViewport(gl, bounds);
                progOutline.draw(gl, style, pathOutline);
            } finally {
                progOutline.end(gl);
            }
        } finally {
            gl.glDisable(GL.GL_BLEND);
        }
    }
}

Output:
         pathOutline.clear();
-        pathOutline.addRectangle(0.5f, y1, width, y2);
+        pathOutline.addRectangle(inset_PX, y1, width - inset_PX, y2);
         GLUtils.enableStandardBlending(gl);


Input:
public boolean isDirectory() {
    return !isFile();
}

Output:
 public boolean isDirectory() {
-    return !isFile();
+    return exists;
 }


Input:
public synchronized void open() throws ResourceUnavailableException {
    if (opened)
        return;
    if (inputFormat == null)
        throw new ResourceUnavailableException("String_Node_Str");
    if (outputFormat == null)
        throw new ResourceUnavailableException("String_Node_Str");
    VideoFormat outputVideoFormat = (VideoFormat) outputFormat;
    Dimension size = outputVideoFormat.getSize();
    int width = size.width;
    int height = size.height;
    long avcodec = FFmpeg.avcodec_find_encoder(FFmpeg.CODEC_ID_H264);
    avctx = FFmpeg.avcodec_alloc_context();
    FFmpeg.avcodeccontext_set_pix_fmt(avctx, FFmpeg.PIX_FMT_YUV420P);
    FFmpeg.avcodeccontext_set_size(avctx, width, height);
    FFmpeg.avcodeccontext_set_qcompress(avctx, 0.6f);
    int bitRate = 128000;
    int frameRate = (int) outputVideoFormat.getFrameRate();
    if (frameRate == Format.NOT_SPECIFIED)
        frameRate = DEFAULT_FRAME_RATE;
    FFmpeg.avcodeccontext_set_bit_rate(avctx, bitRate);
    FFmpeg.avcodeccontext_set_bit_rate_tolerance(avctx, (bitRate / frameRate));
    FFmpeg.avcodeccontext_set_rc_max_rate(avctx, bitRate);
    FFmpeg.avcodeccontext_set_sample_aspect_ratio(avctx, 0, 0);
    FFmpeg.avcodeccontext_set_thread_count(avctx, 1);
    FFmpeg.avcodeccontext_set_time_base(avctx, 1, frameRate);
    FFmpeg.avcodeccontext_set_ticks_per_frame(avctx, 2);
    FFmpeg.avcodeccontext_set_quantizer(avctx, 30, 31, 4);
    FFmpeg.avcodeccontext_add_partitions(avctx, 0x111);
    FFmpeg.avcodeccontext_set_mb_decision(avctx, FFmpeg.FF_MB_DECISION_SIMPLE);
    FFmpeg.avcodeccontext_set_rc_eq(avctx, "String_Node_Str");
    FFmpeg.avcodeccontext_add_flags(avctx, FFmpeg.CODEC_FLAG_LOOP_FILTER);
    FFmpeg.avcodeccontext_add_flags2(avctx, FFmpeg.CODEC_FLAG2_INTRA_REFRESH);
    FFmpeg.avcodeccontext_set_me_method(avctx, 7);
    FFmpeg.avcodeccontext_set_me_subpel_quality(avctx, 2);
    FFmpeg.avcodeccontext_set_me_range(avctx, 16);
    FFmpeg.avcodeccontext_set_me_cmp(avctx, FFmpeg.FF_CMP_CHROMA);
    FFmpeg.avcodeccontext_set_scenechange_threshold(avctx, 40);
    FFmpeg.avcodeccontext_set_crf(avctx, 0);
    FFmpeg.avcodeccontext_set_rc_buffer_size(avctx, 10);
    FFmpeg.avcodeccontext_set_gop_size(avctx, IFRAME_INTERVAL);
    FFmpeg.avcodeccontext_set_i_quant_factor(avctx, 1f / 1.4f);
    FFmpeg.avcodeccontext_set_refs(avctx, 1);
    FFmpeg.avcodeccontext_set_keyint_min(avctx, 0);
    if (packetizationMode == 0) {
        FFmpeg.avcodeccontext_set_rtp_payload_size(avctx, Packetizer.MAX_PAYLOAD_SIZE);
    }
    ConfigurationService configuration = NeomediaActivator.getConfigurationService();
    String profile = (configuration == null) ? null : configuration.getString(DEFAULT_PROFILE_PNAME, DEFAULT_DEFAULT_PROFILE);
    try {
        FFmpeg.avcodeccontext_set_profile(avctx, BASELINE_PROFILE.equalsIgnoreCase(profile) ? FFmpeg.FF_PROFILE_H264_BASELINE : FFmpeg.FF_PROFILE_H264_MAIN);
    } catch (UnsatisfiedLinkError ule) {
        logger.warn("String_Node_Str");
    }
    if (FFmpeg.avcodec_open(avctx, avcodec) < 0) {
        throw new ResourceUnavailableException("String_Node_Str" + width + "String_Node_Str" + height + "String_Node_Str");
    }
    encFrameLen = (width * height * 3) / 2;
    rawFrameBuffer = FFmpeg.av_malloc(encFrameLen);
    avframe = FFmpeg.avcodec_alloc_frame();
    int sizeInBytes = width * height;
    FFmpeg.avframe_set_data(avframe, rawFrameBuffer, sizeInBytes, sizeInBytes / 4);
    FFmpeg.avframe_set_linesize(avframe, width, width / 2, width / 2);
    encFrameBuffer = new byte[encFrameLen];
    if (keyFrameRequestee == null) {
        keyFrameRequestee = new KeyFrameControl.KeyFrameRequestee() {
            public boolean keyFrameRequest() {
                return JNIEncoder.this.keyFrameRequest();
            }
        };
    }
    if (keyFrameControl != null)
        keyFrameControl.addKeyFrameRequestee(-1, keyFrameRequestee);
    opened = true;
    super.open();
}

Output:
     FFmpeg.avcodeccontext_set_keyint_min(avctx, 0);
-    if (packetizationMode == 0) {
+    if ((null == packetizationMode) || "String_Node_Str".equals(packetizationMode)) {
         FFmpeg.avcodeccontext_set_rtp_payload_size(avctx, Packetizer.MAX_PAYLOAD_SIZE);


Input:
public TableElement elementForIndexInSegment(GuiTable table, int index, int segment) {
    if (segment == 2) {
        switch(index) {
            case 0:
                {
                    TableCellFloatNullable cell = new TableCellFloatNullable("String_Node_Str", TableElements.toFloat(transformer.naturalExpansionDistance), 1.0f, 0, 40, "String_Node_Str", "String_Node_Str");
                    cell.setScale(Scales.pow(5));
                    cell.addPropertyListener(this);
                    cell.setTooltip(IvTranslations.formatLines("String_Node_Str"));
                    return new TableElementCell(IvTranslations.get("String_Node_Str"), cell);
                }
            case 1:
                {
                    TableCellFloatNullable cell = new TableCellFloatNullable("String_Node_Str", TableElements.toFloat(transformer.naturalExpansionRandomization), 1.0f, 0, 40, "String_Node_Str", "String_Node_Str");
                    cell.setScale(Scales.pow(5));
                    cell.addPropertyListener(this);
                    cell.setTooltip(IvTranslations.formatLines("String_Node_Str"));
                    return new TableElementCell(IvTranslations.get("String_Node_Str"), cell);
                }
        }
    }
    return super.elementForIndexInSegment(table, index, segment);
}

Output:
                 {
-                    TableCellFloatNullable cell = new TableCellFloatNullable("String_Node_Str", TableElements.toFloat(transformer.naturalExpansionDistance), 1.0f, 0, 40, "String_Node_Str", "String_Node_Str");
+                    TableCellFloat cell = new TableCellFloat("String_Node_Str", TableElements.toFloat(transformer.naturalExpansionDistance), 0, 40);
                     cell.setScale(Scales.pow(5));


Input:
public void testConcurrentPersist() throws NotSupportedException, SystemException, NamingException, SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException {
    userTransaction = (UserTransaction) initialContext.lookup("String_Node_Str");
    userTransaction.begin();
    for (i = 0; i < 1; i++) {
        Runnable r = onExecute();
        r.run();
    }
    userTransaction.commit();
    userTransaction.begin();
    for (i = 0; i < 1; i++) {
        EntityManager em1 = emf.createEntityManager();
        Assert.assertNotNull(em1.find(PersonnelOToOFKEntityJTA.class, "String_Node_Str" + i));
    }
}

Output:
     userTransaction.begin();
-    for (i = 0; i < 1; i++) {
+    for (i = 0; i < 100; i++) {
         Runnable r = onExecute();


Input:
public boolean isReactantValidForStack(int idx, String name) {
    switch(idx) {
        case FUEL:
            return Reactants.isFuel(name);
        case WASTE:
            return Reactants.isWaste(name);
        default:
            return false;
    }
}

Output:
         case WASTE:
-            return Reactants.isWaste(name);
+            return true;
         default:


Input:
protected void doImportItem(IProgressMonitor monitor, ResourcesManager resManager, ImportItem selectedImportItem, boolean overwrite, IPath destinationPath, Set<String> overwriteDeletedItems, Set<String> idDeletedBeforeImport) {
    final Item item = selectedImportItem.getItem();
    if (item != null) {
        final ProxyRepositoryFactory repFactory = ProxyRepositoryFactory.getInstance();
        ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(item);
        IPath path = checkAndCreatePath(selectedImportItem, destinationPath);
        try {
            Item tmpItem = item;
            String id = selectedImportItem.getProperty().getId();
            IRepositoryViewObject lastVersion = selectedImportItem.getExistingItemWithSameId();
            if (selectedImportItem.getState() == State.NAME_EXISTED || selectedImportItem.getState() == State.NAME_AND_ID_EXISTED_BOTH) {
                lastVersion = selectedImportItem.getExistingItemWithSameName();
            }
            if (lastVersion != null && overwrite && !selectedImportItem.isLocked() && (selectedImportItem.getState() == State.ID_EXISTED || selectedImportItem.getState() == State.NAME_EXISTED || selectedImportItem.getState() == State.NAME_AND_ID_EXISTED || selectedImportItem.getState() == State.NAME_AND_ID_EXISTED_BOTH) && !ImportCacheHelper.getInstance().getDeletedItems().contains(id)) {
                if (overwriteDeletedItems != null && !overwriteDeletedItems.contains(id)) {
                    ERepositoryStatus status = repFactory.getStatus(lastVersion);
                    if (status == ERepositoryStatus.DELETED) {
                        repFactory.restoreObject(lastVersion, path);
                    }
                    overwriteDeletedItems.add(id);
                }
                if (selectedImportItem.getState().equals(ImportItem.State.NAME_EXISTED) || selectedImportItem.getState().equals(ImportItem.State.NAME_AND_ID_EXISTED) || selectedImportItem.getState().equals(ImportItem.State.NAME_AND_ID_EXISTED_BOTH)) {
                    final IRepositoryViewObject lastVersionBackup = lastVersion;
                    if (idDeletedBeforeImport != null && !idDeletedBeforeImport.contains(id)) {
                        final List<IRepositoryViewObject> allVersionToDelete = repFactory.getAllVersion(ProjectManager.getInstance().getCurrentProject(), lastVersionBackup.getId(), false);
                        RepositoryWorkUnit repositoryWorkUnit = new RepositoryWorkUnit(Messages.getString("String_Node_Str")) {
                            public void run() throws PersistenceException {
                                for (IRepositoryViewObject currentVersion : allVersionToDelete) {
                                    repFactory.forceDeleteObjectPhysical(lastVersionBackup, currentVersion.getVersion());
                                }
                            }
                        };
                        repositoryWorkUnit.setForceTransaction(true);
                        repositoryWorkUnit.setRefreshRepository(false);
                        ProxyRepositoryFactory.getInstance().executeRepositoryWorkUnit(repositoryWorkUnit);
                        idDeletedBeforeImport.add(id);
                    }
                }
                lastVersion = null;
            }
            User author = selectedImportItem.getProperty().getAuthor();
            if (author != null) {
                if (!repFactory.setAuthorByLogin(tmpItem, author.getLogin())) {
                    tmpItem.getProperty().setAuthor(null);
                }
            }
            beforeCreatingItem(selectedImportItem);
            final RepositoryObjectCache repObjectcache = ImportCacheHelper.getInstance().getRepObjectcache();
            if (lastVersion == null || selectedImportItem.getState().equals(ImportItem.State.ID_EXISTED) || selectedImportItem.getState().equals(ImportItem.State.NAME_AND_ID_EXISTED_BOTH)) {
                repFactory.create(tmpItem, path, true);
                afterCreatedItem(resManager, selectedImportItem);
                selectedImportItem.setImported(true);
            } else if (VersionUtils.compareTo(lastVersion.getProperty().getVersion(), tmpItem.getProperty().getVersion()) < 0) {
                repFactory.forceCreate(tmpItem, path);
                afterForceCreatedItem(resManager, selectedImportItem);
                selectedImportItem.setImported(true);
            } else {
                PersistenceException e = new PersistenceException(Messages.getString("String_Node_Str", tmpItem.getProperty()));
                selectedImportItem.addError(e.getMessage());
                logError(e);
            }
            if (selectedImportItem.isImported()) {
                selectedImportItem.setImportPath(path.toPortableString());
                selectedImportItem.setRepositoryType(itemType);
                selectedImportItem.setItemId(selectedImportItem.getProperty().getId());
                selectedImportItem.setItemVersion(selectedImportItem.getProperty().getVersion());
                repObjectcache.addToCache(tmpItem);
            }
            if (tmpItem.getState() != null && itemType != null) {
                final Set<String> folders = ImportCacheHelper.getInstance().getRestoreFolder().getFolders(itemType);
                if (folders != null) {
                    for (String folderPath : folders) {
                        if (folderPath != null && folderPath.equals(path.toString())) {
                            FolderItem folderItem = repFactory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), itemType, path);
                            if (folderItem != null) {
                                folderItem.getState().setDeleted(false);
                                while (!(folderItem.getParent() instanceof Project)) {
                                    folderItem = (FolderItem) folderItem.getParent();
                                    if (folderItem.getType() == FolderType.SYSTEM_FOLDER_LITERAL) {
                                        break;
                                    }
                                    folderItem.getState().setDeleted(false);
                                }
                            }
                            break;
                        }
                    }
                }
            }
        } catch (Exception e) {
            selectedImportItem.addError(selectedImportItem.getItemName() + "String_Node_Str" + e.getMessage() + "String_Node_Str" + path);
            logError(e);
        }
    }
}

Output:
                         };
-                        repositoryWorkUnit.setForceTransaction(true);
+                        if (isDeleteOnRemote) {
+                            repositoryWorkUnit.setForceTransaction(true);
+                        } else {
+                            repositoryWorkUnit.setForceTransaction(false);
+                        }
                         repositoryWorkUnit.setRefreshRepository(false);


Input:
protected void restoreWidgetValues() {
    IDialogSettings settings = getDialogSettings();
    if (settings != null) {
        String[] directoryNames = settings.getArray(STORE_DESTINATION_NAMES_ID);
        if (directoryNames != null) {
            setDestinationValue(directoryNames[0]);
            for (int i = 0; i < directoryNames.length; i++) {
                addDestinationItem(directoryNames[i]);
            }
        }
        shellLauncherButton.setSelection(settings.getBoolean(STORE_SHELL_LAUNCHER_ID));
        systemRoutineButton.setSelection(settings.getBoolean(STORE_SYSTEM_ROUTINE_ID));
        userRoutineButton.setSelection(settings.getBoolean(STORE_USER_ROUTINE_ID));
        modelButton.setSelection(settings.getBoolean(STORE_MODEL_ID));
        jobItemButton.setSelection(settings.getBoolean(STORE_JOB_ID));
        jobScriptButton.setSelection(settings.getBoolean(STORE_SOURCE_ID));
        contextButton.setSelection(settings.getBoolean(STORE_CONTEXT_ID));
        applyToChildrenButton.setSelection(settings.getBoolean(APPLY_TO_CHILDREN_ID));
    }
    launcherCombo.setItems(manager.getLauncher());
    if (manager.getLauncher().length > 0) {
        launcherCombo.select(0);
    }
    if (process.length > 0) {
        try {
            process[0].setProcess((ProcessItem) ProxyRepositoryFactory.getInstance().getUptodateProperty(process[0].getItem().getProperty()).getItem());
        } catch (PersistenceException e) {
            e.printStackTrace();
        }
        List<String> contextNames = manager.getJobContextsComboValue((ProcessItem) process[0].getItem());
        contextCombo.setItems(contextNames.toArray(new String[contextNames.size()]));
        if (contextNames.size() > 0) {
            contextCombo.select(0);
        }
    }
}

Output:
             setDestinationValue(directoryNames[0]);
-            for (int i = 0; i < directoryNames.length; i++) {
-                addDestinationItem(directoryNames[i]);
+            for (String directoryName : directoryNames) {
+                addDestinationItem(directoryName);
             }


Input:
private void actionColumnSelected(ColumnSelectionEvent arg1) {
    if (model != null) {
        int column = arg1.getColumnPositionRanges().iterator().next().start - 1;
        if (column >= 0) {
            final String attr = handle.getAttributeName(column);
            table.setAttribute(attr);
            table.redraw();
            model.setSelectedAttribute(attr);
            controller.update(new ModelEvent(this, ModelPart.SELECTED_ATTRIBUTE, attr));
        }
    }
}

Output:
         if (column >= 0) {
-            final String attr = handle.getAttributeName(column);
-            table.setAttribute(attr);
-            table.redraw();
-            model.setSelectedAttribute(attr);
-            controller.update(new ModelEvent(this, ModelPart.SELECTED_ATTRIBUTE, attr));
+            DataHandle handle = getHandle();
+            if (handle != null) {
+                final String attr = handle.getAttributeName(column);
+                table.setAttribute(attr);
+                table.redraw();
+                model.setSelectedAttribute(attr);
+                controller.update(new ModelEvent(this, ModelPart.SELECTED_ATTRIBUTE, attr));
+            }
         }


Input:
public long skip(long n) throws IOException {
    if (defaultSkip) {
        return super.skip(n);
    }
    if (n <= 0) {
        return 0;
    }
    long left = n;
    byte[] sBuff = new byte[SKIP_BUFFER_SIZE];
    while (left > 0) {
        int res = read(sBuff, 0, (int) (left < SKIP_BUFFER_SIZE ? left : SKIP_BUFFER_SIZE));
        if (res < 0) {
            break;
        }
        left -= res;
    }
    return n - left;
}

Output:
     if (defaultSkip) {
-        return super.skip(n);
+        long bs = super.skip(n);
+        bytesRead += bs;
+        return bs;
     }


Input:
public void renderStatic(int x, int y, int z, IPartRenderHelper rh, RenderBlocks renderer) {
    boolean useCovered = false;
    for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
        IPart p = getHost().getPart(dir);
        if (p != null && p instanceof IGridHost) {
            IGridHost igh = (IGridHost) p;
            AECableType type = igh.getCableConnectionType(dir.getOpposite());
            if (type == AECableType.COVERED || type == AECableType.SMART) {
                useCovered = true;
                break;
            }
        }
    }
    if (useCovered) {
        rh.setTexture(getCoveredTexture(getCableColor()));
    } else {
        rh.setTexture(getTexture(getCableColor()));
    }
    IPartHost ph = getHost();
    for (ForgeDirection of : EnumSet.complementOf(connections)) {
        IPart bp = ph.getPart(of);
        if (bp instanceof IGridHost) {
            int len = bp.cableConnectionRenderTo();
            if (len < 8) {
                switch(of) {
                    case DOWN:
                        rh.setBounds(6, len, 6, 10, 6, 10);
                        break;
                    case EAST:
                        rh.setBounds(10, 6, 6, 16 - len, 10, 10);
                        break;
                    case NORTH:
                        rh.setBounds(6, 6, len, 10, 10, 6);
                        break;
                    case SOUTH:
                        rh.setBounds(6, 6, 10, 10, 10, 16 - len);
                        break;
                    case UP:
                        rh.setBounds(6, 10, 6, 10, 16 - len, 10);
                        break;
                    case WEST:
                        rh.setBounds(len, 6, 6, 6, 10, 10);
                        break;
                    default:
                        continue;
                }
                rh.renderBlock(x, y, z, renderer);
            }
        }
    }
    if (connections.size() != 2 || !nonLinear(connections) || useCovered) {
        if (useCovered) {
            rh.setBounds(5, 5, 5, 11, 11, 11);
            rh.renderBlock(x, y, z, renderer);
        } else {
            rh.setBounds(6, 6, 6, 10, 10, 10);
            rh.renderBlock(x, y, z, renderer);
        }
        for (ForgeDirection of : connections) {
            rendereGlassConection(x, y, z, rh, renderer, of);
        }
    } else {
        Icon def = getTexture(getCableColor());
        rh.setTexture(def);
        for (ForgeDirection of : connections) {
            switch(of) {
                case DOWN:
                case UP:
                    renderer.setRenderBounds(6 / 16.0, 0, 6 / 16.0, 10 / 16.0, 16 / 16.0, 10 / 16.0);
                    break;
                case EAST:
                case WEST:
                    renderer.uvRotateEast = renderer.uvRotateWest = 1;
                    renderer.uvRotateBottom = renderer.uvRotateTop = 1;
                    renderer.setRenderBounds(0, 6 / 16.0, 6 / 16.0, 16 / 16.0, 10 / 16.0, 10 / 16.0);
                    break;
                case NORTH:
                case SOUTH:
                    renderer.uvRotateNorth = renderer.uvRotateSouth = 1;
                    renderer.setRenderBounds(6 / 16.0, 6 / 16.0, 0, 10 / 16.0, 10 / 16.0, 16 / 16.0);
                    break;
                default:
                    continue;
            }
        }
        renderer.renderStandardBlock(rh.getBlock(), x, y, z);
    }
    rh.setTexture(null);
}

Output:
     }
-    if (connections.size() != 2 || !nonLinear(connections) || useCovered) {
+    if (connections.size() != 2 || !nonLinear(connections) || useCovered || requireDetailed) {
         if (useCovered) {


Input:
private Iterator<Edge> internalEdges(Direction direction, String... labels) {
    this.sqlgGraph.tx().readWrite();
    if (this.sqlgGraph.features().supportsBatchMode() && this.sqlgGraph.tx().isInBatchMode() && this.sqlgGraph.tx().getBatchManager().vertexIsCached(this)) {
        List<Edge> edges = this.sqlgGraph.tx().getBatchManager().getEdges(this, direction, labels);
        return edges.iterator();
    } else {
        List<Edge> edges = new ArrayList<>();
        List<Direction> directions = new ArrayList<>(2);
        Set<SchemaTable> inVertexLabels = new HashSet<>();
        Set<SchemaTable> outVertexLabels = new HashSet<>();
        if (direction == Direction.IN) {
            inVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getLeft());
            if (labels.length > 0) {
                retainLabels(inVertexLabels, labels);
            }
            directions.add(direction);
        } else if (direction == Direction.OUT) {
            outVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getRight());
            if (labels.length > 0) {
                retainLabels(outVertexLabels, labels);
            }
            directions.add(direction);
        } else {
            inVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getLeft());
            outVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getRight());
            if (labels.length > 0) {
                retainLabels(inVertexLabels, labels);
                retainLabels(outVertexLabels, labels);
            }
            directions.add(Direction.IN);
            directions.add(Direction.OUT);
        }
        for (Direction d : directions) {
            for (SchemaTable schemaTable : (d == Direction.IN ? inVertexLabels : outVertexLabels)) {
                StringBuilder sql = new StringBuilder("String_Node_Str");
                switch(d) {
                    case IN:
                        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(schemaTable.getSchema()));
                        sql.append("String_Node_Str");
                        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(schemaTable.getTable()));
                        sql.append(WHERE);
                        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(this.schema + "String_Node_Str" + this.table + SchemaManager.IN_VERTEX_COLUMN_END));
                        sql.append("String_Node_Str");
                        break;
                    case OUT:
                        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(schemaTable.getSchema()));
                        sql.append("String_Node_Str");
                        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(schemaTable.getTable()));
                        sql.append(WHERE);
                        sql.append(this.sqlgGraph.getSchemaManager().getSqlDialect().maybeWrapInQoutes(this.schema + "String_Node_Str" + this.table + SchemaManager.OUT_VERTEX_COLUMN_END));
                        sql.append("String_Node_Str");
                        break;
                    case BOTH:
                        throw new IllegalStateException(BUG_DIRECTION_BOTH_SHOULD_NEVER_FIRE_HERE);
                }
                if (this.sqlgGraph.getSqlDialect().needsSemicolon()) {
                    sql.append("String_Node_Str");
                }
                Connection conn = this.sqlgGraph.tx().getConnection();
                if (logger.isDebugEnabled()) {
                    logger.debug(sql.toString());
                }
                try (PreparedStatement preparedStatement = conn.prepareStatement(sql.toString())) {
                    switch(d) {
                        case IN:
                            preparedStatement.setLong(1, this.recordId.getId());
                            break;
                        case OUT:
                            preparedStatement.setLong(1, this.recordId.getId());
                            break;
                        case BOTH:
                            throw new IllegalStateException(BUG_DIRECTION_BOTH_SHOULD_NEVER_FIRE_HERE);
                    }
                    ResultSet resultSet = preparedStatement.executeQuery();
                    while (resultSet.next()) {
                        Set<String> inVertexColumnNames = new HashSet<>();
                        Set<String> outVertexColumnNames = new HashSet<>();
                        String inVertexColumnName = "String_Node_Str";
                        String outVertexColumnName = "String_Node_Str";
                        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
                        for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
                            String columnName = resultSetMetaData.getColumnLabel(i);
                            if (columnName.endsWith(SchemaManager.IN_VERTEX_COLUMN_END)) {
                                inVertexColumnNames.add(columnName);
                            } else if (columnName.endsWith(SchemaManager.OUT_VERTEX_COLUMN_END)) {
                                outVertexColumnNames.add(columnName);
                            }
                        }
                        if (inVertexColumnNames.isEmpty() || outVertexColumnNames.isEmpty()) {
                            throw new IllegalStateException("String_Node_Str");
                        }
                        Long edgeId = resultSet.getLong("String_Node_Str");
                        Long inId = null;
                        Long outId = null;
                        for (String inColumnName : inVertexColumnNames) {
                            if (inId != null) {
                                Long tempInId = resultSet.getLong(inColumnName);
                                if (!resultSet.wasNull()) {
                                    throw new IllegalStateException("String_Node_Str");
                                }
                            } else {
                                Long tempInId = resultSet.getLong(inColumnName);
                                if (!resultSet.wasNull()) {
                                    inId = tempInId;
                                    inVertexColumnName = inColumnName;
                                }
                            }
                        }
                        for (String outColumnName : outVertexColumnNames) {
                            if (outId != null) {
                                Long tempOutId = resultSet.getLong(outColumnName);
                                if (!resultSet.wasNull()) {
                                    throw new IllegalStateException("String_Node_Str");
                                }
                            } else {
                                Long tempOutId = resultSet.getLong(outColumnName);
                                if (!resultSet.wasNull()) {
                                    outId = tempOutId;
                                    outVertexColumnName = outColumnName;
                                }
                            }
                        }
                        if (inVertexColumnName.isEmpty() || outVertexColumnName.isEmpty()) {
                            throw new IllegalStateException("String_Node_Str");
                        }
                        SchemaTable inSchemaTable = SchemaTable.from(this.sqlgGraph, inVertexColumnName, this.sqlgGraph.getSqlDialect().getPublicSchema());
                        SchemaTable outSchemaTable = SchemaTable.from(this.sqlgGraph, outVertexColumnName, this.sqlgGraph.getSqlDialect().getPublicSchema());
                        List<Object> keyValues = new ArrayList<>();
                        for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
                            String columnName = resultSetMetaData.getColumnLabel(i);
                            if (!((columnName.equals("String_Node_Str") || columnName.equals(inVertexColumnNames) || columnName.equals(outVertexColumnNames)))) {
                                keyValues.add(columnName);
                                keyValues.add(resultSet.getObject(columnName));
                            }
                        }
                        SqlgEdge sqlGEdge = null;
                        switch(d) {
                            case IN:
                                sqlGEdge = new SqlgEdge(this.sqlgGraph, edgeId, schemaTable.getSchema(), schemaTable.getTable().substring(SchemaManager.EDGE_PREFIX.length()), this, SqlgVertex.of(this.sqlgGraph, outId, outSchemaTable.getSchema(), SqlgUtil.removeTrailingOutId(outSchemaTable.getTable())), keyValues.toArray());
                                break;
                            case OUT:
                                sqlGEdge = new SqlgEdge(this.sqlgGraph, edgeId, schemaTable.getSchema(), schemaTable.getTable().substring(SchemaManager.EDGE_PREFIX.length()), SqlgVertex.of(this.sqlgGraph, inId, inSchemaTable.getSchema(), SqlgUtil.removeTrailingInId(inSchemaTable.getTable())), this, keyValues.toArray());
                                break;
                            case BOTH:
                                throw new IllegalStateException("String_Node_Str");
                        }
                        edges.add(sqlGEdge);
                    }
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return edges.iterator();
    }
}

Output:
     if (this.sqlgGraph.features().supportsBatchMode() && this.sqlgGraph.tx().isInBatchMode() && this.sqlgGraph.tx().getBatchManager().vertexIsCached(this)) {
-        List<Edge> edges = this.sqlgGraph.tx().getBatchManager().getEdges(this, direction, labels);
-        return edges.iterator();
+        this.sqlgGraph.tx().flush();
+    }
+    List<Edge> edges = new ArrayList<>();
+    List<Direction> directions = new ArrayList<>(2);
+    Set<SchemaTable> inVertexLabels = new HashSet<>();
+    Set<SchemaTable> outVertexLabels = new HashSet<>();
+    if (direction == Direction.IN) {
+        inVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getLeft());
+        if (labels.length > 0) {
+            retainLabels(inVertexLabels, labels);
+        }
+        directions.add(direction);
+    } else if (direction == Direction.OUT) {
+        outVertexLabels.addAll(this.sqlgGraph.getSchemaManager().getTableLabels(this.getSchemaTablePrefixed()).getRight());
+        if (labels.length > 0) {
+            retainLabels(outVertexLabels, labels);
+        }
+        directions.add(direction);
     } else {


Input:
private static File confirmFileSave(File file, File currentFile) {
    int reply = JOptionPane.NO_OPTION;
    while (file != null && file.exists() && !file.equals(currentFile) && reply == JOptionPane.NO_OPTION) {
        reply = JOptionPane.showConfirmDialog(null, file.getAbsoluteFile() + "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_OPTION);
        if (reply == JOptionPane.NO_OPTION) {
            file = FileChooserService.getSelectedFile("String_Node_Str", "String_Node_Str", FileChooserService.DialogType.SAVE, true);
        }
    }
    return file;
}

Output:
         reply = JOptionPane.showConfirmDialog(null, file.getAbsoluteFile() + "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_OPTION);
-        if (reply == JOptionPane.NO_OPTION) {
+        if (reply != JOptionPane.YES_OPTION) {
             file = FileChooserService.getSelectedFile("String_Node_Str", "String_Node_Str", FileChooserService.DialogType.SAVE, true);


Input:
public static <T extends ImageSingleBand, O extends ImageSingleBand> void subtract(T inputA, T inputB, O output) {
    if (ImageUInt8.class == inputA.getClass()) {
        PixelMath.subtract((ImageUInt8) inputA, (ImageUInt8) inputB, (ImageUInt16) output);
    } else if (ImageSInt8.class == inputA.getClass()) {
        PixelMath.subtract((ImageSInt8) inputA, (ImageSInt8) inputB, (ImageSInt16) output);
    } else if (ImageUInt16.class == inputA.getClass()) {
        PixelMath.subtract((ImageUInt16) inputA, (ImageUInt16) inputB, (ImageSInt32) output);
    } else if (ImageSInt16.class == inputA.getClass()) {
        PixelMath.subtract((ImageSInt16) inputA, (ImageSInt16) inputB, (ImageSInt32) output);
    } else if (ImageSInt32.class == inputA.getClass()) {
        PixelMath.subtract((ImageSInt32) inputA, (ImageSInt32) inputB, (ImageSInt32) output);
    } else if (ImageSInt64.class == inputA.getClass()) {
        PixelMath.subtract((ImageSInt64) inputA, (ImageSInt64) inputB, (ImageSInt64) output);
    } else if (ImageFloat32.class == inputA.getClass()) {
        PixelMath.subtract((ImageFloat32) inputA, (ImageFloat32) inputB, (ImageFloat32) output);
    } else if (ImageFloat64.class == inputA.getClass()) {
        PixelMath.subtract((ImageFloat64) inputA, (ImageFloat64) inputB, (ImageFloat64) output);
    } else {
        throw new IllegalArgumentException("String_Node_Str" + inputA.getClass().getSimpleName());
    }
}

Output:
     if (ImageUInt8.class == inputA.getClass()) {
-        PixelMath.subtract((ImageUInt8) inputA, (ImageUInt8) inputB, (ImageUInt16) output);
+        PixelMath.subtract((ImageUInt8) inputA, (ImageUInt8) inputB, (ImageInt16) output);
     } else if (ImageSInt8.class == inputA.getClass()) {


Input:
public static Action parseAction(String line) {
    if (line.length() > 0) {
        if (Character.isDigit(line.charAt(0)) || line.charAt(0) == '[' || line.charAt(0) == '!') {
            return Action.ITEM;
        }
        switch(line.charAt(0)) {
            case 'c':
                if (line.equals("String_Node_Str")) {
                    return Action.COLLECT;
                }
                return Action.NULL;
            case 'd':
                if (line.equals("String_Node_Str")) {
                    return Action.DEPOSIT;
                }
                return Action.NULL;
            case 'a':
                if (line.equals("String_Node_Str")) {
                    return Action.ALL;
                }
                return Action.NULL;
            default:
                return Action.NULL;
        }
    } else {
        return Action.NULL;
    }
}

Output:
     if (line.length() > 0) {
-        if (Character.isDigit(line.charAt(0)) || line.charAt(0) == '[' || line.charAt(0) == '!') {
+        if (Character.isDigit(line.charAt(0))) {
             return Action.ITEM;


Input:
public PerformResult perform(File transformedAppFolder, TransformationContext transformationContext) throws TransformationUtilityException {
    if (hasBeenPerformed.get()) {
        String exceptionMessage = String.format("String_Node_Str", getName());
        TransformationUtilityException e = new TransformationUtilityException(exceptionMessage);
        return PerformResult.error(this, e);
    }
    if (ifConditionAttributeName != null) {
        Object conditionResult = transformationContext.get(ifConditionAttributeName);
        if (conditionResult == null || conditionResult instanceof Boolean && !((Boolean) conditionResult).booleanValue()) {
            String details = String.format("String_Node_Str", getName(), ifConditionAttributeName);
            return PerformResult.skippedCondition(this, details);
        }
    }
    if (unlessConditionAttributeName != null) {
        Object conditionResult = transformationContext.get(unlessConditionAttributeName);
        if (conditionResult == null || conditionResult instanceof Boolean && ((Boolean) conditionResult).booleanValue()) {
            String details = String.format("String_Node_Str", getName(), unlessConditionAttributeName);
            return PerformResult.skippedCondition(this, details);
        }
    }
    if (utilityCondition != null) {
        try {
            TransformationUtility utilityCondition = this.utilityCondition.clone();
            utilityCondition.relative(this.getRelativePath());
            TUExecutionResult conditionExecutionResult = (TUExecutionResult) utilityCondition.execution(transformedAppFolder, transformationContext);
            Object conditionResult = conditionExecutionResult.getValue();
            if (conditionResult == null || conditionResult instanceof Boolean && !((Boolean) conditionResult).booleanValue()) {
                String utilityConditionName = (utilityCondition.getName() == null ? utilityCondition.toString() : utilityCondition.getName());
                String details = String.format("String_Node_Str", getName(), utilityConditionName);
                return PerformResult.skippedCondition(this, details);
            }
        } catch (CloneNotSupportedException e) {
            String exceptionMessage = String.format("String_Node_Str", getName());
            TransformationUtilityException ex = new TransformationUtilityException(exceptionMessage, e);
            return PerformResult.error(this, ex);
        }
    }
    PerformResult result = (PerformResult) checkDependencies(transformationContext);
    if (result != null) {
        return result;
    }
    applyPropertiesFromContext(transformationContext);
    try {
        ExecutionResult executionResult = execution(transformedAppFolder, transformationContext);
        result = PerformResult.executionResult(this, executionResult);
    } catch (Exception e) {
        String exceptionMessage = String.format("String_Node_Str", getName());
        TransformationUtilityException ex = new TransformationUtilityException(exceptionMessage, e);
        return PerformResult.error(this, ex);
    } finally {
        hasBeenPerformed.set(true);
    }
    return result;
}

Output:
         Object conditionResult = transformationContext.get(unlessConditionAttributeName);
-        if (conditionResult == null || conditionResult instanceof Boolean && ((Boolean) conditionResult).booleanValue()) {
+        if (conditionResult != null && conditionResult instanceof Boolean && ((Boolean) conditionResult).booleanValue()) {
             String details = String.format("String_Node_Str", getName(), unlessConditionAttributeName);


Input:
private void drawPiece(Canvas canvas, Piece piece, PieceDrawMode drawMode) {
    if (piece.isAnimated()) {
        final PointF point = piece.getPointF();
        drawPieceAtPoint(canvas, piece, point);
        return;
    }
    final int imageRadius = pieceSize_ / 2;
    Bitmap bitmap = piece.getBitmap();
    Position viewPos = getViewPosition(piece.getPosition());
    final float left = offset_ - imageRadius + viewPos.column * cellSize_;
    final float top = offset_ - imageRadius + viewPos.row * cellSize_;
    if (drawMode == PieceDrawMode.PIECE_DRAW_MODE_SELECTED) {
        Log.d(TAG, "String_Node_Str");
        canvas.drawRect(left - 3, top - 3, left + pieceSize_ + 3, top + pieceSize_ + 3, selectPaint_);
    } else if (drawMode == PieceDrawMode.PIECE_DRAW_MODE_RECENT) {
        Log.d(TAG, "String_Node_Str");
        canvas.drawCircle(left + imageRadius, top + imageRadius, imageRadius + 6, recentPaint_);
    }
    canvas.drawBitmap(bitmap, null, new RectF(left, top, left + pieceSize_, top + pieceSize_), null);
}

Output:
     } else if (drawMode == PieceDrawMode.PIECE_DRAW_MODE_RECENT) {
-        Log.d(TAG, "String_Node_Str");
+        Log.v(TAG, "String_Node_Str");
         canvas.drawCircle(left + imageRadius, top + imageRadius, imageRadius + 6, recentPaint_);


Input:
public boolean sendVpcRoutingPolicyChangeUpdate(OvsVpcRoutingPolicyConfigCommand updateCmd, long hostId, String bridgeName) {
    try {
        s_logger.debug("String_Node_Str" + hostId);
        updateCmd.setHostId(hostId);
        updateCmd.setBridgeName(bridgeName);
        Answer ans = _agentMgr.send(hostId, updateCmd);
        if (ans.getResult()) {
            s_logger.debug("String_Node_Str" + hostId + "String_Node_Str");
            return true;
        } else {
            s_logger.debug("String_Node_Str" + hostId + "String_Node_Str");
            return false;
        }
    } catch (Exception e) {
        s_logger.debug("String_Node_Str" + hostId + "String_Node_Str");
        return false;
    }
}

Output:
     } catch (Exception e) {
-        s_logger.debug("String_Node_Str" + hostId + "String_Node_Str");
+        s_logger.debug("String_Node_Str" + hostId + "String_Node_Str", e);
         return false;


Input:
public void onPanelCollapsed(View view) {
    Log.d(Constants.LOG_TAG, "String_Node_Str");
    ArrayList<String> subscribed = new ArrayList<>();
    subscribed.add(modelKey);
    String[] modelNotifications = ModelHelper.getNotificationTypes(modelType);
    ListViewAdapter adapter = ((ListViewAdapter) list.getAdapter());
    for (int i = 0; i < adapter.values.size(); i++) {
        NotificationTypeListElement element = ((NotificationTypeListElement) adapter.values.get(i));
        Log.d(Constants.LOG_TAG, "String_Node_Str" + i + "String_Node_Str" + element.isEnabled());
        if (element.isEnabled()) {
            subscribed.add(modelNotifications[element.getPosition()]);
        }
    }
    Log.d(Constants.LOG_TAG, "String_Node_Str" + subscribed);
    if (subscribed.size() == 1) {
        new RemoveUserSubscription(getActivity()).execute(modelKey);
    } else {
        new AddUpdateUserSubscription(getActivity()).execute(subscribed.toArray(new String[subscribed.size()]));
    }
}

Output:
     ListViewAdapter adapter = ((ListViewAdapter) list.getAdapter());
-    for (int i = 0; i < adapter.values.size(); i++) {
-        NotificationTypeListElement element = ((NotificationTypeListElement) adapter.values.get(i));
-        Log.d(Constants.LOG_TAG, "String_Node_Str" + i + "String_Node_Str" + element.isEnabled());
-        if (element.isEnabled()) {
-            subscribed.add(modelNotifications[element.getPosition()]);
+    if (adapter != null) {
+        for (int i = 0; i < adapter.values.size(); i++) {
+            NotificationTypeListElement element = ((NotificationTypeListElement) adapter.values.get(i));
+            Log.d(Constants.LOG_TAG, "String_Node_Str" + i + "String_Node_Str" + element.isEnabled());
+            if (element.isEnabled()) {
+                subscribed.add(modelNotifications[element.getPosition()]);
+            }
         }


Input:
public boolean apply(Game game, Ability source) {
    Permanent thisCreature = game.getPermanent(source.getId());
    FilterCreatureCard filter = new FilterCreatureCard("String_Node_Str");
    filter.add(new AbilityPredicate(MorphAbility.class));
    Effect effect = new PutCardFromHandOntoBattlefieldEffect(new FilterCreatureCard(filter));
    if (effect.apply(game, source)) {
        if (thisCreature != null) {
            effect = new ReturnToHandTargetEffect();
            effect.setTargetPointer(new FixedTarget(thisCreature.getId()));
            effect.apply(game, source);
            return true;
        }
    }
    return false;
}

Output:
     filter.add(new AbilityPredicate(MorphAbility.class));
-    Effect effect = new PutCardFromHandOntoBattlefieldEffect(new FilterCreatureCard(filter));
+    Effect effect = new PutCardFromHandOntoBattlefieldEffect(filter);
     if (effect.apply(game, source)) {


Input:
public void onEquipCompass(PlayerItemHeldEvent event) {
    try {
        Player player = event.getPlayer();
        if (player.getInventory().getItem(event.getNewSlot()).getType().equals(Material.COMPASS)) {
            player.sendMessage("String_Node_Str");
            player.sendMessage(ChatColor.YELLOW + "String_Node_Str");
            player.sendMessage(ChatColor.YELLOW + "String_Node_Str");
        }
    } catch (Exception ignore) {
    }
}

Output:
         Player player = event.getPlayer();
-        if (player.getInventory().getItem(event.getNewSlot()).getType().equals(Material.COMPASS)) {
+        if (player.hasPermission("String_Node_Str") && player.getInventory().getItem(event.getNewSlot()).getType().equals(Material.COMPASS)) {
             player.sendMessage("String_Node_Str");


Input:
protected void computeRect(Raster[] sources, WritableRaster dest, Rectangle destRect) {
    int mlibInterpType = Constants.MLIB_BICUBIC;
    if (interp instanceof InterpolationBicubic2) {
        mlibInterpType = Constants.MLIB_BICUBIC2;
    }
    Raster source = sources[0];
    Rectangle srcRect = source.getBounds();
    int formatTag = MediaLibAccessor.findCompatibleTag(sources, dest);
    MediaLibAccessor srcAccessor = new MediaLibAccessor(source, srcRect, formatTag);
    MediaLibAccessor dstAccessor = new MediaLibAccessor(dest, destRect, formatTag);
    double[] medialib_tr = (double[]) this.medialib_tr.clone();
    medialib_tr[2] = m_transform[0] * srcRect.x + m_transform[1] * srcRect.y + m_transform[2] - destRect.x;
    medialib_tr[5] = m_transform[3] * srcRect.x + m_transform[4] * srcRect.y + m_transform[5] - destRect.y;
    mediaLibImage[] srcML, dstML;
    switch(dstAccessor.getDataType()) {
        case DataBuffer.TYPE_BYTE:
        case DataBuffer.TYPE_USHORT:
        case DataBuffer.TYPE_SHORT:
        case DataBuffer.TYPE_INT:
            srcML = srcAccessor.getMediaLibImages();
            dstML = dstAccessor.getMediaLibImages();
            if (setBackground)
                Image.Affine2(dstML[0], srcML[0], medialib_tr, mlibInterpType, Constants.MLIB_EDGE_DST_NO_WRITE, intBackgroundValues);
            else
                Image.Affine(dstML[0], srcML[0], medialib_tr, mlibInterpType, Constants.MLIB_EDGE_DST_NO_WRITE);
            break;
        case DataBuffer.TYPE_FLOAT:
        case DataBuffer.TYPE_DOUBLE:
            srcML = srcAccessor.getMediaLibImages();
            dstML = dstAccessor.getMediaLibImages();
            if (setBackground)
                Image.Affine2_Fp(dstML[0], srcML[0], medialib_tr, mlibInterpType, Constants.MLIB_EDGE_DST_NO_WRITE, backgroundValues);
            else
                Image.Affine_Fp(dstML[0], srcML[0], medialib_tr, mlibInterpType, Constants.MLIB_EDGE_DST_NO_WRITE);
            break;
        default:
            String className = this.getClass().getName();
            throw new Error(JaiI18N.getString("String_Node_Str"));
    }
    if (dstAccessor.isDataCopy()) {
        dstAccessor.copyDataToRaster();
    }
}

Output:
             String className = this.getClass().getName();
-            throw new Error(JaiI18N.getString("String_Node_Str"));
+            throw new RuntimeException(JaiI18N.getString("String_Node_Str"));
     }


Input:
public void setCursor(int w, int h, Point hotspot, int[] data, byte[] mask) {
    synchronized (cc.viewer.useLocalCursor) {
        if (!cc.viewer.useLocalCursor.getValue())
            return;
    }
    hideLocalCursor();
    if (hotspot == null)
        hotspot = new Point(0, 0);
    cursor.hotspot = hotspot;
    Dimension bsc = tk.getBestCursorSize(w, h);
    cursor.setSize(((int) bsc.getWidth() > w ? (int) bsc.getWidth() : w), ((int) bsc.getHeight() > h ? (int) bsc.getHeight() : h));
    cursor.setPF(getPF());
    cursorBacking.setSize(cursor.width(), cursor.height());
    cursorBacking.setPF(getPF());
    cursor.data = new int[cursor.width() * cursor.height()];
    cursor.mask = new byte[cursor.maskLen()];
    int maskBytesPerRow = (w + 7) / 8;
    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            int byte_ = y * maskBytesPerRow + x / 8;
            int bit = 7 - x % 8;
            if ((mask[byte_] & (1 << bit)) > 0) {
                cursor.data[y * cursor.width() + x] = (0xff << 24) | (im.cm.getRed(data[y * w + x]) << 16) | (im.cm.getGreen(data[y * w + x]) << 8) | (im.cm.getBlue(data[y * w + x]));
            }
        }
        System.arraycopy(mask, y * maskBytesPerRow, cursor.mask, y * ((cursor.width() + 7) / 8), maskBytesPerRow);
    }
    MemoryImageSource bitmap = new MemoryImageSource(cursor.width(), cursor.height(), ColorModel.getRGBdefault(), cursor.data, 0, cursor.width());
    int cw = (int) Math.floor((float) cursor.width() * scaleWidthRatio);
    int ch = (int) Math.floor((float) cursor.height() * scaleHeightRatio);
    int hint = java.awt.Image.SCALE_DEFAULT;
    hotspot = new Point((int) Math.floor((float) hotspot.x * scaleWidthRatio), (int) Math.floor((float) hotspot.y * scaleHeightRatio));
    Image cursorImage = (cw <= 0 || ch <= 0) ? tk.createImage(bitmap) : tk.createImage(bitmap).getScaledInstance(cw, ch, hint);
    softCursor = tk.createCustomCursor(cursorImage, new java.awt.Point(hotspot.x, hotspot.y), "String_Node_Str");
    cursorImage.flush();
    if (softCursor != null) {
        setCursor(softCursor);
        cursorAvailable = true;
        return;
    }
    if (!cursorAvailable) {
        cursorAvailable = true;
    }
    showLocalCursor();
    return;
}

Output:
     cursor.hotspot = hotspot;
-    Dimension bsc = tk.getBestCursorSize(w, h);
-    cursor.setSize(((int) bsc.getWidth() > w ? (int) bsc.getWidth() : w), ((int) bsc.getHeight() > h ? (int) bsc.getHeight() : h));
+    cursor.setSize(w, h);
     cursor.setPF(getPF());


Input:
public boolean matches(IBond targetBond) {
    if (this.queryBond != null && queryBond instanceof IQueryBond) {
        return ((IQueryBond) queryBond).matches(targetBond);
    } else if ((queryBond != null && targetBond != null) && isBondMatchFlag() && isBondTypeMatch(targetBond)) {
        return true;
    } else if ((queryBond != null && targetBond != null) && !isBondMatchFlag() && isShouldMatchRings()) {
        if (queryBond.getFlag(CDKConstants.ISAROMATIC) && targetBond.getFlag(CDKConstants.ISAROMATIC)) {
            return true;
        }
        return !queryBond.getFlag(CDKConstants.ISAROMATIC) && !targetBond.getFlag(CDKConstants.ISAROMATIC);
    }
    return false;
}

Output:
         }
-        return !queryBond.getFlag(CDKConstants.ISAROMATIC) && !targetBond.getFlag(CDKConstants.ISAROMATIC);
+    } else if ((queryBond != null && targetBond != null) && !isBondMatchFlag() && !isShouldMatchRings()) {
+        return true;
     }


Input:
public boolean dispatchTouchEvent(MotionEvent m) {
    if (mZoomButtonsController.isVisible() && mZoomButtonsController.onTouch(null, m)) {
        scheduleDismissOnScreenControls();
    }
    if (!super.dispatchTouchEvent(m)) {
        return mGestureDetector.onTouchEvent(m);
    }
    return true;
}

Output:
 public boolean dispatchTouchEvent(MotionEvent m) {
-    if (mZoomButtonsController.isVisible() && mZoomButtonsController.onTouch(null, m)) {
+    if (mZoomButtonsController.isVisible()) {
         scheduleDismissOnScreenControls();


Input:
public void setIncomingPacket(int[] packet) {
    int adr = RAM_RXFIFO;
    memory[adr++] = packet.length + 2;
    for (int i = 0, n = packet.length; i < n; i++) {
        memory[adr++] = packet[i] & 0xff;
    }
    memory[adr++] = (202) & 0xff;
    memory[adr++] = (37) | 0x80;
    rxPacket = true;
    rxCursor = 0;
    rxLen = adr;
    updateFifopPin();
}

Output:
     memory[adr++] = packet.length + 2;
-    for (int i = 0, n = packet.length; i < n; i++) {
-        memory[adr++] = packet[i] & 0xff;
+    for (int element : packet) {
+        memory[adr++] = element & 0xff;
     }


Input:
public boolean performFinish() {
    boolean successful = false;
    try {
        fProjectPage.updateData();
        fContentPage.updateData();
        IDialogSettings settings = getDialogSettings();
        if (settings != null) {
            fProjectPage.saveSettings(settings);
            fContentPage.saveSettings(settings);
        }
        fTemplateWizard.setTemplateExtension(fProjectPage.getProjectName());
        BasicNewProjectResourceWizard.updatePerspective(fConfig);
        if (!PDECore.getDefault().areModelsInitialized()) {
            try {
                getContainer().run(true, true, new IRunnableWithProgress() {
                    public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                        PDECore.getDefault().getModelManager().targetReloaded(monitor);
                        if (monitor.isCanceled()) {
                            throw new InterruptedException();
                        }
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        getContainer().run(false, true, new NewProjectCreationOperation(fPluginData, fProjectProvider, fTemplateWizard));
        IWorkingSet[] workingSets = fProjectPage.getSelectedWorkingSets();
        if (workingSets.length > 0)
            getWorkbench().getWorkingSetManager().addToWorkingSets(fProjectProvider.getProject(), workingSets);
        setNature(fProjectProvider.getProject());
        setPackageLayout();
        addPackageImports();
        fProjectProvider.getProject().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
        successful = true;
    } catch (InvocationTargetException e) {
        PDEPlugin.logException(e);
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (CoreException e) {
        e.printStackTrace();
    }
    return successful;
}

Output:
         setPackageLayout();
-        addPackageImports();
+        updateManifest();
         fProjectProvider.getProject().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());


Input:
public void testRunDebugRhodesAppTask() throws Throwable {
    String appName = "String_Node_Str";
    String projectLocation = OSHelper.concat(workspaceFolder, appName).getPath();
    String signature1 = OSValidator.isWindows() ? "String_Node_Str" + unixSlashes(projectLocation) + "String_Node_Str" : "String_Node_Str" + projectLocation;
    String signature2 = OSValidator.isWindows() ? "String_Node_Str" : "String_Node_Str";
    ProcessListViewer rhosimViewer = new ProcessListViewer(signature1);
    ProcessListViewer rakeViewer = new ProcessListViewer(signature2);
    try {
        {
            RunTask task = new GenerateRhodesAppTask(workspaceFolder, appName);
            task.run();
            assertEquals(0, TaskResultConverter.getResultIntCode(task.getResult()));
        }
        {
            String[] text = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
            String appRb = OSHelper.concat(projectLocation, "String_Node_Str", "String_Node_Str").getPath();
            writeTextFile(appRb, join("String_Node_Str", text));
        }
        DebugCallback debugCallback = new DebugCallback(m_eventQueue, m_semaphore);
        final DebugServer debugServer = new DebugServer(debugCallback);
        final Throwable[] exception = new Throwable[1];
        Thread debugServerThread = new Thread(new Runnable() {
            public void run() {
                try {
                    debugServer.run();
                } catch (Throwable t) {
                    exception[0] = t;
                }
            }
        });
        debugServerThread.start();
        {
            Map<String, Object> params = new HashMap<String, Object>();
            ILaunch launch = new Launch(null, ILaunchManager.DEBUG_MODE, null);
            params.put(RunDebugRhodesAppTask.workDir, projectLocation);
            params.put(RunDebugRhodesAppTask.appName, appName);
            params.put(RunDebugRhodesAppTask.platformType, PlatformType.eAndroid);
            params.put(RunDebugRhodesAppTask.reloadCode, false);
            params.put(RunDebugRhodesAppTask.launchObj, launch);
            params.put(RunDebugRhodesAppTask.traceFlag, false);
            Map<String, ?> results = RhoTaskHolder.getInstance().runTask(RunDebugRhodesAppTask.class, params);
            assertEquals(TaskResultConverter.okCode, TaskResultConverter.getResultIntCode(results));
        }
        suspend("String_Node_Str");
        debugServer.debugBreakpoint("String_Node_Str", 5);
        debugServer.debugBreakpoint("String_Node_Str", 6);
        debugServer.debugRemoveBreakpoint("String_Node_Str", 5);
        pass("String_Node_Str", "String_Node_Str", "String_Node_Str" + unixSlashes(prependPrivate(OSHelper.concat(projectLocation, "String_Node_Str").getPath())) + "String_Node_Str", "String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str");
        debugServer.debugBreakpoint("String_Node_Str", 7);
        debugServer.debugResume();
        pass("String_Node_Str", "String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str");
        debugServer.debugStepOver();
        pass("String_Node_Str", "String_Node_Str", "String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str");
        debugServer.debugBreakpoint("String_Node_Str", 12);
        debugServer.debugResume();
        pass("String_Node_Str", "String_Node_Str");
        debugServer.debugBreakpoint("String_Node_Str", 13);
        debugServer.debugRemoveAllBreakpoints();
        debugServer.debugStepReturn();
        pass("String_Node_Str", "String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str" + prependPrivate(unixSlashes(OSHelper.concat(projectLocation, "String_Node_Str", "String_Node_Str").getPath())) + "String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str");
        debugServer.debugEvaluate("String_Node_Str");
        pass("String_Node_Str");
        debugServer.debugTerminate();
        pass("String_Node_Str");
        debugServer.shutdown();
        resume();
        debugServerThread.join();
        if (exception[0] != null) {
            throw exception[0];
        }
    } finally {
        OSHelper.killProcesses(rhosimViewer.getNewProcesses());
        OSHelper.killProcesses(rakeViewer.getNewProcesses());
    }
}

Output:
             ILaunch launch = new Launch(null, ILaunchManager.DEBUG_MODE, null);
-            params.put(RunDebugRhodesAppTask.workDir, projectLocation);
-            params.put(RunDebugRhodesAppTask.appName, appName);
-            params.put(RunDebugRhodesAppTask.platformType, PlatformType.eAndroid);
-            params.put(RunDebugRhodesAppTask.reloadCode, false);
-            params.put(RunDebugRhodesAppTask.launchObj, launch);
-            params.put(RunDebugRhodesAppTask.traceFlag, false);
-            Map<String, ?> results = RhoTaskHolder.getInstance().runTask(RunDebugRhodesAppTask.class, params);
-            assertEquals(TaskResultConverter.okCode, TaskResultConverter.getResultIntCode(results));
+            RunTask task = new RunDebugRhodesAppTask(projectLocation, appName, PlatformType.eAndroid, false, launch, false);
+            task.run();
+            assertEquals(TaskResultConverter.okCode, TaskResultConverter.getResultIntCode(task.getResult()));
         }


Input:
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
    String prefix = cmd.getName();
    Player player = (Player) sender;
    if (prefix.equalsIgnoreCase("String_Node_Str")) {
        if (args.length > 0) {
            String name = args[0];
            if (permissions.world(player)) {
                for (World world : getServer().getWorlds().toArray(new World[0])) {
                    if (name.equalsIgnoreCase(config.getAliasFromWorld(world))) {
                        sendPlayerList(player, "String_Node_Str" + world.getName() + "String_Node_Str" + world.getPlayers().size() + "String_Node_Str" + getServer().getMaxPlayers() + "String_Node_Str", world.getPlayers());
                        return true;
                    }
                }
            }
            if (permissions.player(player)) {
                for (World world : getServer().getWorlds().toArray(new World[0])) {
                    for (Player playerInfo : world.getPlayers().toArray(new Player[0])) {
                        if (playerInfo.getName().equalsIgnoreCase(name)) {
                            Location loc = playerInfo.getLocation();
                            Util.sendMessage(player, "String_Node_Str" + playerInfo.getName());
                            Util.sendMessage(player, "String_Node_Str" + playerInfo.getAddress().getAddress().getHostAddress().toString());
                            Util.sendMessage(player, "String_Node_Str" + loc.getX() + "String_Node_Str" + loc.getY() + "String_Node_Str" + loc.getZ());
                            Util.sendMessage(player, "String_Node_Str" + config.getAliasFromWorld(playerInfo.getWorld()));
                            Util.sendMessage(player, "String_Node_Str" + playerInfo.getHealth() + "String_Node_Str");
                            Util.sendMessage(player, "String_Node_Str" + (player.isOp() ? "String_Node_Str" : "String_Node_Str"));
                            return true;
                        }
                    }
                }
            }
        } else if (permissions.list(player)) {
            List<Player> players = new ArrayList<Player>();
            for (World world : getServer().getWorlds().toArray(new World[0])) players.addAll(world.getPlayers());
            sendPlayerList(player, "String_Node_Str" + players.size() + "String_Node_Str" + getServer().getMaxPlayers() + "String_Node_Str", players);
            return true;
        }
    }
    return false;
}

Output:
                         if (playerInfo.getName().equalsIgnoreCase(name)) {
-                            Location loc = playerInfo.getLocation();
+                            Location loc = Util.getSimpleLocation(playerInfo.getLocation());
                             Util.sendMessage(player, "String_Node_Str" + playerInfo.getName());


Input:
public static TclTree genLocalOpTcl(BuiltinOpcode op, Var out, List<Arg> in, ArrayList<Expression> argExpr) {
    if (op == BuiltinOpcode.ASSERT || op == BuiltinOpcode.ASSERT_EQ) {
        assert (out != null && Types.isVoidVal(out));
        Token tclFn;
        switch(op) {
            case ASSERT:
                tclFn = Turbine.TURBINE_ASSERT_IMPL;
                break;
            case ASSERT_EQ:
                tclFn = Turbine.TURBINE_ASSERT_EQUAL_IMPL;
                break;
            default:
                throw new STCRuntimeError("String_Node_Str" + op.toString());
        }
        return new Command(tclFn, argExpr);
    } else {
        if (op == BuiltinOpcode.SPRINTF) {
            Square fmtArgs = new TclList(argExpr);
            Square fmt = new Square(new Token("String_Node_Str"), new Token("String_Node_Str"), fmtArgs);
            return new SetVariable(TclNamer.prefixVar(out.name()), fmt);
        } else {
            assert (out != null);
            assert (Types.isPrimValue(out));
            Expression rhs;
            if (op == BuiltinOpcode.STRCAT) {
                rhs = localStrCat(in, argExpr);
            } else if (op == BuiltinOpcode.DIRCAT) {
                rhs = localDirCat(in, argExpr);
            } else if (op == BuiltinOpcode.EQ_STRING || op == BuiltinOpcode.NEQ_STRING) {
                assert (argExpr.size() == 2);
                Expression s1 = argExpr.get(0);
                Expression s2 = argExpr.get(1);
                rhs = Turbine.stringEqual(s1, s2);
                if (op == BuiltinOpcode.NEQ_STRING) {
                    rhs = new TclExpr(true, TclExpr.NOT, rhs);
                }
            } else if (op == BuiltinOpcode.COPY_BLOB || op == BuiltinOpcode.COPY_BOOL || op == BuiltinOpcode.COPY_INT || op == BuiltinOpcode.COPY_VOID || op == BuiltinOpcode.COPY_FLOAT || op == BuiltinOpcode.COPY_STRING) {
                assert (argExpr.size() == 1);
                checkCopy(op, out, in.get(0));
                rhs = argExpr.get(0);
            } else if (op == BuiltinOpcode.MOD_INT) {
                rhs = Turbine.modInteger(argExpr.get(0), argExpr.get(1));
            } else if (op == BuiltinOpcode.DIV_INT) {
                rhs = Turbine.divideInteger(argExpr.get(0), argExpr.get(1));
            } else if (op == BuiltinOpcode.POW_INT) {
                assert (argExpr.size() == 2);
                assert (in.get(0).isImmInt() && in.get(1).isImmInt());
                rhs = new Square(Turbine.POW_INTEGER_IMPL, argExpr.get(0), argExpr.get(1));
            } else if (op == BuiltinOpcode.SUBSTRING) {
                assert (argExpr.size() == 3);
                rhs = new Square(Turbine.SUBSTRING_IMPL, argExpr.get(0), argExpr.get(1), argExpr.get(2));
            } else if (op == BuiltinOpcode.INTTOSTR || op == BuiltinOpcode.FLOATTOSTR) {
                assert (argExpr.size() == 1);
                rhs = argExpr.get(0);
            } else if (op == BuiltinOpcode.PARSE_INT) {
                assert (argExpr.size() == 2);
                rhs = Square.fnCall(Turbine.PARSE_INT, argExpr.get(0), argExpr.get(1));
            } else if (op == BuiltinOpcode.PARSE_FLOAT) {
                assert (argExpr.size() == 1);
                rhs = Square.fnCall(Turbine.TOFLOAT_IMPL, argExpr.get(0), argExpr.get(1));
            } else {
                Expression[] exp = arithOpExpr(op, argExpr);
                rhs = new TclExpr(exp);
            }
            return new SetVariable(TclNamer.prefixVar(out.name()), rhs);
        }
    }
}

Output:
                 assert (argExpr.size() == 1);
-                rhs = Square.fnCall(Turbine.TOFLOAT_IMPL, argExpr.get(0), argExpr.get(1));
+                rhs = Square.fnCall(Turbine.TOFLOAT_IMPL, argExpr.get(0));
             } else {


Input:
public Graph filter(Graph graph, Filter[] filters) {
    if (filters.length > 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    HierarchicalGraph hgraph = (HierarchicalGraph) graph;
    Filter filter = filters[0];
    if (filter instanceof EdgeFilter && ((EdgeFilter) filter).init(hgraph)) {
        EdgeFilter edgeFilter = (EdgeFilter) filter;
        for (Edge e : hgraph.getEdgesAndMetaEdges().toArray()) {
            if (edgeFilter.evaluate(hgraph, e)) {
                hgraph.removeEdge(e);
            }
        }
        edgeFilter.finish();
    }
    return hgraph;
}

Output:
             if (edgeFilter.evaluate(hgraph, e)) {
-                hgraph.removeEdge(e);
+                edgesToRemove.add(e);
             }


Input:
private void updateRefOfDita(Content changeTable, Hashtable<String, String> conflictTable, AbstractPipelineInput input) {
    DITAOTJavaLogger logger = new DITAOTJavaLogger();
    String tempDir = ((PipelineHashIO) input).getAttribute(Constants.ANT_INVOKER_PARAM_TEMPDIR);
    if (!new File(tempDir).isAbsolute()) {
        String baseDir = ((PipelineHashIO) input).getAttribute(Constants.ANT_INVOKER_PARAM_BASEDIR);
        tempDir = new File(baseDir, tempDir).getAbsolutePath();
    }
    File ditalist = new File(tempDir, Constants.FILE_NAME_DITA_LIST);
    File xmlDitalist = new File(tempDir, Constants.FILE_NAME_DITA_LIST_XML);
    Properties prop = new Properties();
    try {
        if (xmlDitalist.exists()) {
            prop.loadFromXML(new FileInputStream(xmlDitalist));
        } else {
            prop.load(new FileInputStream(ditalist));
        }
    } catch (IOException io) {
        logger.logError(io.getMessage());
    }
    TopicRefWriter topicRefWriter = new TopicRefWriter();
    topicRefWriter.setContent(changeTable);
    topicRefWriter.setup(conflictTable);
    StringTokenizer fullTopicList = new StringTokenizer(prop.getProperty(Constants.FULL_DITAMAP_TOPIC_LIST), Constants.COMMA);
    try {
        while (fullTopicList.hasMoreTokens()) {
            topicRefWriter.write(new File(tempDir, fullTopicList.nextToken()).getAbsolutePath());
        }
    } catch (DITAOTException ex) {
        logger.logException(ex);
    }
}

Output:
         if (xmlDitalist.exists()) {
-            prop.loadFromXML(new FileInputStream(xmlDitalist));
+            in = new FileInputStream(xmlDitalist);
+            prop.loadFromXML(in);
         } else {


Input:
public void onEntryUpdated(NotificationData.Entry entry, StatusBarNotification oldNotification) {
    String oldKey = oldNotification.getGroupKey();
    String newKey = entry.notification.getGroupKey();
    boolean groupKeysChanged = !oldKey.equals(newKey);
    boolean wasGroupChild = isGroupChild(oldNotification);
    boolean isGroupChild = isGroupChild(entry.notification);
    mUpdatingSuppressionBlocked = !groupKeysChanged && wasGroupChild == isGroupChild;
    if (mGroupMap.get(getGroupKey(oldNotification)) != null) {
        onEntryRemovedInternal(entry, oldNotification);
    }
    onEntryAdded(entry);
    mUpdatingSuppressionBlocked = false;
    if (isIsolated(entry.notification)) {
        mIsolatedEntries.put(entry.key, entry.notification);
        if (groupKeysChanged) {
            updateSuppression(mGroupMap.get(oldKey));
            updateSuppression(mGroupMap.get(newKey));
        }
    } else if (!wasGroupChild && isGroupChild) {
        onEntryBecomingChild(entry);
    }
}

Output:
     boolean isGroupChild = isGroupChild(entry.notification);
-    mUpdatingSuppressionBlocked = !groupKeysChanged && wasGroupChild == isGroupChild;
+    mIsUpdatingUnchangedGroup = !groupKeysChanged && wasGroupChild == isGroupChild;
     if (mGroupMap.get(getGroupKey(oldNotification)) != null) {


Input:
public void createLink(String parentPath, String childPath) {
    parentPath = cleanPath(parentPath);
    childPath = cleanPath(childPath);
    Vertex parentVertex = nodeList.get(parentPath);
    Vertex childVertex = nodeList.get(childPath);
    if (parentVertex == null) {
        this.addNodeEvent(parentPath);
        parentVertex = nodeList.get(parentPath);
    }
    if (childVertex == null) {
        this.addNodeEvent(childPath);
        childVertex = nodeList.get(childPath);
    }
    Edge e = graph.aConnectingEdge(parentVertex, childVertex);
    if (e == Edge.NONE) {
        graph.insertDirectedEdge(parentVertex, childVertex, "String_Node_Str");
        System.out.println("String_Node_Str" + parentPath + "String_Node_Str" + childPath);
    }
}

Output:
         graph.insertDirectedEdge(parentVertex, childVertex, "String_Node_Str");
-        System.out.println("String_Node_Str" + parentPath + "String_Node_Str" + childPath);
+        logger.info("String_Node_Str" + parentPath + "String_Node_Str" + childPath);
     }


Input:
public boolean isSet() {
    if (getFirstIndex() >= 0 && getSecondIndex() >= 0) {
        return true;
    } else {
        return false;
    }
}

Output:
 public boolean isSet() {
-    if (getFirstIndex() >= 0 && getSecondIndex() >= 0) {
+    if (firstIndex >= 0 && secondIndex >= 0 && thirdIndex >= 0) {
         return true;


Input:
public boolean onPlayerRightClick(EntityPlayer player, int side, Pos hit) {
    if (isServer()) {
        ItemStack stack = player.getHeldItem();
        if (getMissile() != null) {
            if (stack == null) {
                player.addChatComponentMessage(new ChatComponentText("String_Node_Str"));
                player.inventory.mainInventory[player.inventory.currentItem] = getMissile().toStack();
                setMissile(null);
                player.inventoryContainer.detectAndSendChanges();
                updateClient();
                return true;
            }
        } else if (stack.getItem() instanceof ItemMissile) {
            player.addChatComponentMessage(new ChatComponentText("String_Node_Str"));
            setMissile(MissileModuleBuilder.INSTANCE.buildMissile(stack));
            if (!player.capabilities.isCreativeMode) {
                stack.stackSize--;
                if (stack.stackSize <= 0) {
                    player.inventory.mainInventory[player.inventory.currentItem] = null;
                }
                player.inventoryContainer.detectAndSendChanges();
                updateClient();
            }
            return true;
        }
    }
    return false;
}

Output:
                 player.inventoryContainer.detectAndSendChanges();
-                updateClient();
+                sendDescPacket();
                 return true;


Input:
public void draw() {
    int regionZoomLevel = Math.max(0, this.mapView.getZoomLevel());
    double tSize = (double) (this.mw.mapTexture.textureSize << regionZoomLevel);
    double u = (this.mapView.getMinX() % tSize) / tSize;
    double v = (this.mapView.getMinZ() % tSize) / tSize;
    double w = this.mapView.getWidth() / tSize;
    double h = this.mapView.getHeight() / tSize;
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GL11.glTranslatef((float) this.mapMode.xTranslation, (float) this.mapMode.yTranslation, -2000.0f);
    if (this.mapMode.rotate) {
        GL11.glRotatef((float) this.mw.mapRotationDegrees, 0.0f, 0.0f, 1.0f);
    }
    if (this.mapMode.circular) {
        Render.setCircularStencil(0, 0, this.mapMode.h / 2.0);
    }
    Render.setColourWithAlphaPercent(0xffffff, this.mapMode.alphaPercent);
    this.mw.mapTexture.bind();
    Render.drawTexturedRect(this.mapMode.x, this.mapMode.y, this.mapMode.w, this.mapMode.h, u, v, u + w, v + h);
    Render.disableStencil();
    this.drawBorder(this.mapMode);
    this.mw.markerManager.drawMarkers(this.mapMode, this.mapView);
    if (this.mw.playerTrail.enabled) {
        this.mw.playerTrail.draw(this.mapMode, this.mapView);
    }
    Point.Double arrow = this.getPlayerArrowPos();
    Render.setColour(this.mapMode.playerArrowColour);
    Render.drawArrow(arrow.x, arrow.y, this.mw.playerHeading, this.mapMode.playerArrowSize);
    GL11.glLoadIdentity();
    GL11.glTranslatef((float) this.mapMode.xTranslation, (float) this.mapMode.yTranslation, -2000.0f);
    drawCoords(this.mw, this.mapMode);
    GL11.glPopMatrix();
}

Output:
     Render.drawTexturedRect(this.mapMode.x, this.mapMode.y, this.mapMode.w, this.mapMode.h, u, v, u + w, v + h);
-    Render.disableStencil();
+    if (this.mapMode.circular) {
+        Render.disableStencil();
+    }
     this.drawBorder(this.mapMode);


Input:
public void updateScreen() {
    prevOffsetY = offsetY.value();
    if (!portalSpeed.isAnimating()) {
        if (currentObject != null) {
            if (MathUtil.floatEquals(portalSpeed.value(), 15F))
                portalSpeed.startAnimation(15F, 5F, 0.5F);
        } else if (MathUtil.floatEquals(portalSpeed.value(), 5F))
            portalSpeed.startAnimation(5F, 15F, 0.5F);
    }
    portalRenderer.update((int) portalSpeed.value());
    for (AnimatedFloat animation : animationList) animation.update(0.05F);
    int wheel = Mouse.getDWheel();
    if (wheel != 0) {
        if (currentObject != null && (currentObject == KnowledgeRegistrations.HELP || prevMouseX >= width >> 1)) {
            if (wheel > 0)
                actionPerformed((GuiButton) buttonList.get(3));
            else if (wheel < 0)
                actionPerformed((GuiButton) buttonList.get(4));
        } else
            offsetY.set(offsetY.value() + (wheel > 0 ? 80 : -80));
    }
    if (!MathUtil.floatEquals(prevDragOffsetY, 0F)) {
        offsetY.set(offsetY.value() - prevDragOffsetY);
        prevDragOffsetY = 0F;
    }
    if (offsetY.value() > 0)
        offsetY.set(0F);
    else if (offsetY.value() < -totalHeight + height - 32)
        offsetY.set(-totalHeight + height - 32);
}

Output:
     else if (offsetY.value() < -totalHeight + height - 32)
-        offsetY.set(-totalHeight + height - 32);
+        offsetY.set(totalHeight > height ? -totalHeight + height - 32F : 0F);
 }


Input:
public static String getLongLikeLabelText(Context context, int numLikes, boolean isLikedByCurrentUser) {
    if (isLikedByCurrentUser) {
        switch(numLikes) {
            case 1:
                return context.getString(R.string.reader_likes_only_you);
            case 2:
                return context.getString(R.string.reader_likes_you_and_one);
            default:
                String youAndMultiLikes = context.getString(R.string.reader_likes_you_and_multi);
                return String.format(youAndMultiLikes, numLikes - 1);
        }
    } else {
        if (numLikes == 1) {
            return context.getString(R.string.reader_likes_one);
        } else {
            String likes = context.getString(R.string.reader_likes_multi);
            return String.format(LocaleManager.getSafeLocale(context), likes, numLikes);
        }
    }
}

Output:
                 String youAndMultiLikes = context.getString(R.string.reader_likes_you_and_multi);
-                return String.format(youAndMultiLikes, numLikes - 1);
+                return String.format(LocaleManager.getSafeLocale(context), youAndMultiLikes, numLikes - 1);
         }


Input:
private void parseHomeLine(BufferedReader reader) throws IOException {
    String[] RowData = reader.readLine().split("String_Node_Str");
    home = new waypoint(Double.valueOf(RowData[8]), Double.valueOf(RowData[9]), Double.valueOf(RowData[10]));
    home.setNumber(Integer.valueOf(RowData[0]));
    home.setFrame(Integer.valueOf(RowData[2]));
    home.setCmd(ApmCommands.getCmd(Integer.valueOf(RowData[3])));
    home.setParameters(Float.valueOf(RowData[4]), Float.valueOf(RowData[5]), Float.valueOf(RowData[6]), Float.valueOf(RowData[7]));
    home.setAutoContinue(Integer.valueOf(RowData[11]));
}

Output:
     String[] RowData = reader.readLine().split("String_Node_Str");
-    home = new waypoint(Double.valueOf(RowData[8]), Double.valueOf(RowData[9]), Double.valueOf(RowData[10]));
+    home = new Home(Double.valueOf(RowData[8]), Double.valueOf(RowData[9]), Double.valueOf(RowData[10]));
     home.setNumber(Integer.valueOf(RowData[0]));