Input:
protected void onListItemClick(ListView l, View v, int position, long id) {
    Track trackSelected = fileChooser.choose((String) l.getItemAtPosition(position));
    if (trackSelected != null) {
        tp.player.play(trackSelected);
        SwitchToNowPlayingSlide();
    }
}

Output:
 protected void onListItemClick(ListView l, View v, int position, long id) {
-    Track trackSelected = fileChooser.choose((String) l.getItemAtPosition(position));
+    Track trackSelected = fileChooser.choose((Instance) l.getItemAtPosition(position));
     if (trackSelected != null) {


Input:
public void testCopyFromEmptyStringRouting() throws Exception {
    execute("String_Node_Str");
    ensureYellow();
    execute("String_Node_Str");
    refresh();
    String uri = Paths.get(folder.getRoot().toURI()).toString();
    SQLResponse response = execute("String_Node_Str", new Object[] { uri });
    assertThat(response.rowCount(), is(2L));
    execute("String_Node_Str");
    refresh();
    execute("String_Node_Str", new Object[] { uri + "String_Node_Str" });
    refresh();
    response = execute("String_Node_Str");
    assertThat(response.rowCount(), is(1L));
    assertThat((long) response.rows()[0][1], is(2L));
}

Output:
     refresh();
-    String uri = Paths.get(folder.getRoot().toURI()).toString();
+    String uri = Paths.get(folder.getRoot().toURI()).toUri().toString();
     SQLResponse response = execute("String_Node_Str", new Object[] { uri });


Input:
private void checkStatus() {
    GossipMember local = getSelf();
    Map<GossipMember, HeartbeatState> endpoints = getEndpointMembers();
    Set<GossipMember> epKeys = endpoints.keySet();
    for (GossipMember k : epKeys) {
        if (!k.equals(local)) {
            HeartbeatState state = endpoints.get(k);
            long now = System.currentTimeMillis();
            long duration = now - state.getHeartbeatTime();
            long convictedTime = convictedTime();
            LOGGER.info("String_Node_Str" + k.toString() + "String_Node_Str" + state.toString() + "String_Node_Str" + duration + "String_Node_Str" + convictedTime);
            if (duration > convictedTime) {
                if (duration > (getSettings().getDeleteThreshold() * getSettings().getGossipInterval())) {
                    clearMember(k);
                } else if (isAlive(k) || getLiveMembers().contains(k)) {
                    LOGGER.info("String_Node_Str");
                    down(k);
                }
            }
            if (duration <= convictedTime && (isDiscoverable(k) || getDeadMembers().contains(k))) {
                LOGGER.info("String_Node_Str");
                up(k);
            }
        }
    }
}

Output:
             LOGGER.info("String_Node_Str" + k.toString() + "String_Node_Str" + state.toString() + "String_Node_Str" + duration + "String_Node_Str" + convictedTime);
-            if (duration > convictedTime) {
-                if (duration > (getSettings().getDeleteThreshold() * getSettings().getGossipInterval())) {
-                    clearMember(k);
-                } else if (isAlive(k) || getLiveMembers().contains(k)) {
-                    LOGGER.info("String_Node_Str");
-                    down(k);
-                }
+            if (duration > convictedTime && (isAlive(k) || getLiveMembers().contains(k))) {
+                downing(k, state);
             }


Input:
private void onFriendFocusDelete(SSDataEvent event) {
    final Ref rng = event.getRef();
    if (BookHelper.getSheet(_book, rng.getOwnerSheet()).equals(_selectedSheet)) {
        final Focus focus = (Focus) event.getPayload();
        removeEditorFocus(focus.id);
    }
}

Output:
     final Ref rng = event.getRef();
-    if (BookHelper.getSheet(_book, rng.getOwnerSheet()).equals(_selectedSheet)) {
+    Worksheet sheet = BookHelper.getSheet(_book, rng.getOwnerSheet());
+    if (sheet == null) {
+        return;
+    }
+    if (sheet.equals(_selectedSheet)) {
         final Focus focus = (Focus) event.getPayload();


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
        int xSum = 0;
        xSum += playerPaysXGenericMana(controller, source, game);
        for (UUID playerId : controller.getInRange()) {
            if (playerId != controller.getId()) {
                Player player = game.getPlayer(playerId);
                if (player != null) {
                    xSum += playerPaysXGenericMana(player, source, game);
                }
            }
        }
        if (xSum > 0) {
            for (UUID playerId : controller.getInRange()) {
                Effect effect = new PutTopCardOfLibraryIntoGraveTargetEffect(xSum);
                effect.setTargetPointer(new FixedTarget(playerId));
                effect.apply(game, source);
            }
        }
        controller.resetStoredBookmark(game);
        return true;
    }
    return false;
}

Output:
         xSum += playerPaysXGenericMana(controller, source, game);
-        for (UUID playerId : controller.getInRange()) {
+        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
             if (playerId != controller.getId()) {


Input:
final void dumpApplicationMemoryUsage(FileDescriptor fd, PrintWriter pw, String prefix, String[] args, boolean brief, PrintWriter categoryPw) {
    boolean dumpDetails = false;
    boolean dumpFullDetails = false;
    boolean dumpDalvik = false;
    boolean oomOnly = false;
    boolean isCompact = false;
    int opti = 0;
    while (opti < args.length) {
        String opt = args[opti];
        if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
            break;
        }
        opti++;
        if ("String_Node_Str".equals(opt)) {
            dumpDetails = true;
            dumpFullDetails = true;
            dumpDalvik = true;
        } else if ("String_Node_Str".equals(opt)) {
            dumpDalvik = true;
        } else if ("String_Node_Str".equals(opt)) {
            isCompact = true;
        } else if ("String_Node_Str".equals(opt)) {
            oomOnly = true;
        } else if ("String_Node_Str".equals(opt)) {
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            pw.println("String_Node_Str");
            return;
        } else {
            pw.println("String_Node_Str" + opt + "String_Node_Str");
        }
    }
    final boolean isCheckinRequest = scanArgs(args, "String_Node_Str");
    long uptime = SystemClock.uptimeMillis();
    long realtime = SystemClock.elapsedRealtime();
    final long[] tmpLong = new long[1];
    ArrayList<ProcessRecord> procs = collectProcesses(pw, opti, args);
    if (procs == null) {
        if (args != null && args.length > opti && args[opti].charAt(0) != '-') {
            ArrayList<ProcessCpuTracker.Stats> nativeProcs = new ArrayList<ProcessCpuTracker.Stats>();
            updateCpuStatsNow();
            int findPid = -1;
            try {
                findPid = Integer.parseInt(args[opti]);
            } catch (NumberFormatException e) {
            }
            synchronized (mProcessCpuThread) {
                final int N = mProcessCpuTracker.countStats();
                for (int i = 0; i < N; i++) {
                    ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
                    if (st.pid == findPid || (st.baseName != null && st.baseName.equals(args[opti]))) {
                        nativeProcs.add(st);
                    }
                }
            }
            if (nativeProcs.size() > 0) {
                dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, isCompact);
                Debug.MemoryInfo mi = null;
                for (int i = nativeProcs.size() - 1; i >= 0; i--) {
                    final ProcessCpuTracker.Stats r = nativeProcs.get(i);
                    final int pid = r.pid;
                    if (!isCheckinRequest && dumpDetails) {
                        pw.println("String_Node_Str" + pid + "String_Node_Str" + r.baseName + "String_Node_Str");
                    }
                    if (mi == null) {
                        mi = new Debug.MemoryInfo();
                    }
                    if (dumpDetails || (!brief && !oomOnly)) {
                        Debug.getMemoryInfo(pid, mi);
                    } else {
                        mi.dalvikPss = (int) Debug.getPss(pid, tmpLong);
                        mi.dalvikPrivateDirty = (int) tmpLong[0];
                    }
                    ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, pid, r.baseName, 0, 0, 0, 0, 0, 0);
                    if (isCheckinRequest) {
                        pw.println();
                    }
                }
                return;
            }
        }
        pw.println("String_Node_Str" + args[opti]);
        return;
    }
    if (!brief && !oomOnly && (procs.size() == 1 || isCheckinRequest)) {
        dumpDetails = true;
    }
    dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, isCompact);
    String[] innerArgs = new String[args.length - opti];
    System.arraycopy(args, opti, innerArgs, 0, args.length - opti);
    ArrayList<MemItem> procMems = new ArrayList<MemItem>();
    final SparseArray<MemItem> procMemsMap = new SparseArray<MemItem>();
    long nativePss = 0, dalvikPss = 0, otherPss = 0;
    long[] miscPss = new long[Debug.MemoryInfo.NUM_OTHER_STATS];
    long[] oomPss = new long[DUMP_MEM_OOM_LABEL.length];
    ArrayList<MemItem>[] oomProcs = (ArrayList<MemItem>[]) new ArrayList[DUMP_MEM_OOM_LABEL.length];
    long totalPss = 0;
    long cachedPss = 0;
    Debug.MemoryInfo mi = null;
    for (int i = procs.size() - 1; i >= 0; i--) {
        final ProcessRecord r = procs.get(i);
        final IApplicationThread thread;
        final int pid;
        final int oomAdj;
        final boolean hasActivities;
        synchronized (this) {
            thread = r.thread;
            pid = r.pid;
            oomAdj = r.getSetAdjWithServices();
            hasActivities = r.activities.size() > 0;
        }
        if (thread != null) {
            if (!isCheckinRequest && dumpDetails) {
                pw.println("String_Node_Str" + pid + "String_Node_Str" + r.processName + "String_Node_Str");
            }
            if (mi == null) {
                mi = new Debug.MemoryInfo();
            }
            if (dumpDetails || (!brief && !oomOnly)) {
                Debug.getMemoryInfo(pid, mi);
            } else {
                mi.dalvikPss = (int) Debug.getPss(pid, tmpLong);
                mi.dalvikPrivateDirty = (int) tmpLong[0];
            }
            if (dumpDetails) {
                try {
                    pw.flush();
                    thread.dumpMemInfo(fd, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, innerArgs);
                } catch (RemoteException e) {
                    if (!isCheckinRequest) {
                        pw.println("String_Node_Str");
                        pw.flush();
                    }
                }
            }
            final long myTotalPss = mi.getTotalPss();
            final long myTotalUss = mi.getTotalUss();
            synchronized (this) {
                if (r.thread != null && oomAdj == r.getSetAdjWithServices()) {
                    r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true, r.pkgList);
                }
            }
            if (!isCheckinRequest && mi != null) {
                totalPss += myTotalPss;
                MemItem pssItem = new MemItem(r.processName + "String_Node_Str" + pid + (hasActivities ? "String_Node_Str" : "String_Node_Str"), r.processName, myTotalPss, pid, hasActivities);
                procMems.add(pssItem);
                procMemsMap.put(pid, pssItem);
                nativePss += mi.nativePss;
                dalvikPss += mi.dalvikPss;
                otherPss += mi.otherPss;
                for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
                    long mem = mi.getOtherPss(j);
                    miscPss[j] += mem;
                    otherPss -= mem;
                }
                if (oomAdj >= ProcessList.CACHED_APP_MIN_ADJ) {
                    cachedPss += myTotalPss;
                }
                for (int oomIndex = 0; oomIndex < oomPss.length; oomIndex++) {
                    if (oomAdj <= DUMP_MEM_OOM_ADJ[oomIndex] || oomIndex == (oomPss.length - 1)) {
                        oomPss[oomIndex] += myTotalPss;
                        if (oomProcs[oomIndex] == null) {
                            oomProcs[oomIndex] = new ArrayList<MemItem>();
                        }
                        oomProcs[oomIndex].add(pssItem);
                        break;
                    }
                }
            }
        }
    }
    if (!isCheckinRequest && procs.size() > 1) {
        updateCpuStatsNow();
        synchronized (mProcessCpuThread) {
            final int N = mProcessCpuTracker.countStats();
            for (int i = 0; i < N; i++) {
                ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
                if (st.vsize > 0 && procMemsMap.indexOfKey(st.pid) < 0) {
                    if (mi == null) {
                        mi = new Debug.MemoryInfo();
                    }
                    if (!brief && !oomOnly) {
                        Debug.getMemoryInfo(st.pid, mi);
                    } else {
                        mi.nativePss = (int) Debug.getPss(st.pid, tmpLong);
                        mi.nativePrivateDirty = (int) tmpLong[0];
                    }
                    final long myTotalPss = mi.getTotalPss();
                    totalPss += myTotalPss;
                    MemItem pssItem = new MemItem(st.name + "String_Node_Str" + st.pid + "String_Node_Str", st.name, myTotalPss, st.pid, false);
                    procMems.add(pssItem);
                    nativePss += mi.nativePss;
                    dalvikPss += mi.dalvikPss;
                    otherPss += mi.otherPss;
                    for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
                        long mem = mi.getOtherPss(j);
                        miscPss[j] += mem;
                        otherPss -= mem;
                    }
                    oomPss[0] += myTotalPss;
                    if (oomProcs[0] == null) {
                        oomProcs[0] = new ArrayList<MemItem>();
                    }
                    oomProcs[0].add(pssItem);
                }
            }
        }
        ArrayList<MemItem> catMems = new ArrayList<MemItem>();
        catMems.add(new MemItem("String_Node_Str", "String_Node_Str", nativePss, -1));
        catMems.add(new MemItem("String_Node_Str", "String_Node_Str", dalvikPss, -2));
        catMems.add(new MemItem("String_Node_Str", "String_Node_Str", otherPss, -3));
        for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
            String label = Debug.MemoryInfo.getOtherLabel(j);
            catMems.add(new MemItem(label, label, miscPss[j], j));
        }
        ArrayList<MemItem> oomMems = new ArrayList<MemItem>();
        for (int j = 0; j < oomPss.length; j++) {
            if (oomPss[j] != 0) {
                String label = isCompact ? DUMP_MEM_OOM_COMPACT_LABEL[j] : DUMP_MEM_OOM_LABEL[j];
                MemItem item = new MemItem(label, label, oomPss[j], DUMP_MEM_OOM_ADJ[j]);
                item.subitems = oomProcs[j];
                oomMems.add(item);
            }
        }
        if (!brief && !oomOnly && !isCompact) {
            pw.println();
            pw.println("String_Node_Str");
            dumpMemItems(pw, "String_Node_Str", "String_Node_Str", procMems, true, isCompact);
            pw.println();
        }
        if (!isCompact) {
            pw.println("String_Node_Str");
        }
        dumpMemItems(pw, "String_Node_Str", "String_Node_Str", oomMems, false, isCompact);
        if (!brief && !oomOnly) {
            PrintWriter out = categoryPw != null ? categoryPw : pw;
            if (!isCompact) {
                out.println();
                out.println("String_Node_Str");
            }
            dumpMemItems(out, "String_Node_Str", "String_Node_Str", catMems, true, isCompact);
        }
        if (!isCompact) {
            pw.println();
        }
        MemInfoReader memInfo = new MemInfoReader();
        memInfo.readMemInfo();
        if (!brief) {
            if (!isCompact) {
                pw.print("String_Node_Str");
                pw.print(memInfo.getTotalSizeKb());
                pw.println("String_Node_Str");
                pw.print("String_Node_Str");
                pw.print(cachedPss + memInfo.getCachedSizeKb() + memInfo.getFreeSizeKb());
                pw.print("String_Node_Str");
                pw.print(cachedPss);
                pw.print("String_Node_Str");
                pw.print(memInfo.getCachedSizeKb());
                pw.print("String_Node_Str");
                pw.print(memInfo.getFreeSizeKb());
                pw.println("String_Node_Str");
            } else {
                pw.print("String_Node_Str");
                pw.print(memInfo.getTotalSizeKb());
                pw.print("String_Node_Str");
                pw.print(cachedPss + memInfo.getCachedSizeKb() + memInfo.getFreeSizeKb());
                pw.print("String_Node_Str");
                pw.println(totalPss - cachedPss);
            }
        }
        if (!isCompact) {
            pw.print("String_Node_Str");
            pw.print(totalPss - cachedPss + memInfo.getBuffersSizeKb() + memInfo.getShmemSizeKb() + memInfo.getSlabSizeKb());
            pw.print("String_Node_Str");
            pw.print(totalPss - cachedPss);
            pw.print("String_Node_Str");
            pw.print(memInfo.getBuffersSizeKb());
            pw.print("String_Node_Str");
            pw.print(memInfo.getShmemSizeKb());
            pw.print("String_Node_Str");
            pw.print(memInfo.getSlabSizeKb());
            pw.println("String_Node_Str");
            pw.print("String_Node_Str");
            pw.print(memInfo.getTotalSizeKb() - totalPss - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb() - memInfo.getBuffersSizeKb() - memInfo.getShmemSizeKb() - memInfo.getSlabSizeKb());
            pw.println("String_Node_Str");
        }
        if (!brief) {
            if (memInfo.getZramTotalSizeKb() != 0) {
                if (!isCompact) {
                    pw.print("String_Node_Str");
                    pw.print(memInfo.getZramTotalSizeKb());
                    pw.print("String_Node_Str");
                    pw.print(memInfo.getSwapTotalSizeKb() - memInfo.getSwapFreeSizeKb());
                    pw.print("String_Node_Str");
                    pw.print(memInfo.getSwapTotalSizeKb());
                    pw.println("String_Node_Str");
                } else {
                    pw.print("String_Node_Str");
                    pw.print(memInfo.getZramTotalSizeKb());
                    pw.print("String_Node_Str");
                    pw.print(memInfo.getSwapTotalSizeKb());
                    pw.print("String_Node_Str");
                    pw.println(memInfo.getSwapFreeSizeKb());
                }
            }
            final int[] SINGLE_LONG_FORMAT = new int[] { Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG };
            long[] longOut = new long[1];
            Process.readProcFile("String_Node_Str", SINGLE_LONG_FORMAT, null, longOut, null);
            long shared = longOut[0] * ProcessList.PAGE_SIZE / 1024;
            longOut[0] = 0;
            Process.readProcFile("String_Node_Str", SINGLE_LONG_FORMAT, null, longOut, null);
            long sharing = longOut[0] * ProcessList.PAGE_SIZE / 1024;
            longOut[0] = 0;
            Process.readProcFile("String_Node_Str", SINGLE_LONG_FORMAT, null, longOut, null);
            long unshared = longOut[0] * ProcessList.PAGE_SIZE / 1024;
            longOut[0] = 0;
            Process.readProcFile("String_Node_Str", SINGLE_LONG_FORMAT, null, longOut, null);
            long voltile = longOut[0] * ProcessList.PAGE_SIZE / 1024;
            if (!isCompact) {
                if (sharing != 0 || shared != 0 || unshared != 0 || voltile != 0) {
                    pw.print("String_Node_Str");
                    pw.print(sharing);
                    pw.print("String_Node_Str");
                    pw.print(shared);
                    pw.println("String_Node_Str");
                    pw.print("String_Node_Str");
                    pw.print(unshared);
                    pw.print("String_Node_Str");
                    pw.print(voltile);
                    pw.println("String_Node_Str");
                }
                pw.print("String_Node_Str");
                pw.print(ActivityManager.staticGetMemoryClass());
                pw.print("String_Node_Str");
                pw.print(ActivityManager.staticGetLargeMemoryClass());
                pw.print("String_Node_Str");
                pw.print(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ) / 1024);
                pw.print("String_Node_Str");
                pw.print("String_Node_Str");
                pw.print(mProcessList.getCachedRestoreThresholdKb());
                pw.print("String_Node_Str");
                if (ActivityManager.isLowRamDeviceStatic()) {
                    pw.print("String_Node_Str");
                }
                if (ActivityManager.isHighEndGfx()) {
                    pw.print("String_Node_Str");
                }
                pw.println();
            } else {
                pw.print("String_Node_Str");
                pw.print(sharing);
                pw.print("String_Node_Str");
                pw.print(shared);
                pw.print("String_Node_Str");
                pw.print(unshared);
                pw.print("String_Node_Str");
                pw.println(voltile);
                pw.print("String_Node_Str");
                pw.print(ActivityManager.staticGetMemoryClass());
                pw.print(',');
                pw.print(ActivityManager.staticGetLargeMemoryClass());
                pw.print(',');
                pw.print(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ) / 1024);
                if (ActivityManager.isLowRamDeviceStatic()) {
                    pw.print("String_Node_Str");
                }
                if (ActivityManager.isHighEndGfx()) {
                    pw.print("String_Node_Str");
                }
                pw.println();
            }
        }
    }
}

Output:
             if (dumpDetails) {
-                try {
-                    pw.flush();
-                    thread.dumpMemInfo(fd, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, innerArgs);
-                } catch (RemoteException e) {
-                    if (!isCheckinRequest) {
-                        pw.println("String_Node_Str");
+                if (localOnly) {
+                    ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, pid, r.processName, 0, 0, 0, 0, 0, 0);
+                    if (isCheckinRequest) {
+                        pw.println();
+                    }
+                } else {
+                    try {
                         pw.flush();


Input:
protected void displayTableAndViewComp(final SchemaIndicator schemaIndicator) {
    tableAndViewComposite.setVisible(true);
    List<TableIndicator> indicatorTableList = (List<TableIndicator>) schemaIndicator.getTableIndicators();
    if (tableOfCatalogOrSchemaViewer == null) {
        tableOfCatalogOrSchemaViewer = new TableViewer(tableAndViewComposite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.SINGLE);
        final Table catalogOrSchemaTable = tableOfCatalogOrSchemaViewer.getTable();
        catalogOrSchemaTable.setHeaderVisible(true);
        catalogOrSchemaTable.setLinesVisible(true);
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
        layoutData.heightHint = 150;
        catalogOrSchemaTable.setLayoutData(layoutData);
        String[] columnTexts = new String[] { DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str") };
        createSorterColumns(tableOfCatalogOrSchemaViewer, columnTexts, tableSorters, COLUMN_TABLE_WIDTH);
        TableOfCatalogOrSchemaProvider providerTable = new TableOfCatalogOrSchemaProvider();
        tableOfCatalogOrSchemaViewer.setLabelProvider(providerTable);
        tableOfCatalogOrSchemaViewer.setContentProvider(providerTable);
        final TableCursor cursor = new TableCursor(catalogOrSchemaTable, SWT.NONE);
        cursor.setBackground(catalogOrSchemaTable.getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION));
        cursor.setForeground(catalogOrSchemaTable.getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION_TEXT));
        cursor.setLayout(new FillLayout());
        final Menu menu = new Menu(catalogOrSchemaTable);
        MenuItem keyitem = new MenuItem(menu, SWT.PUSH);
        keyitem.setText(DefaultMessagesImpl.getString("String_Node_Str"));
        keyitem.setImage(ImageLib.getImage(ImageLib.PK_DECORATE));
        final Menu menu1 = new Menu(catalogOrSchemaTable);
        MenuItem indexitem = new MenuItem(menu1, SWT.PUSH);
        indexitem.setText(DefaultMessagesImpl.getString("String_Node_Str"));
        indexitem.setImage(ImageLib.getImage(ImageLib.INDEX_VIEW));
        keyitem.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                TableItem tableItem = cursor.getRow();
                String tableName = tableItem.getText(0);
                Package parentPack = (Package) currentSelectionSchemaIndicator.getAnalyzedElement();
                TypedReturnCode<TdProviderConnection> tdPc = DataProviderHelper.getTdProviderConnection(tdDataProvider);
                TdProviderConnection providerConnection = tdPc.getObject();
                TypedReturnCode<TableNode> findSqlExplorerTableNode = SqlExplorerBridge.findSqlExplorerTableNode(providerConnection, parentPack, tableName, Messages.getString("String_Node_Str"));
                if (!findSqlExplorerTableNode.isOk()) {
                    log.error(findSqlExplorerTableNode.getMessage());
                }
            }
        });
        cursor.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                int column = cursor.getColumn();
                if (column == VIEW_COLUMN_INDEX) {
                    cursor.setMenu(menu);
                    menu.setVisible(true);
                } else {
                    cursor.setMenu(null);
                }
            }
        });
        indexitem.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                TableItem tableItem = cursor.getRow();
                String tableName = tableItem.getText(0);
                Package parentPack = (Package) currentSelectionSchemaIndicator.getAnalyzedElement();
                TypedReturnCode<TdProviderConnection> tdPc = DataProviderHelper.getTdProviderConnection(tdDataProvider);
                TdProviderConnection providerConnection = tdPc.getObject();
                TypedReturnCode<TableNode> findSqlExplorerTableNode = SqlExplorerBridge.findSqlExplorerTableNode(providerConnection, parentPack, tableName, Messages.getString("String_Node_Str"));
                if (!findSqlExplorerTableNode.isOk()) {
                    log.error(findSqlExplorerTableNode.getMessage());
                }
            }
        });
        cursor.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                int column = cursor.getColumn();
                if (column == VIEW_COLUMN_INDEXES) {
                    cursor.setMenu(menu1);
                    menu1.setVisible(true);
                } else {
                    cursor.setMenu(null);
                }
            }
        });
        viewOfCatalogOrSchemaViewer = new TableViewer(tableAndViewComposite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION);
        Table tableCatalogOrSchemaView = viewOfCatalogOrSchemaViewer.getTable();
        tableCatalogOrSchemaView.setHeaderVisible(true);
        tableCatalogOrSchemaView.setLinesVisible(true);
        layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
        layoutData.heightHint = 150;
        tableCatalogOrSchemaView.setLayoutData(layoutData);
        columnTexts = new String[] { DefaultMessagesImpl.getString("String_Node_Str"), DefaultMessagesImpl.getString("String_Node_Str") };
        createSorterColumns(viewOfCatalogOrSchemaViewer, columnTexts, viewSorters, COLUMN_VIEW_WIDTH);
        ViewOfCatalogOrSchemaProvider viewProvider = new ViewOfCatalogOrSchemaProvider();
        viewOfCatalogOrSchemaViewer.setLabelProvider(viewProvider);
        viewOfCatalogOrSchemaViewer.setContentProvider(viewProvider);
    }
    tableOfCatalogOrSchemaViewer.getTable().setMenu(null);
    tableOfCatalogOrSchemaViewer.setInput(indicatorTableList);
    List<ViewIndicator> indicatorViewList = (List<ViewIndicator>) schemaIndicator.getViewIndicators();
    viewOfCatalogOrSchemaViewer.setInput(indicatorViewList);
    tableAndViewComposite.layout();
    form.reflow(true);
}

Output:
     viewOfCatalogOrSchemaViewer.setInput(indicatorViewList);
-    tableAndViewComposite.layout();
+    tableAndViewComposite.pack();
+    statisticalSection.pack();
+    statisticalSection.layout();
     form.reflow(true);


Input:
protected void saveProject() {
    File output = getSelectedOutputFile(ZIP_FILTER);
    if (output != null) {
        Appender app = Logger.getRootLogger().getAppender("String_Node_Str");
        String logFile = null;
        if (app instanceof FileAppender && app != null) {
            logFile = ((FileAppender) app).getFile();
        } else {
            logger.error("String_Node_Str");
        }
        ZipProject zp = new ZipProject(indatafile, inlabelsfile, inpointsfile, logFile);
        try {
            if (new File(output.getCanonicalPath()).exists()) {
                new File(output.getCanonicalPath()).delete();
            }
            zp.saveTo(output.getCanonicalPath());
        } catch (IOException e) {
            logger.error(e, e);
            JOptionPane.showMessageDialog(this, e.getMessage(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        }
    }
}

Output:
     File output = getSelectedOutputFile(ZIP_FILTER);
-    if (output != null) {
+    if (output != null && !output.equals("String_Node_Str")) {
         Appender app = Logger.getRootLogger().getAppender("String_Node_Str");


Input:
public synchronized void setIcon(final String iconName) {
    libgtk.gdk_threads_enter();
    libgtk.gtk_status_icon_set_from_file(trayIcon, iconPath(iconName));
    libgtk.gdk_threads_leave();
}

Output:
 public synchronized void setIcon(final String iconName) {
-    libgtk.gdk_threads_enter();
-    libgtk.gtk_status_icon_set_from_file(trayIcon, iconPath(iconName));
-    libgtk.gdk_threads_leave();
+    gtk.gdk_threads_enter();
+    gtk.gtk_status_icon_set_from_file(trayIcon, iconPath(iconName));
+    gtk.gdk_threads_leave();
 }


Input:
private boolean containsTableInSchema(String schemaName) {
    ResultSet rs = metaDataProvider.getAlltables(metaDataProvider.getCatalog(), schemaName, "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str" });
    boolean hasNonSystemTable = false;
    if (rs != null) {
        try {
            while (rs.next()) {
                if (!"String_Node_Str".equalsIgnoreCase(rs.getString("String_Node_Str"))) {
                    hasNonSystemTable = true;
                    break;
                }
            }
        } catch (SQLException e) {
            logger.log(Level.FINE, e.getMessage(), e);
        }
    }
    if (hasNonSystemTable) {
        return true;
    } else {
        return false;
    }
}

Output:
             while (rs.next()) {
-                if (!"String_Node_Str".equalsIgnoreCase(rs.getString("String_Node_Str"))) {
-                    hasNonSystemTable = true;
-                    break;
-                }
+                return true;
             }


Input:
private void updateSuggestion() {
    if (matchedBoards.isEmpty() || matchedBoards.size() == boards.size()) {
        suggestion = Optional.empty();
    } else {
        suggestion = matchedBoards.stream().min(String::compareToIgnoreCase);
    }
}

Output:
 private void updateSuggestion() {
-    if (matchedBoards.isEmpty() || matchedBoards.size() == boards.size()) {
+    if (matchedBoards.isEmpty() || (matchedBoards.size() == boards.size() && boards.size() != 1)) {
         suggestion = Optional.empty();


Input:
private void addMenuOnGantChart(ChartEntity chartEntity, Menu menu) {
    CategoryItemEntity itemEntity = (CategoryItemEntity) chartEntity;
    String seriesK = itemEntity.getRowKey().toString();
    String seriesLabel = itemEntity.getColumnKey().toString();
    EList<Column> nominalList = indicator.getNominalColumns();
    final String sql = MultiColumnSetValueExplorer.getInstance().getQueryStirng(column, analysis, nominalList, seriesK, seriesLabel);
    MenuItem item = new MenuItem(menu, SWT.PUSH);
    item.setText("String_Node_Str");
    item.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            Display.getDefault().asyncExec(new Runnable() {
                public void run() {
                    TdDataProvider tdDataProvider = SwitchHelpers.TDDATAPROVIDER_SWITCH.doSwitch(analysis.getContext().getConnection());
                    String query = sql;
                    String editorName = ColumnHelper.getColumnSetOwner(column).getName();
                    CorePlugin.getDefault().runInDQViewer(tdDataProvider, query, editorName);
                }
            });
        }
    });
}

Output:
             Display.getDefault().asyncExec(new Runnable() {
-                public void run() {
-                    TdDataProvider tdDataProvider = SwitchHelpers.TDDATAPROVIDER_SWITCH.doSwitch(analysis.getContext().getConnection());
-                    String query = sql;
-                    String editorName = ColumnHelper.getColumnSetOwner(column).getName();
-                    CorePlugin.getDefault().runInDQViewer(tdDataProvider, query, editorName);
-                }
-            });
-        }
-    });
+                    public void run() {
+                        TdDataProvider tdDataProvider = SwitchHelpers.TDDATAPROVIDER_SWITCH.doSwitch(analysis.getContext().getConnection());
+                        String query = sql;
+                        String editorName = ColumnHelper.getColumnSetOwner(column).getName();
+                        CorePlugin.getDefault().runInDQViewer(tdDataProvider, query, editorName);
+                    }
+                });
+            }
+        });
+    }
 }


Input:
public static byte[] createThumbnailFromUri(Context context, Uri imageUri, int maxWidth, String fileExtension, int rotation) {
    if (context == null || imageUri == null)
        return null;
    String filePath = null;
    if (imageUri.toString().contains("String_Node_Str")) {
        String[] projection = new String[] { MediaStore.Images.Media.DATA };
        Cursor cur = context.getContentResolver().query(imageUri, projection, null, null, null);
        if (cur != null) {
            if (cur.moveToFirst()) {
                int dataColumn = cur.getColumnIndex(MediaStore.Images.Media.DATA);
                filePath = cur.getString(dataColumn);
            }
            cur.close();
        }
    }
    if (TextUtils.isEmpty(filePath)) {
        filePath = imageUri.toString().replace("String_Node_Str", "String_Node_Str");
        filePath = filePath.replace("String_Node_Str", "String_Node_Str");
    }
    BitmapFactory.Options optBounds = new BitmapFactory.Options();
    optBounds.inJustDecodeBounds = true;
    try {
        BitmapFactory.decodeFile(filePath, optBounds);
    } catch (OutOfMemoryError e) {
        CrashlyticsUtils.logException(e, CrashlyticsUtils.ExceptionType.SPECIFIC, AppLog.T.UTILS);
        return null;
    }
    int scale = 1;
    if (maxWidth > 0 && optBounds.outWidth > maxWidth) {
        double d = Math.pow(2, (int) Math.round(Math.log(maxWidth / (double) optBounds.outWidth) / Math.log(0.5)));
        scale = (int) d;
    }
    BitmapFactory.Options optActual = new BitmapFactory.Options();
    optActual.inSampleSize = scale;
    Bitmap bmpResized;
    try {
        bmpResized = BitmapFactory.decodeFile(filePath, optActual);
    } catch (OutOfMemoryError e) {
        CrashlyticsUtils.setFloat(CrashlyticsUtils.ExtraKey.IMAGE_RESIZE_SCALE, scale);
        CrashlyticsUtils.logException(e, CrashlyticsUtils.ExceptionType.SPECIFIC, AppLog.T.UTILS);
        return null;
    }
    if (bmpResized == null)
        return null;
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    float percentage = (float) maxWidth / bmpResized.getWidth();
    float proportionateHeight = bmpResized.getHeight() * percentage;
    int finalHeight = (int) Math.rint(proportionateHeight);
    float scaleWidth = ((float) maxWidth) / bmpResized.getWidth();
    float scaleHeight = ((float) finalHeight) / bmpResized.getHeight();
    float scaleBy = Math.min(scaleWidth, scaleHeight);
    Matrix matrix = new Matrix();
    matrix.postScale(scaleBy, scaleBy);
    if (rotation != 0) {
        matrix.setRotate(rotation);
    }
    Bitmap.CompressFormat fmt;
    if (fileExtension != null && fileExtension.equalsIgnoreCase("String_Node_Str")) {
        fmt = Bitmap.CompressFormat.PNG;
    } else {
        fmt = Bitmap.CompressFormat.JPEG;
    }
    final Bitmap bmpRotated;
    try {
        bmpRotated = Bitmap.createBitmap(bmpResized, 0, 0, bmpResized.getWidth(), bmpResized.getHeight(), matrix, true);
    } catch (OutOfMemoryError e) {
        CrashlyticsUtils.setInt(CrashlyticsUtils.ExtraKey.IMAGE_ANGLE, rotation);
        CrashlyticsUtils.setInt(CrashlyticsUtils.ExtraKey.IMAGE_WIDTH, bmpResized.getWidth());
        CrashlyticsUtils.setInt(CrashlyticsUtils.ExtraKey.IMAGE_HEIGHT, bmpResized.getHeight());
        CrashlyticsUtils.setFloat(CrashlyticsUtils.ExtraKey.IMAGE_RESIZE_SCALE, scaleBy);
        CrashlyticsUtils.logException(e, CrashlyticsUtils.ExceptionType.SPECIFIC, AppLog.T.UTILS);
        return null;
    }
    bmpRotated.compress(fmt, 100, stream);
    bmpResized.recycle();
    bmpRotated.recycle();
    return stream.toByteArray();
}

Output:
 public static byte[] createThumbnailFromUri(Context context, Uri imageUri, int maxWidth, String fileExtension, int rotation) {
-    if (context == null || imageUri == null)
+    if (context == null || imageUri == null || maxWidth <= 0)
         return null;


Input:
private File getFileForExtraHash(String taskID, StringBuilder dir, Properties meta, String extraHash) {
    dir.append(meta.get(COMMON.METRICS_PROPERTIES_KEY));
    File dir1 = new File(dir.toString());
    dir1.mkdirs();
    String fileName = "String_Node_Str";
    if (extraHash.length() != 0) {
        fileName = extraHash.toString();
    } else {
        fileName = meta.get(COMMON.METRICS_PROPERTIES_KEY).toString();
    }
    File f = new File(dir.toString() + File.separator + fileName + SUFFIX);
    return f;
}

Output:
     if (extraHash.length() != 0) {
-        fileName = extraHash.toString();
+        fileName = extraHash;
     } else {


Input:
public void saveRelations() {
    if (!loaded && !modified) {
        return;
    }
    Project currentProject = getAimProject();
    currentProject.getEmfProject().getItemsRelations().clear();
    for (Relation relation : currentProjectItemsRelations.keySet()) {
        ItemRelations itemRelations = PropertiesFactory.eINSTANCE.createItemRelations();
        ItemRelation baseItem = PropertiesFactory.eINSTANCE.createItemRelation();
        itemRelations.setBaseItem(baseItem);
        baseItem.setId(relation.getId());
        baseItem.setType(relation.getType());
        baseItem.setVersion(relation.getVersion());
        List<Relation> relationItemsList = new ArrayList<Relation>(currentProjectItemsRelations.get(relation));
        Collections.sort(relationItemsList, new Comparator<Relation>() {
            public int compare(Relation o1, Relation o2) {
                return o1.getType().compareTo(o2.getType());
            }
        });
        for (Relation relatedItem : relationItemsList) {
            ItemRelation emfRelatedItem = PropertiesFactory.eINSTANCE.createItemRelation();
            emfRelatedItem.setId(relatedItem.getId());
            emfRelatedItem.setType(relatedItem.getType());
            emfRelatedItem.setVersion(relatedItem.getVersion());
            itemRelations.getRelatedItems().add(emfRelatedItem);
        }
        currentProject.getEmfProject().getItemsRelations().add(itemRelations);
    }
    try {
        getProxyRepositoryFactory().saveProject(currentProject);
    } catch (PersistenceException e) {
        ExceptionHandler.process(e);
    }
    modified = false;
}

Output:
     Project currentProject = getAimProject();
-    currentProject.getEmfProject().getItemsRelations().clear();
+    List<ItemRelations> oldRelations = new ArrayList<ItemRelations>(currentProject.getEmfProject().getItemsRelations());
+    List<ItemRelations> usedList = new ArrayList<ItemRelations>();
     for (Relation relation : currentProjectItemsRelations.keySet()) {


Input:
public boolean resolve(Game game) {
    boolean result;
    if (card.getCardType().contains(CardType.INSTANT) || card.getCardType().contains(CardType.SORCERY)) {
        int index = 0;
        result = false;
        boolean legalParts = false;
        for (SpellAbility spellAbility : this.spellAbilities) {
            for (UUID modeId : spellAbility.getModes().getSelectedModes()) {
                spellAbility.getModes().setMode(spellAbility.getModes().get(modeId));
                if (spellAbility.getTargets().stillLegal(spellAbility, game)) {
                    legalParts = true;
                    if (!spellAbility.getSpellAbilityType().equals(SpellAbilityType.SPLICE)) {
                        updateOptionalCosts(index);
                    }
                    result |= spellAbility.resolve(game);
                }
            }
            index++;
        }
        if (legalParts) {
            if (!copiedSpell) {
                for (Effect effect : ability.getEffects()) {
                    if (effect instanceof PostResolveEffect) {
                        ((PostResolveEffect) effect).postResolve(card, ability, controllerId, game);
                        return result;
                    }
                }
                if (!card.isCopy() && game.getState().getZone(card.getId()) == Zone.STACK) {
                    card.moveToZone(Zone.GRAVEYARD, ability.getId(), game, false);
                }
            }
            return result;
        }
        game.informPlayers(getName() + "String_Node_Str");
        counter(null, game);
        return false;
    } else if (card.getCardType().contains(CardType.ENCHANTMENT) && card.getSubtype().contains("String_Node_Str")) {
        if (ability.getTargets().stillLegal(ability, game)) {
            updateOptionalCosts(0);
            if (card.putOntoBattlefield(game, Zone.HAND, ability.getId(), controllerId)) {
                return ability.resolve(game);
            }
            return false;
        }
        if (card.getCardType().contains(CardType.CREATURE)) {
            updateOptionalCosts(0);
            result = card.putOntoBattlefield(game, Zone.HAND, ability.getId(), controllerId);
            return result;
        } else {
            game.informPlayers(getName() + "String_Node_Str");
            counter(null, game);
            return false;
        }
    } else {
        updateOptionalCosts(0);
        result = card.putOntoBattlefield(game, Zone.HAND, ability.getId(), controllerId);
        return result;
    }
}

Output:
     boolean result;
-    if (card.getCardType().contains(CardType.INSTANT) || card.getCardType().contains(CardType.SORCERY)) {
+    if (this.getCardType().contains(CardType.INSTANT) || this.getCardType().contains(CardType.SORCERY)) {
         int index = 0;


Input:
public long getWorkingDuration(long from, long to) {
    long ret = 0;
    if (to > from) {
        java.util.Calendar fromDateTime = createCalendar(from);
        do {
            WorkingDay wd = findWorkingDay(fromDateTime);
            if (wd != null) {
                if (!isExcluded(fromDateTime)) {
                    if (wd.getStartHour() > fromDateTime.get(java.util.Calendar.HOUR_OF_DAY)) {
                        fromDateTime.set(java.util.Calendar.HOUR_OF_DAY, wd.getStartHour());
                        fromDateTime.set(java.util.Calendar.MINUTE, wd.getStartMinute());
                    } else if (wd.getStartHour() == fromDateTime.get(java.util.Calendar.HOUR_OF_DAY) && wd.getStartMinute() > fromDateTime.get(java.util.Calendar.MINUTE)) {
                        fromDateTime.set(java.util.Calendar.MINUTE, wd.getStartMinute());
                    }
                    long startOfDay = fromDateTime.getTimeInMillis();
                    fromDateTime.set(java.util.Calendar.HOUR_OF_DAY, wd.getEndHour());
                    fromDateTime.set(java.util.Calendar.MINUTE, wd.getEndMinute());
                    long endOfDay = fromDateTime.getTimeInMillis();
                    if (endOfDay > to) {
                        endOfDay = to;
                    }
                    ret += (endOfDay - startOfDay);
                }
            }
            fromDateTime = createCalendar(fromDateTime.getTimeInMillis() + (24 * 60 * 60 * 1000));
            fromDateTime.set(java.util.Calendar.HOUR_OF_DAY, 0);
            fromDateTime.set(java.util.Calendar.MINUTE, 0);
        } while (fromDateTime.getTimeInMillis() < to);
    }
    return (ret);
}

Output:
             }
-            fromDateTime = createCalendar(fromDateTime.getTimeInMillis() + (24 * 60 * 60 * 1000));
+            fromDateTime.set(java.util.Calendar.DAY_OF_MONTH, fromDateTime.get(java.util.Calendar.DAY_OF_MONTH) + 1);
             fromDateTime.set(java.util.Calendar.HOUR_OF_DAY, 0);


Input:
public void testMarshalInvalidObject() {
    StringWriter writer = new StringWriter();
    try {
        marshaller.marshal(new Car(), writer);
    } catch (MarshalException marshalException) {
        Throwable linkedException = marshalException.getLinkedException();
        assertTrue("String_Node_Str", linkedException instanceof XMLMarshalException);
        assertTrue("String_Node_Str", ((XMLMarshalException) linkedException).getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT);
        return;
    } catch (Exception e) {
        log(e.getMessage());
        assertTrue("String_Node_Str", false);
    }
    assertTrue("String_Node_Str", false);
}

Output:
         marshaller.marshal(new Car(), writer);
-    } catch (MarshalException marshalException) {
-        Throwable linkedException = marshalException.getLinkedException();
-        assertTrue("String_Node_Str", linkedException instanceof XMLMarshalException);
-        assertTrue("String_Node_Str", ((XMLMarshalException) linkedException).getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT);
+    } catch (JAXBException jaxbex) {
+        Throwable internalException = jaxbex.getInternalException();
+        assertTrue("String_Node_Str", internalException instanceof XMLMarshalException);
+        assertTrue("String_Node_Str", ((XMLMarshalException) internalException).getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT);
         return;


Input:
public void testGetBlob1() throws Exception {
    expect(mockStore.openHDFSConnection()).andReturn(mockFs);
    expect(mockStore.getId()).andReturn(new URI("String_Node_Str")).times(3);
    replay(mockStore, mockFs);
    HDFSBlobStoreConnection connection = createTestConnection();
    HDFSBlob b = (HDFSBlob) connection.getBlob(new URI("String_Node_Str"), null);
    assertNotNull(b);
    assertTrue(b.getConnection() == connection);
}

Output:
 public void testGetBlob1() throws Exception {
-    expect(mockStore.openHDFSConnection()).andReturn(mockFs);
-    expect(mockStore.getId()).andReturn(new URI("String_Node_Str")).times(3);
+    expect(mockStore.getFilesystem()).andReturn(mockFs);
+    expect(mockStore.getId()).andReturn(mockId).times(3);
     replay(mockStore, mockFs);


Input:
public void run() {
    int savedWidth = sharedPrefs.getInt(WALLPAPER_WIDTH_KEY, defaultWallpaperSize.x);
    int savedHeight = sharedPrefs.getInt(WALLPAPER_HEIGHT_KEY, defaultWallpaperSize.y);
    wallpaperManager.suggestDesiredDimensions(savedWidth, savedHeight);
}

Output:
 public void run() {
-    int savedWidth = sharedPrefs.getInt(WALLPAPER_WIDTH_KEY, defaultWallpaperSize.x);
-    int savedHeight = sharedPrefs.getInt(WALLPAPER_HEIGHT_KEY, defaultWallpaperSize.y);
-    wallpaperManager.suggestDesiredDimensions(savedWidth, savedHeight);
+    updateWallpaperDimensions(outWidth, outHeight);
+    if (finishActivityWhenDone) {
+        setResult(Activity.RESULT_OK);
+        finish();
+    }
 }


Input:
private void buildTypeHeader(StringBuffer html, String packageName) {
    logger.entering("String_Node_Str", "String_Node_Str", html);
    int count = packageName.replaceAll("String_Node_Str", "String_Node_Str").length();
    String str = "String_Node_Str";
    for (int i = 0; i < count + 1; i++) {
        str += "String_Node_Str";
    }
    html.append(HtmlUtils.getAnchorTag(null, str + "String_Node_Str", null, "String_Node_Str") + Constants.NBSP_TWICE);
    html.append(HtmlUtils.getAnchorTag(null, "String_Node_Str", null, "String_Node_Str") + Constants.NBSP_TWICE);
    html.append(HtmlUtils.getAnchorTag(null, "String_Node_Str", null, "String_Node_Str"));
    html.append(Constants.HTML_HR);
    html.append(HtmlUtils.getAnchorTag("String_Node_Str", null, null, null));
    html.append(getTableTagWithStyle("String_Node_Str"));
    html.append(getTableRowTagWithStyle("String_Node_Str"));
    html.append(getTableDataTagWithStyle("String_Node_Str"));
    html.append("String_Node_Str");
    html.append(HtmlUtils.getAnchorTag(null, "String_Node_Str", "String_Node_Str", "String_Node_Str"));
    html.append(Constants.HTML_TABLE_TD_END);
    html.append(getTableDataTagWithStyle("String_Node_Str"));
    html.append("String_Node_Str");
    html.append(HtmlUtils.getAnchorTag(null, "String_Node_Str", "String_Node_Str", "String_Node_Str"));
    html.append(Constants.HTML_TABLE_TD_END);
    html.append(Constants.HTML_TABLE_TR_END);
    html.append(Constants.HTML_TABLE_END);
    html.append(Constants.HTML_HR);
    logger.exiting("String_Node_Str", "String_Node_Str", html);
}

Output:
     logger.entering("String_Node_Str", "String_Node_Str", html);
-    int count = packageName.replaceAll("String_Node_Str", "String_Node_Str").length();
-    String str = "String_Node_Str";
-    for (int i = 0; i < count + 1; i++) {
-        str += "String_Node_Str";
+    String relPath = "String_Node_Str";
+    String[] folders = currentPackageName.split("String_Node_Str");
+    for (String folder : folders) {
+        relPath = relPath + "String_Node_Str";
     }


Input:
void doGet(long timeoutMillis) {
    long remainingMillis = timeoutMillis;
    try {
        for (MemberCall memberCall : lsMemberCalls) {
            long now = System.currentTimeMillis();
            if (timeoutMillis == -1) {
                memberCall.get();
            } else {
                if (remainingMillis < 0) {
                    innerFutureTask.innerSetException(new TimeoutException());
                    return;
                }
                memberCall.get(remainingMillis, TimeUnit.MILLISECONDS);
            }
            remainingMillis -= (System.currentTimeMillis() - now);
        }
    } catch (Exception e) {
        e.printStackTrace();
        innerFutureTask.innerSetException(e);
    } finally {
        innerFutureTask.innerDone();
    }
}

Output:
                 if (remainingMillis < 0) {
-                    innerFutureTask.innerSetException(new TimeoutException());
+                    done = false;
+                    innerFutureTask.innerSetException(new TimeoutException(), done);
                     return;


Input:
public void processCommand(ICommandSender commandSender, String[] args) {
    if (args.length > 0) {
        String commandName = args[0];
        System.arraycopy(args, 1, args, 0, args.length - 1);
        if (commandName.toLowerCase().equals("String_Node_Str")) {
            CommandOverlay.processCommand(commandSender, args);
        } else if (commandName.toLowerCase().equals("String_Node_Str")) {
            CommandParticles.processCommand(commandSender, args);
        } else if (commandName.toLowerCase().equals("String_Node_Str")) {
            CommandSounds.processCommand(commandSender, args);
        }
    } else {
        throw new WrongUsageException("String_Node_Str", new Object[0]);
    }
}

Output:
         System.arraycopy(args, 1, args, 0, args.length - 1);
-        if (commandName.toLowerCase().equals("String_Node_Str")) {
+        if (commandName.equalsIgnoreCase(getLocalizedString(COMMAND_OVERLAY))) {
             CommandOverlay.processCommand(commandSender, args);


Input:
public void onPlayerMove(PlayerMoveEvent event) {
    MVPlayerSession ps = this.plugin.core.getPlayerSession(event.getPlayer());
    if (ps != null && ps.isStaleLocation()) {
        return;
    }
    MVPortal portal = this.plugin.getPortalUtils().isPortal(event.getPlayer(), event.getTo());
    if (portal != null) {
        System.out.print("String_Node_Str" + portal);
        Destination d = portal.getDestination();
        Location l = null;
        if (d.getType() == DestinationType.World) {
            if (this.plugin.core.isMVWorld(d.getName())) {
                MVWorld w = this.plugin.core.getMVWorld(d.getName());
                l = w.getCBWorld().getSpawnLocation();
            } else if (this.plugin.getServer().getWorld(d.getName()) != null) {
                l = this.plugin.getServer().getWorld(d.getName()).getSpawnLocation();
            }
        } else if (d.getType() == DestinationType.Portal) {
        }
        if (l == null) {
            return;
        }
        event.getPlayer().teleport(l);
    }
}

Output:
     MVPortal portal = this.plugin.getPortalUtils().isPortal(event.getPlayer(), event.getTo());
-    if (portal != null) {
-        System.out.print("String_Node_Str" + portal);
+    if (portal != null && !this.showDebugInfo(event.getPlayer(), portal)) {
         Destination d = portal.getDestination();


Input:
protected boolean fromCache() throws DataException {
    if (queryDefn.getQueryExecutionHints().enablePushDown()) {
        if (querySpec != null && querySpec.getResultSetSpecification() != null && !querySpec.getResultSetSpecification().isEmpty()) {
            if (appContext.get(DataEngine.QUERY_EXECUTION_SESSION_ID) == null) {
                dataEngine.getSession().getDataSetCacheManager().clearCache(dataEngine.getDataSourceDesign(this.dataSet.getDesign().getDataSourceName()), this.dataSet.getDesign());
            }
        }
    }
    return super.fromCache();
}

Output:
         if (querySpec != null && querySpec.getResultSetSpecification() != null && !querySpec.getResultSetSpecification().isEmpty()) {
-            if (appContext.get(DataEngine.QUERY_EXECUTION_SESSION_ID) == null) {
+            if (!CacheIDFetcher.getInstance().enableSampleDataPreivew(appContext)) {
                 dataEngine.getSession().getDataSetCacheManager().clearCache(dataEngine.getDataSourceDesign(this.dataSet.getDesign().getDataSourceName()), this.dataSet.getDesign());


Input:
public static List<ITestDataCubePO> computeReuser(IParameterInterfacePO tdc, EntityManager session) {
    CriteriaBuilder builder = session.getCriteriaBuilder();
    CriteriaQuery query = builder.createQuery();
    Root from = query.from(PoMaker.getTestDataCubeClass());
    query.select(from).where(builder.isNotNull(from.get("String_Node_Str")));
    List<ITestDataCubePO> queryResult = session.createQuery(query).getResultList();
    List<ITestDataCubePO> result = new ArrayList<ITestDataCubePO>();
    for (ITestDataCubePO pio : queryResult) {
        if (areEqual(pio.getReferencedDataCube(), tdc)) {
            result.add(pio);
        }
    }
    return result;
}

Output:
     Root from = query.from(PoMaker.getTestDataCubeClass());
-    query.select(from).where(builder.isNotNull(from.get("String_Node_Str")));
+    query.select(from).where(builder.and(builder.isNotNull(from.get("String_Node_Str")), builder.equal(from.get("String_Node_Str"), tdc.getParentProjectId())));
     List<ITestDataCubePO> queryResult = session.createQuery(query).getResultList();


Input:
public void transferredResourceDeleted(String transferredResourceID) {
    boolean forceCommit = false;
    deleteDocumentFromIndex(RodaConstants.INDEX_TRANSFERRED_RESOURCE, transferredResourceID, "String_Node_Str" + transferredResourceID + "String_Node_Str", forceCommit);
}

Output:
 public void transferredResourceDeleted(String transferredResourceID) {
-    boolean forceCommit = false;
-    deleteDocumentFromIndex(RodaConstants.INDEX_TRANSFERRED_RESOURCE, transferredResourceID, "String_Node_Str" + transferredResourceID + "String_Node_Str", forceCommit);
+    deleteDocumentFromIndex(RodaConstants.INDEX_TRANSFERRED_RESOURCE, transferredResourceID, "String_Node_Str" + transferredResourceID + "String_Node_Str");
 }


Input:
public static final EasySOAApiFraSCAti getInstance() {
    if (instance == null) {
        try {
            instance = new EasySOAApiFraSCAti();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
    return instance;
}

Output:
     if (instance == null) {
-        try {
-            instance = new EasySOAApiFraSCAti();
-        } catch (InstantiationException e) {
-            e.printStackTrace();
-        }
+        instance = new EasySOAApiFraSCAti();
     }


Input:
public void runAndRenderReport(IViewerReportDesignHandle design, String outputDocName, InputOptions options, Map parameters, OutputStream out, List activeIds) throws ReportServiceException {
    HttpServletRequest request = (HttpServletRequest) options.getOption(InputOptions.OPT_REQUEST);
    Locale locale = (Locale) options.getOption(InputOptions.OPT_LOCALE);
    Boolean isMasterPageContent = (Boolean) options.getOption(InputOptions.OPT_IS_MASTER_PAGE_CONTENT);
    Boolean svgFlag = (Boolean) options.getOption(InputOptions.OPT_SVG_FLAG);
    String format = (String) options.getOption(InputOptions.OPT_RENDER_FORMAT);
    Boolean isRtl = (Boolean) options.getOption(InputOptions.OPT_RTL);
    try {
        IReportRunnable runnable = (IReportRunnable) design.getDesignObject();
        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parameters, isMasterPageContent.booleanValue(), svgFlag.booleanValue());
    } catch (RemoteException e) {
        throw new ReportServiceException(e.getLocalizedMessage());
    }
}

Output:
         IReportRunnable runnable = (IReportRunnable) design.getDesignObject();
-        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parameters, isMasterPageContent.booleanValue(), svgFlag.booleanValue());
+        ReportEngineService.getInstance().runAndRenderReport(request, runnable, out, format, locale, isRtl.booleanValue(), parameters, isMasterPageContent.booleanValue(), svgFlag.booleanValue(), displayTexts);
     } catch (RemoteException e) {


Input:
public IStyle getStyle(Chart model, StyledComponent name) {
    SimpleStyle ss = null;
    if (cache == null || !useCache) {
        StyleHandle style = handle.getPrivateStyle();
        ss = new SimpleStyle();
        String fname = style.getFontFamilyHandle().getStringValue();
        int fsize = getFontSizeIntValue(handle);
        boolean fbold = getFontWeight(style.getFontWeight()) >= 700;
        boolean fitalic = DesignChoiceConstants.FONT_STYLE_ITALIC.equals(style.getFontStyle());
        boolean funder = DesignChoiceConstants.TEXT_UNDERLINE_UNDERLINE.equals(style.getTextUnderline());
        boolean fstrike = DesignChoiceConstants.TEXT_LINE_THROUGH_LINE_THROUGH.equals(style.getTextLineThrough());
        if (dstyle != null) {
            CSSValueList valueList = (CSSValueList) dstyle.getProperty(StyleConstants.STYLE_FONT_FAMILY);
            if (valueList.getLength() > 0) {
                fname = valueList.item(0).getCssText();
            }
            fsize = getSize(dstyle.getProperty(StyleConstants.STYLE_FONT_SIZE));
            fbold = isBoldFont(dstyle.getProperty(StyleConstants.STYLE_FONT_WEIGHT));
            fitalic = isItalicFont(dstyle.getFontStyle());
            funder = CSSConstants.CSS_UNDERLINE_VALUE.equals(dstyle.getTextUnderline());
            fstrike = CSSConstants.CSS_LINE_THROUGH_VALUE.equals(dstyle.getTextLineThrough());
        }
        HorizontalAlignment ha = HorizontalAlignment.LEFT_LITERAL;
        if (DesignChoiceConstants.TEXT_ALIGN_CENTER.equals(style.getTextAlign())) {
            ha = HorizontalAlignment.CENTER_LITERAL;
        } else if (DesignChoiceConstants.TEXT_ALIGN_RIGHT.equals(style.getTextAlign())) {
            ha = HorizontalAlignment.RIGHT_LITERAL;
        }
        VerticalAlignment va = VerticalAlignment.TOP_LITERAL;
        if (DesignChoiceConstants.VERTICAL_ALIGN_MIDDLE.equals(style.getVerticalAlign())) {
            va = VerticalAlignment.CENTER_LITERAL;
        } else if (DesignChoiceConstants.VERTICAL_ALIGN_BOTTOM.equals(style.getVerticalAlign())) {
            va = VerticalAlignment.BOTTOM_LITERAL;
        }
        TextAlignment ta = TextAlignmentImpl.create();
        ta.setHorizontalAlignment(ha);
        ta.setVerticalAlignment(va);
        FontDefinition fd = FontDefinitionImpl.create(fname, fsize, fbold, fitalic, funder, fstrike, true, 0, ta);
        ss.setFont(fd);
        ColorHandle ch = style.getColor();
        if (dstyle != null) {
            ss.setColor(getColor(dstyle.getProperty(StyleConstants.STYLE_COLOR)));
        } else if (ch != null && ch.getRGB() != -1) {
            int rgbValue = ch.getRGB();
            ColorDefinition cd = ColorDefinitionImpl.create((rgbValue >> 16) & 0xff, (rgbValue >> 8) & 0xff, rgbValue & 0xff);
            ss.setColor(cd);
        } else {
            ss.setColor(ColorDefinitionImpl.BLACK());
        }
        ch = style.getBackgroundColor();
        if (dstyle != null) {
            ss.setBackgroundColor(getColor(dstyle.getProperty(StyleConstants.STYLE_BACKGROUND_COLOR)));
        } else if (ch != null && ch.getRGB() != -1) {
            int rgbValue = ch.getRGB();
            ColorDefinition cd = ColorDefinitionImpl.create((rgbValue >> 16) & 0xff, (rgbValue >> 8) & 0xff, rgbValue & 0xff);
            ss.setBackgroundColor(cd);
        }
        if (style.getBackgroundImage() != null && style.getBackgroundImage().length() > 0) {
            String urlString = style.getBackgroundImage();
            try {
                new URL(urlString);
                ss.setBackgroundImage(ImageImpl.create(urlString));
            } catch (Exception _) {
                urlString = "String_Node_Str" + urlString;
                try {
                    new URL(urlString);
                    ss.setBackgroundImage(ImageImpl.create(urlString));
                } catch (Exception __) {
                    logger.log(_);
                }
            }
        }
        double pt = convertToPixel(style.getPaddingTop());
        double pb = convertToPixel(style.getPaddingBottom());
        double pl = convertToPixel(style.getPaddingLeft());
        double pr = convertToPixel(style.getPaddingRight());
        ss.setPadding(InsetsImpl.create(pt, pl, pb, pr));
        if (useCache) {
            cache = ss;
        }
    }
    if (useCache) {
        ss = cache.copy();
    }
    return ss;
}

Output:
             } catch (Exception _) {
-                urlString = "String_Node_Str" + urlString;
+                if (urlString != null && urlString.startsWith("String_Node_Str")) {
+                    urlString = "String_Node_Str" + urlString;
+                } else {
+                    urlString = "String_Node_Str" + urlString;
+                }
                 try {


Input:
public void create() throws IOException {
    HttpServletRequest req = ServletActionContext.getRequest();
    HttpServletResponse resp = ServletActionContext.getResponse();
    node = new Node();
    String pNodeName = req.getParameter("String_Node_Str");
    String pNodeType = req.getParameter("String_Node_Str");
    String pParentId = req.getParameter("String_Node_Str");
    String pRouterType = req.getParameter("String_Node_Str");
    String pNodeLevel = req.getParameter("String_Node_Str");
    if (Strings.isNullOrEmpty(pNodeName)) {
        responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
        return;
    }
    node.setName(pNodeName);
    if (Strings.isNullOrEmpty(pNodeType)) {
        responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
        return;
    }
    if (pNodeType.equals(Constants.EXCHANGE_TYPE_OF_STRING)) {
        responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
        return;
    }
    node.setType(Short.valueOf(pNodeType));
    if (Strings.isNullOrEmpty(pParentId)) {
        responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
        return;
    }
    node.setParentId(Integer.valueOf(pParentId));
    if (node.getType() == Constants.EXCHANGE_TYPE) {
        if (Strings.isNullOrEmpty(pRouterType)) {
            responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
            return;
        }
        node.setRouterType(pRouterType);
    }
    if (Strings.isNullOrEmpty(pNodeLevel)) {
        responseJTableData(resp, generateErrorJSONStr("String_Node_Str"));
        return;
    }
    node.setLevel(Short.valueOf(pNodeLevel));
    try {
        node.setRoutingKey(nodeService.generateRoutingKey(node));
        node.setValue(nodeService.generateNodeValue(node));
    } catch (IllegalStateException e) {
        responseJTableData(resp, generateErrorJSONStr(e.getMessage()));
        return;
    }
    try {
        nodeService.save(node);
        responseJTableData(resp, generateCreateSuccessJSONStr("String_Node_Str"));
    } catch (SQLException e) {
        logger.error("String_Node_Str" + e.getMessage());
        responseJTableData(resp, generateErrorJSONStr(e.getMessage()));
    }
}

Output:
     }
-    node.setParentId(Integer.valueOf(pParentId));
+    node.setParentId(Integer.parseInt(pParentId));
     if (node.getType() == Constants.EXCHANGE_TYPE) {


Input:
public boolean doNLST(String argument, Writer out) throws IOException {
    if (!parse(argument)) {
        return false;
    }
    FileObject[] files = null;
    try {
        files = fileSystemView.listFiles(file);
    } catch (FtpException ex) {
    }
    if (files == null) {
        return false;
    }
    RegularExpr regexp = null;
    if (pattern != null) {
        regexp = new RegularExpr(pattern);
    }
    for (int i = 0; i < files.length; i++) {
        if (files[i] == null) {
            continue;
        }
        if ((!isAllOption) && files[i].isHidden()) {
            continue;
        }
        if ((regexp != null) && (!regexp.isMatch(files[i].getShortName()))) {
            continue;
        }
        if (isDetailOption) {
            printLine(files[i], out);
        } else {
            out.write(files[i].getShortName());
        }
        out.write(NEWLINE);
    }
    out.flush();
    return true;
}

Output:
     }
-    FileObject[] files = null;
-    try {
-        files = fileSystemView.listFiles(file);
-    } catch (FtpException ex) {
-    }
+    FileObject[] files = listFiles();
     if (files == null) {


Input:
public Map<ECustomVersionGroup, Set<LibraryFile>> getImportLibLibraries() {
    Map<ECustomVersionGroup, Set<LibraryFile>> libMap = new HashMap<ECustomVersionGroup, Set<LibraryFile>>();
    if (isFromExistVersion) {
        IHadoopService hadoopService = null;
        if (GlobalServiceRegister.getDefault().isServiceRegistered(IHadoopService.class)) {
            hadoopService = (IHadoopService) GlobalServiceRegister.getDefault().getService(IHadoopService.class);
        }
        if (hadoopService != null) {
            for (ECustomVersionGroup group : existVersionSelectionMap.keySet()) {
                if (existVersionSelectionMap.get(group)) {
                    if (types != null) {
                        HashSet libInSameGroup = new HashSet<LibraryFile>();
                        for (ECustomVersionType type : types) {
                            if (type.getGroup() == group) {
                                Set<String> hadoopLibraries = new HashSet<String>();
                                if (ECustomVersionType.PIG == type) {
                                    hadoopLibraries = getLibrariesForPig();
                                } else {
                                    if (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type) {
                                        type = ECustomVersionType.HDFS;
                                    }
                                    hadoopLibraries = hadoopService.getHadoopLibrariesByType(type, getDistribution(), getVersion());
                                }
                                Set<LibraryFile> convertToLibraryFile = customLibUtil.convertToLibraryFile(hadoopLibraries);
                                libInSameGroup.addAll(convertToLibraryFile);
                            }
                        }
                        libMap.put(group, libInSameGroup);
                    }
                }
            }
        }
    } else if (isFromZip) {
        Set<ECustomVersionGroup> groups = new HashSet<ECustomVersionGroup>();
        for (ECustomVersionGroup group : fromZipSelectionMap.keySet()) {
            if (fromZipSelectionMap.get(group)) {
                groups.add(group);
            }
        }
        return customLibUtil.readZipFile(zipLocation, groups);
    }
    return libMap;
}

Output:
                                 } else {
-                                    if (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type) {
+                                    if (!commonGroupCalculated && (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type)) {
                                         type = ECustomVersionType.HDFS;


Input:
private void appendLink(StringBuffer sb, String prefix, BidirectionalRepositoryLayout layout, ArchivaArtifact artifact) {
    String type = artifact.getType();
    String linkText = StringUtils.capitalize(type);
    appendLink(sb, prefix, layout, artifact, linkText);
}

Output:
     String linkText = StringUtils.capitalize(type);
-    appendLink(sb, prefix, layout, artifact, linkText);
+    appendLink(sb, prefix, repo, artifact, linkText);
 }


Input:
public void combine(IntervalStats stats, boolean mutable, List<IntervalStats> accumulatedResult) {
    IntervalStats accum;
    if (accumulatedResult.isEmpty()) {
        accum = new IntervalStats();
        accum.beginTime = stats.beginTime;
        accumulatedResult.add(accum);
    } else {
        accum = accumulatedResult.get(0);
    }
    mergePackageStats(accum, stats);
}

Output:
     }
-    mergePackageStats(accum, stats);
+    mergePackageStats(accum, stats, deviceUsageTime);
 }


Input:
public void add(AccessibilityNodeInfo info) {
    if (ENABLED) {
        synchronized (mLock) {
            if (DEBUG) {
                Log.i(LOG_TAG, "String_Node_Str" + info + "String_Node_Str");
            }
            final long sourceId = info.getSourceNodeId();
            AccessibilityNodeInfo oldInfo = mCacheImpl.get(sourceId);
            if (oldInfo != null) {
                final LongArray newChildrenIds = info.getChildNodeIds();
                final int oldChildCount = oldInfo.getChildCount();
                for (int i = 0; i < oldChildCount; i++) {
                    final long oldChildId = oldInfo.getChildId(i);
                    if (newChildrenIds.indexOf(oldChildId) < 0) {
                        clearSubTreeLocked(oldChildId);
                    }
                }
                final long oldParentId = oldInfo.getParentNodeId();
                if (info.getParentNodeId() != oldParentId) {
                    clearSubTreeLocked(oldParentId);
                }
            }
            AccessibilityNodeInfo clone = AccessibilityNodeInfo.obtain(info);
            mCacheImpl.put(sourceId, clone);
        }
    }
}

Output:
                 final LongArray newChildrenIds = info.getChildNodeIds();
-                final int oldChildCount = oldInfo.getChildCount();
-                for (int i = 0; i < oldChildCount; i++) {
-                    final long oldChildId = oldInfo.getChildId(i);
-                    if (newChildrenIds.indexOf(oldChildId) < 0) {
-                        clearSubTreeLocked(oldChildId);
+                if (newChildrenIds != null) {
+                    final int oldChildCount = oldInfo.getChildCount();
+                    for (int i = 0; i < oldChildCount; i++) {
+                        final long oldChildId = oldInfo.getChildId(i);
+                        if (newChildrenIds.indexOf(oldChildId) < 0) {
+                            clearSubTreeLocked(oldChildId);
+                        }
                     }


Input:
protected void updateRtLFlag() throws EngineException {
    if (renderOptions == null)
        return;
    IReportRunnable runnable = executionContext.getRunnable();
    if (runnable == null)
        return;
    ReportDesignHandle handle = (ReportDesignHandle) runnable.getDesignHandle();
    if (handle != null) {
        Object bidiFlag = renderOptions.getOption(IRenderOption.RTL_FLAG);
        String bidiOrientation = null;
        if (bidiFlag != null) {
            if (Boolean.TRUE.equals(bidiFlag)) {
                bidiOrientation = DesignChoiceConstants.BIDI_DIRECTION_RTL;
            } else {
                bidiOrientation = DesignChoiceConstants.BIDI_DIRECTION_LTR;
            }
            try {
                handle.setBidiOrientation(bidiOrientation);
                Report report = executionContext.getReport();
                AbstractStyle rootStyle = (AbstractStyle) report.getStyles().get(report.getRootStyleName());
                {
                    if (rootStyle != null) {
                        rootStyle.setDirection(bidiOrientation);
                    }
                }
            } catch (SemanticException e) {
                log.log(Level.WARNING, "String_Node_Str", e);
                throw new EngineException("String_Node_Str");
            }
        } else if (handle.isDirectionRTL()) {
            renderOptions.setOption(IRenderOption.RTL_FLAG, new Boolean(true));
            IRenderOption renderOptions2 = executionContext.getRenderOption();
            if (renderOptions2 != null) {
                renderOptions2.setOption(IRenderOption.RTL_FLAG, new Boolean(true));
                executionContext.setRenderOption(renderOptions2);
            }
        }
    }
}

Output:
                 AbstractStyle rootStyle = (AbstractStyle) report.getStyles().get(report.getRootStyleName());
-                {
-                    if (rootStyle != null) {
-                        rootStyle.setDirection(bidiOrientation);
-                    }
+                if (rootStyle != null) {
+                    rootStyle.setDirection(bidiOrientation);
                 }


Input:
public void resetJobProcess(long msid, int jobResultCode, String jobResultMessage) {
    String sql = "String_Node_Str" + JobInfo.Status.FAILED.ordinal() + "String_Node_Str" + jobResultCode + "String_Node_Str" + jobResultMessage + "String_Node_Str" + JobInfo.Status.IN_PROGRESS.ordinal() + "String_Node_Str";
    TransactionLegacy txn = TransactionLegacy.currentTxn();
    PreparedStatement pstmt = null;
    try {
        pstmt = txn.prepareAutoCloseStatement(sql);
        pstmt.setLong(1, msid);
        pstmt.setLong(2, msid);
        pstmt.execute();
    } catch (SQLException e) {
        s_logger.warn("String_Node_Str" + msid, e);
    } catch (Throwable e) {
        s_logger.warn("String_Node_Str" + msid, e);
    }
}

Output:
 public void resetJobProcess(long msid, int jobResultCode, String jobResultMessage) {
-    String sql = "String_Node_Str" + JobInfo.Status.FAILED.ordinal() + "String_Node_Str" + jobResultCode + "String_Node_Str" + jobResultMessage + "String_Node_Str" + JobInfo.Status.IN_PROGRESS.ordinal() + "String_Node_Str";
+    String sql = "String_Node_Str";
     TransactionLegacy txn = TransactionLegacy.currentTxn();


Input:
private void linkToSalarParameterChanged() {
    String paramName = Utility.findIndex(linkToSalarParameter.getItems(), linkToSalarParameter.getText()) == 0 ? null : linkToSalarParameter.getText();
    if (paramName == null) {
        enableComposite(defaultValueComposite, linkToSalarParameter.isEnabled());
        defaultValue.setText(defaultValueString);
    } else {
        if (defaultValue.isEnabled())
            defaultValueString = defaultValue.getText();
        structureHandle.setDefaultValue("String_Node_Str");
        enableComposite(defaultValueComposite, false);
        defaultValue.setText(NONE_DEFAULT_VALUE);
    }
}

Output:
         enableComposite(defaultValueComposite, linkToSalarParameter.isEnabled());
-        defaultValue.setText(defaultValueString);
+        defaultValue.setText(NONE_DEFAULT_VALUE.equals(defaultValueString) ? "String_Node_Str" : defaultValueString);
     } else {


Input:
private void updateColumnsOfDataSetHandle() {
    DataSetHandle dataSet = ((DataSetEditor) getContainer()).getHandle();
    DataSetViewData[] items = DataSetProvider.getCurrentInstance().getColumns(dataSet, false, true, true);
    int inexistence = 0;
    for (int i = 0; i < items.length; i++) {
        boolean exist = false;
        if (items[i].isComputedColumn()) {
            Iterator iter = computedColumns.iterator();
            while (iter.hasNext()) {
                ComputedColumn computedColumn = null;
                Object obj = iter.next();
                if (obj instanceof ComputedColumnHandle) {
                    computedColumn = (ComputedColumn) ((ComputedColumnHandle) obj).getStructure();
                }
                if (items[i].getName().equals(computedColumn.getName())) {
                    exist = true;
                }
            }
            if (!exist) {
                items[i] = null;
                inexistence++;
            }
        }
    }
    if (inexistence == 0)
        return;
    DataSetViewData[] existItems = new DataSetViewData[items.length - inexistence];
    int index = 0;
    for (int i = 0; i < items.length; i++) {
        if (items[i] != null) {
            existItems[index] = items[i];
            index++;
        }
    }
    DataSetProvider.getCurrentInstance().updateColumnsOfDataSetHandle(dataSet, existItems);
}

Output:
                 }
-                if (items[i].getName().equals(computedColumn.getName())) {
+                if (computedColumn != null && items[i].getName().equals(computedColumn.getName())) {
                     exist = true;


Input:
public void testIO() throws ClassHierarchyException {
    AnalysisScope scope = CallGraphTestUtil.makeJ2SEAnalysisScope("String_Node_Str", "String_Node_Str");
    ClassHierarchy cha = ClassHierarchy.make(scope);
    Iterable<Entrypoint> entrypoints = makePrimordialPublicEntrypoints(scope, cha, "String_Node_Str");
    AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
    CallGraphTestUtil.buildZeroCFA(options, new AnalysisCache(), cha, scope);
}

Output:
     AnalysisOptions options = CallGraphTestUtil.makeAnalysisOptions(scope, entrypoints);
-    CallGraphTestUtil.buildZeroCFA(options, new AnalysisCache(), cha, scope);
+    CallGraphTestUtil.buildZeroCFA(options, new AnalysisCache(), cha, scope, false);
 }


Input:
private Section createTableSectionPartForMapDB(Composite parentComp, String title, SimpleStatIndicator ssIndicator) {
    Section columnSetElementSection = this.createSection(form, parentComp, title, null);
    Composite sectionTableComp = toolkit.createComposite(columnSetElementSection);
    if (ssIndicator.isStoreData()) {
        columnSetElementSection.setExpanded(true);
        columnSetElementSection.setEnabled(true);
        sectionTableComp.setLayoutData(new GridData(GridData.FILL_BOTH));
        sectionTableComp.setLayout(new GridLayout());
        Button filterDataBt = new Button(sectionTableComp, SWT.NONE);
        filterDataBt.setText(DefaultMessagesImpl.getString("String_Node_Str"));
        filterDataBt.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
        filterDataBt.setEnabled(containAllMatchIndicator());
        filterDataBt.addMouseListener(new MouseListener() {
            public void mouseDoubleClick(MouseEvent e) {
            }
            public void mouseDown(MouseEvent e) {
                List<Indicator> indicatorsList = masterPage.analysisItem.getAnalysis().getResults().getIndicators();
                SelectPatternsWizard wizard = new SelectPatternsWizard(indicatorsList);
                wizard.setFilterType(filterType);
                wizard.setOldTableInputList(ColumnSetResultPage.this.tableFilterResult);
                WizardDialog dialog = new WizardDialog(null, wizard);
                dialog.setPageSize(300, 400);
                wizard.setContainer(dialog);
                wizard.setWindowTitle(DefaultMessagesImpl.getString("String_Node_Str"));
                if (WizardDialog.OK == dialog.open()) {
                    ColumnSetResultPage.this.tableFilterResult = wizard.getPatternSelectPage().getTableInputList();
                    filterType = wizard.getPatternSelectPage().getFilterType();
                    columnsElementViewer.refresh();
                }
            }
            public void mouseUp(MouseEvent e) {
            }
        });
        columnsElementViewer = new TableViewer(sectionTableComp, SWT.MULTI | SWT.FULL_SELECTION | SWT.BORDER);
        Table table = columnsElementViewer.getTable();
        table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        table.setLinesVisible(true);
        table.setHeaderVisible(true);
        TableSectionViewerProvider provider = new TableSectionViewerProvider();
        columnsElementViewer.setContentProvider(provider);
        columnsElementViewer.addFilter(new PatternDataFilter());
        columnSetElementSection.setClient(sectionTableComp);
        columnSetElementSection.setExpanded(false);
        int pageSize = 100;
        setupTableGridDataLimitedSize(table, pageSize);
        final PageableController controller = new PageableController(100);
        final IPageLoader<PageResult<Object[]>> pageLoader = new MapDBPageLoader<Object[]>(ssIndicator.getMapDB(StandardDBName.dataSection.name()));
        controller.addPageChangedListener(PageLoaderStrategyHelper.createLoadPageAndReplaceItemsListener(controller, columnsElementViewer, pageLoader, PageResultContentProvider.getInstance(), null));
        ResultAndNavigationPageGraphicsRenderer resultAndPageButtonsDecorator = new ResultAndNavigationPageGraphicsRenderer(sectionTableComp, SWT.NONE, controller);
        resultAndPageButtonsDecorator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        createColumns(controller, ssIndicator);
        controller.setCurrentPage(0);
        for (TableColumn column : table.getColumns()) {
            column.pack();
        }
    } else {
        columnSetElementSection.setExpanded(false);
        columnSetElementSection.setEnabled(false);
    }
    return columnSetElementSection;
}

Output:
         final PageableController controller = new PageableController(100);
-        final IPageLoader<PageResult<Object[]>> pageLoader = new MapDBPageLoader<Object[]>(ssIndicator.getMapDB(StandardDBName.dataSection.name()));
-        controller.addPageChangedListener(PageLoaderStrategyHelper.createLoadPageAndReplaceItemsListener(controller, columnsElementViewer, pageLoader, PageResultContentProvider.getInstance(), null));
-        ResultAndNavigationPageGraphicsRenderer resultAndPageButtonsDecorator = new ResultAndNavigationPageGraphicsRenderer(sectionTableComp, SWT.NONE, controller);
-        resultAndPageButtonsDecorator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+        try {
+            final IPageLoader<PageResult<Object[]>> pageLoader = new MapDBPageLoader<Object[]>(ssIndicator.getMapDB(StandardDBName.dataSection.name()));
+            controller.addPageChangedListener(PageLoaderStrategyHelper.createLoadPageAndReplaceItemsListener(controller, columnsElementViewer, pageLoader, PageResultContentProvider.getInstance(), null));
+            ResultAndNavigationPageGraphicsRenderer resultAndPageButtonsDecorator = new ResultAndNavigationPageGraphicsRenderer(sectionTableComp, SWT.NONE, controller);
+            resultAndPageButtonsDecorator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+        } catch (IOError error) {
+            log.warn(error.getMessage(), error);
+        }
         createColumns(controller, ssIndicator);


Input:
public int executeBatch() {
    Cassandra.Client conn = null;
    Object pooledConnection = null;
    Map<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>> batchMutationMap = new HashMap<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>>();
    int recordsExecuted = 0;
    String batchQuery = CQLTranslator.BATCH_QUERY;
    batchQuery = StringUtils.replace(batchQuery, CQLTranslator.STATEMENT, "String_Node_Str");
    StringBuilder batchQueryBuilder = new StringBuilder(batchQuery);
    try {
        boolean isCql3Enabled = false;
        for (Node node : nodes) {
            if (node.isDirty()) {
                node.handlePreEvent();
                Object entity = node.getData();
                Object id = node.getEntityId();
                EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(node.getDataClass());
                persistenceUnit = metadata.getPersistenceUnit();
                isUpdate = node.isUpdate();
                MetamodelImpl metaModel = (MetamodelImpl) KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodel(metadata.getPersistenceUnit());
                if (isCql3Enabled(metadata)) {
                    isCql3Enabled = true;
                    List<RelationHolder> relationHolders = getRelationHolders(node);
                    String query;
                    if (node.isInState(RemovedState.class)) {
                        query = onDeleteQuery(metadata, metaModel, id);
                    } else {
                        query = createInsertQuery(metadata, entity, conn, relationHolders, getTtlValues().get(metadata.getTableName()));
                    }
                    batchQueryBuilder.append(query);
                } else {
                    if (node.isInState(RemovedState.class)) {
                        delete(entity, id);
                    } else {
                        List<RelationHolder> relationHolders = getRelationHolders(node);
                        Map<ByteBuffer, Map<String, List<Mutation>>> mutationMap = new HashMap<ByteBuffer, Map<String, List<Mutation>>>();
                        mutationMap = prepareMutation(metadata, entity, id, relationHolders, mutationMap);
                        recordsExecuted += mutationMap.size();
                        if (!batchMutationMap.containsKey(metadata.getEntityClazz())) {
                            batchMutationMap.put(metadata.getEntityClazz(), mutationMap);
                        } else {
                            batchMutationMap.get(metadata.getEntityClazz()).putAll(mutationMap);
                        }
                        indexNode(node, metadata);
                    }
                }
                node.handlePostEvent();
            }
        }
        if (!batchMutationMap.isEmpty()) {
            pooledConnection = getConection();
            conn = getConnection(pooledConnection);
            for (Class<?> entityClass : batchMutationMap.keySet()) {
                conn.batch_mutate(batchMutationMap.get(entityClass), consistencyLevel);
            }
        }
        if (!nodes.isEmpty() && isCql3Enabled) {
            batchQueryBuilder.append(CQLTranslator.APPLY_BATCH);
            executeCQLQuery(batchQueryBuilder.toString(), false);
        }
    } catch (InvalidRequestException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (TException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (UnavailableException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } catch (TimedOutException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } catch (SchemaDisagreementException e) {
        log.error("String_Node_Str", e);
        throw new KunderaException(e);
    } finally {
        clear();
        if (pooledConnection != null) {
            releaseConnection(pooledConnection);
        }
    }
    return recordsExecuted;
}

Output:
         }
-    } catch (InvalidRequestException e) {
-        log.error("String_Node_Str", e);
-        throw new KunderaException(e);
-    } catch (TException e) {
-        log.error("String_Node_Str", e);
-        throw new KunderaException(e);
-    } catch (UnavailableException e) {
-        log.error("String_Node_Str", e);
-        throw new KunderaException(e);
-    } catch (TimedOutException e) {
-        log.error("String_Node_Str" + e);
-        throw new KunderaException(e);
-    } catch (SchemaDisagreementException e) {
+    } catch (Exception e) {
         log.error("String_Node_Str", e);


Input:
public void watch(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.SPELL_CAST) {
        spellsCastThisTurnInOrder.add(event.getTargetId());
        UUID playerId = event.getPlayerId();
        if (playerId != null) {
            Integer amount = amountOfSpellsCastOnCurrentTurn.get(playerId);
            if (amount == null) {
                amount = 1;
            } else {
                amount = amount + 1;
            }
            amountOfSpellsCastOnCurrentTurn.put(playerId, amount);
        }
    }
}

Output:
     if (event.getType() == GameEvent.EventType.SPELL_CAST) {
-        spellsCastThisTurnInOrder.add(event.getTargetId());
+        spellsCastThisTurnInOrder.add(new MageObjectReference(event.getSourceId(), game));
         UUID playerId = event.getPlayerId();


Input:
public void addPlugin(PomDependencyMgt plugin) {
    String pluginValue = plugin.getGroupId() + EXTRA_INFO_DELIMITER + plugin.getArtifaceId() + EXTRA_INFO_DELIMITER + plugin.getVersion();
    String pluginExtraInfo = (String) ivyModuleDescriptor.getExtraInfo().get("String_Node_Str");
    if (pluginExtraInfo == null) {
        pluginExtraInfo = pluginValue;
    } else {
        pluginExtraInfo = pluginExtraInfo + "String_Node_Str" + pluginValue;
    }
    ivyModuleDescriptor.getExtraInfo().put("String_Node_Str", pluginExtraInfo);
}

Output:
 public void addPlugin(PomDependencyMgt plugin) {
-    String pluginValue = plugin.getGroupId() + EXTRA_INFO_DELIMITER + plugin.getArtifaceId() + EXTRA_INFO_DELIMITER + plugin.getVersion();
+    String pluginValue = plugin.getGroupId() + EXTRA_INFO_DELIMITER + plugin.getArtifactId() + EXTRA_INFO_DELIMITER + plugin.getVersion();
     String pluginExtraInfo = (String) ivyModuleDescriptor.getExtraInfo().get("String_Node_Str");


Input:
public void createSalesforceSchemasWizard(RepositoryNode node, final boolean forceReadOnly) {
    SalesforceSchemaConnection connection = null;
    MetadataTable metadataTable = null;
    boolean creation = false;
    if (node.getType() == ENodeType.REPOSITORY_ELEMENT) {
        ERepositoryObjectType nodeType = (ERepositoryObjectType) node.getProperties(EProperties.CONTENT_TYPE);
        String tableLabel = (String) node.getProperties(EProperties.LABEL);
        SalesforceSchemaConnectionItem item = null;
        if (nodeType == ERepositoryObjectType.METADATA_SALESFORCE_MODULE) {
            item = (SalesforceSchemaConnectionItem) node.getObject().getProperty().getItem();
            connection = (SalesforceSchemaConnection) item.getConnection();
            metadataTable = ConnectionFactory.eINSTANCE.createMetadataTable();
            String nextId = ProxyRepositoryFactory.getInstance().getNextId();
            metadataTable.setId(nextId);
            metadataTable.setLabel(getStringIndexed(metadataTable.getLabel()));
            creation = false;
        } else {
            return;
        }
        initContextMode(item);
        SalesforceSchemasWizard salesforceSchemasWizard = new SalesforceSchemasWizard(PlatformUI.getWorkbench(), creation, node.getObject(), metadataTable, getExistingNames(), forceReadOnly, null, null, node.getProperties(EProperties.LABEL).toString());
        WizardDialog wizardDialog = new WizardDialog(Display.getCurrent().getActiveShell(), salesforceSchemasWizard);
        handleWizard(node, wizardDialog);
    }
}

Output:
             connection = (SalesforceSchemaConnection) item.getConnection();
-            metadataTable = ConnectionFactory.eINSTANCE.createMetadataTable();
-            String nextId = ProxyRepositoryFactory.getInstance().getNextId();
-            metadataTable.setId(nextId);
-            metadataTable.setLabel(getStringIndexed(metadataTable.getLabel()));
+            metadataTable = TableHelper.findByLabel(connection, tableLabel);
             creation = false;


Input:
public boolean canAttack(Game game) {
    return true;
}

Output:
 public boolean canAttack(Game game) {
-    return true;
+    Ability source = (Ability) getValue("String_Node_Str");
+    return game.getBattlefield().count(filter, source.getSourceId(), source.getControllerId(), game) > 0 || HateCondition.getInstance().apply(game, source);
 }


Input:
public void propertyChange(PropertyChangeEvent evt) {
    DialogFileFilter fileFilter = (DialogFileFilter) evt.getNewValue();
    selectedBuilder = getExporter(fileFilter);
    if (selectedBuilder != null) {
        selectedExporter = selectedBuilder.buildExporter();
    }
    if (selectedBuilder != null && exportController.getExportController().getUI(selectedExporter) != null) {
        optionsButton.setEnabled(true);
    } else {
        optionsButton.setEnabled(false);
    }
    if (selectedFile != null && fileFilter != null) {
        String filePath = selectedFile.getAbsolutePath();
        filePath = filePath.substring(0, filePath.lastIndexOf("String_Node_Str"));
        filePath = filePath.concat(fileFilter.getExtensions().get(0));
        selectedFile = new File(filePath);
        chooser.setSelectedFile(selectedFile);
    }
}

Output:
     if (selectedFile != null && fileFilter != null) {
-        String filePath = selectedFile.getAbsolutePath();
-        filePath = filePath.substring(0, filePath.lastIndexOf("String_Node_Str"));
-        filePath = filePath.concat(fileFilter.getExtensions().get(0));
-        selectedFile = new File(filePath);
+        String fileName = selectedFile.getName();
+        String directoryPath = chooser.getCurrentDirectory().getAbsolutePath();
+        fileName = fileName.substring(0, fileName.lastIndexOf("String_Node_Str"));
+        fileName = fileName.concat(fileFilter.getExtensions().get(0));
+        selectedFile = new File(directoryPath, fileName);
         chooser.setSelectedFile(selectedFile);


Input:
protected Answer copyVolumeFromSnapshot(DataObject snapObj, DataObject volObj) {
    SnapshotInfo snapshot = (SnapshotInfo) snapObj;
    StoragePool pool = (StoragePool) volObj.getDataStore();
    String basicErrMsg = "String_Node_Str" + snapshot.getName() + "String_Node_Str" + pool;
    DataStore store = snapObj.getDataStore();
    DataStoreTO storTO = store.getTO();
    DataObject srcData = snapObj;
    try {
        if (!(storTO instanceof NfsTO)) {
            srcData = cacheSnapshotChain(snapshot);
        }
        String value = configDao.getValue(Config.CreateVolumeFromSnapshotWait.toString());
        int _createVolumeFromSnapshotWait = NumbersUtil.parseInt(value, Integer.parseInt(Config.CreateVolumeFromSnapshotWait.getDefaultValue()));
        EndPoint ep = null;
        if (srcData.getDataStore().getRole() == DataStoreRole.Primary) {
            ep = selector.select(volObj);
        } else {
            ep = selector.select(snapObj, volObj);
        }
        CopyCommand cmd = new CopyCommand(srcData.getTO(), volObj.getTO(), _createVolumeFromSnapshotWait, _mgmtServer.getExecuteInSequence());
        Answer answer = null;
        if (ep == null) {
            String errMsg = "String_Node_Str";
            s_logger.error(errMsg);
            answer = new Answer(cmd, false, errMsg);
        } else {
            answer = ep.sendMessage(cmd);
        }
        return answer;
    } catch (Exception e) {
        s_logger.error(basicErrMsg, e);
        throw new CloudRuntimeException(basicErrMsg);
    } finally {
        if (!(storTO instanceof NfsTO)) {
            releaseSnapshotCacheChain((SnapshotInfo) srcData);
        }
    }
}

Output:
         }
-        CopyCommand cmd = new CopyCommand(srcData.getTO(), volObj.getTO(), _createVolumeFromSnapshotWait, _mgmtServer.getExecuteInSequence());
+        CopyCommand cmd = new CopyCommand(srcData.getTO(), volObj.getTO(), _createVolumeFromSnapshotWait, VirtualMachineManager.ExecuteInSequence.value());
         Answer answer = null;