Input:
public Object getValueAt(int rowIndex, int columnIndex) {
    Species species = this.population.getSpecies().get(rowIndex);
    String leader = "String_Node_Str";
    if (species.getLeader() != null)
        leader = Format.formatInteger((int) species.getLeader().getGenomeID());
    switch(columnIndex) {
        case 0:
            return Format.formatInteger((int) species.getSpeciesID());
        case 1:
            return Format.formatInteger(species.getAge());
        case 2:
            return Format.formatDouble(species.getBestScore(), 4);
        case 3:
            return Format.formatInteger(species.getGensNoImprovement());
        case 4:
            return leader;
        case 5:
            return Format.formatInteger(species.getMembers().size());
        default:
            return "String_Node_Str";
    }
}

Output:
 public Object getValueAt(int rowIndex, int columnIndex) {
-    Species species = this.population.getSpecies().get(rowIndex);
+    NEATSpecies species = this.population.getSpecies().get(rowIndex);
     String leader = "String_Node_Str";


Input:
public void testNoRemoveWindowPropertyAlias4a() {
    test("String_Node_Str" + "String_Node_Str", "String_Node_Str");
}

Output:
 public void testNoRemoveWindowPropertyAlias4a() {
-    test("String_Node_Str" + "String_Node_Str", "String_Node_Str");
+    testSame(LINE_JOINER.join("String_Node_Str", "String_Node_Str"));
 }


Input:
private int stopAll(String callingApp) {
    int result = TextToSpeech.ERROR;
    boolean speechQueueAvailable = false;
    try {
        speechQueueAvailable = speechQueueLock.tryLock(SPEECHQUEUELOCK_TIMEOUT, TimeUnit.MILLISECONDS);
        if (speechQueueAvailable) {
            for (int i = mSpeechQueue.size() - 1; i > -1; i--) {
                if (mSpeechQueue.get(i).mType != SpeechItem.TEXT_TO_FILE) {
                    mSpeechQueue.remove(i);
                }
            }
            if ((mCurrentSpeechItem != null) && ((mCurrentSpeechItem.mType != SpeechItem.TEXT_TO_FILE) || mCurrentSpeechItem.mCallingApp.equals(callingApp))) {
                if (sIsKillingSynth) {
                    Log.v("String_Node_Str", "String_Node_Str");
                    result = TextToSpeech.ERROR;
                } else {
                    result = sNativeSynth.stop();
                }
                mKillList.put(mCurrentSpeechItem, true);
                if (mPlayer != null) {
                    try {
                        mPlayer.stop();
                    } catch (IllegalStateException e) {
                    }
                }
                mIsSpeaking = false;
                mCurrentSpeechItem = null;
            } else {
                result = TextToSpeech.SUCCESS;
            }
            Log.i("String_Node_Str", "String_Node_Str");
        }
    } catch (InterruptedException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        e.printStackTrace();
    } finally {
        if (speechQueueAvailable) {
            speechQueueLock.unlock();
        }
        return result;
    }
}

Output:
             if ((mCurrentSpeechItem != null) && ((mCurrentSpeechItem.mType != SpeechItem.TEXT_TO_FILE) || mCurrentSpeechItem.mCallingApp.equals(callingApp))) {
-                if (sIsKillingSynth) {
-                    Log.v("String_Node_Str", "String_Node_Str");
-                    result = TextToSpeech.ERROR;
-                } else {
-                    result = sNativeSynth.stop();
-                }
+                result = sNativeSynth.stop();
                 mKillList.put(mCurrentSpeechItem, true);


Input:
public void depose() {
    weaver.depose();
}

Output:
 public void depose() {
-    weaver.depose();
+    if (null != obj && null != depose)
+        depose.trigger(obj);
 }


Input:
private TSpan copySpanWithoutSpanEvent(TSpan span) {
    TSpan copiedSpan = span.deepCopy();
    copiedSpan.setSpanEventList(Collections.EMPTY_LIST);
    return copiedSpan;
}

Output:
     TSpan copiedSpan = span.deepCopy();
-    copiedSpan.setSpanEventList(Collections.EMPTY_LIST);
+    copiedSpan.setSpanEventList(Collections.<TSpanEvent>emptyList());
     return copiedSpan;


Input:
public void showMeetingDetails(CenterWithAssociations centerWithAssociations) {
    if (!centerWithAssociations.getActive()) {
        llBottomPanel.setVisibility(View.VISIBLE);
        showErrorMessage(R.string.error_center_inactive);
    }
    if (centerWithAssociations.getCollectionMeetingCalendar().getCalendarInstanceId() == null) {
        tvMeetingDate.setText(getString(R.string.unassigned));
        if (getView() != null) {
            getView().findViewById(R.id.row_meeting_frequency).setVisibility(View.GONE);
        }
    } else {
        tvMeetingDate.setText(Utils.getStringOfDate(getContext(), centerWithAssociations.getCollectionMeetingCalendar().getNextTenRecurringDates().get(0)));
        if (getView() != null) {
            getView().findViewById(R.id.row_meeting_frequency).setVisibility(View.VISIBLE);
            tvMeetingFrequency.setText(centerWithAssociations.getCollectionMeetingCalendar().getHumanReadable());
        }
    }
}

Output:
     } else {
-        tvMeetingDate.setText(Utils.getStringOfDate(getContext(), centerWithAssociations.getCollectionMeetingCalendar().getNextTenRecurringDates().get(0)));
+        tvMeetingDate.setText(Utils.getStringOfDate(centerWithAssociations.getCollectionMeetingCalendar().getNextTenRecurringDates().get(0)));
         if (getView() != null) {


Input:
public void playSoundEffect(int effectId) {
    checkThread();
    final AudioManager audioManager = getAudioManager();
    switch(effectId) {
        case SoundEffectConstants.CLICK:
            audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
            return;
        case SoundEffectConstants.NAVIGATION_DOWN:
            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
            return;
        case SoundEffectConstants.NAVIGATION_LEFT:
            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
            return;
        case SoundEffectConstants.NAVIGATION_RIGHT:
            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
            return;
        case SoundEffectConstants.NAVIGATION_UP:
            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
            return;
        default:
            throw new IllegalArgumentException("String_Node_Str" + effectId + "String_Node_Str" + SoundEffectConstants.class.getCanonicalName());
    }
}

Output:
     checkThread();
-    final AudioManager audioManager = getAudioManager();
-    switch(effectId) {
-        case SoundEffectConstants.CLICK:
-            audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
-            return;
-        case SoundEffectConstants.NAVIGATION_DOWN:
-            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
-            return;
-        case SoundEffectConstants.NAVIGATION_LEFT:
-            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
-            return;
-        case SoundEffectConstants.NAVIGATION_RIGHT:
-            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
-            return;
-        case SoundEffectConstants.NAVIGATION_UP:
-            audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
-            return;
-        default:
-            throw new IllegalArgumentException("String_Node_Str" + effectId + "String_Node_Str" + SoundEffectConstants.class.getCanonicalName());
+    try {
+        final AudioManager audioManager = getAudioManager();
+        switch(effectId) {
+            case SoundEffectConstants.CLICK:
+                audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
+                return;
+            case SoundEffectConstants.NAVIGATION_DOWN:
+                audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
+                return;
+            case SoundEffectConstants.NAVIGATION_LEFT:
+                audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
+                return;
+            case SoundEffectConstants.NAVIGATION_RIGHT:
+                audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
+                return;
+            case SoundEffectConstants.NAVIGATION_UP:
+                audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
+                return;
+            default:
+                throw new IllegalArgumentException("String_Node_Str" + effectId + "String_Node_Str" + SoundEffectConstants.class.getCanonicalName());
+        }
+    } catch (IllegalStateException e) {
+        Log.e(TAG, "String_Node_Str" + e);
+        e.printStackTrace();
     }


Input:
public void startPrefixMapping(String prefix, String uri) throws SAXException {
    unmarshalNamespaceResolver.push(prefix, uri);
}

Output:
 public void startPrefixMapping(String prefix, String uri) throws SAXException {
-    unmarshalNamespaceResolver.push(prefix, uri);
+    getUnmarshalNamespaceResolver().push(prefix, uri);
 }


Input:
public static int computeEmptyProcessLimit(int totalProcessLimit) {
    return (totalProcessLimit * 2) / 3;
}

Output:
 public static int computeEmptyProcessLimit(int totalProcessLimit) {
-    return (totalProcessLimit * 2) / 3;
+    return totalProcessLimit / 2;
 }


Input:
public static long copy(Readable from, Appendable to) throws IOException {
    CharBuffer buf = CharBuffer.allocate(BUF_SIZE);
    long total = 0;
    while (true) {
        int r = from.read(buf);
        if (r == -1) {
            break;
        }
        buf.flip();
        to.append(buf, 0, r);
        total += r;
    }
    return total;
}

Output:
     long total = 0;
-    while (true) {
-        int r = from.read(buf);
-        if (r == -1) {
-            break;
-        }
+    while (from.read(buf) != -1) {
         buf.flip();


Input:
public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
    writer.println("String_Node_Str" + mComponentName + "String_Node_Str" + mBound);
}

Output:
 public void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
-    writer.println("String_Node_Str" + mComponentName + "String_Node_Str" + mBound);
+    writer.println("String_Node_Str" + mComponentName + "String_Node_Str" + mBound + "String_Node_Str" + mConnected);
 }


Input:
public IProject createNewProject(String projectName, Shell shell) throws InvocationTargetException, InterruptedException, CoreException {
    final Shell currentShell = shell;
    final IProject newProjectHandle = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    final IProjectDescription description = workspace.newProjectDescription(newProjectHandle.getName());
    IRunnableWithProgress op = new IRunnableWithProgress() {
        public void run(IProgressMonitor monitor) throws InvocationTargetException {
            CreateProjectOperation op = new CreateProjectOperation(description, DefaultMessagesImpl.getString("String_Node_Str"));
            try {
                PlatformUI.getWorkbench().getOperationSupport().getOperationHistory().execute(op, monitor, WorkspaceUndoUtil.getUIInfoAdapter(currentShell));
            } catch (ExecutionException e) {
                throw new InvocationTargetException(e);
            }
        }
    };
    if (!newProjectHandle.exists()) {
        ProgressUI.popProgressDialog(op, shell);
    }
    newProjectHandle.setPersistentProperty(PROJECT_TDQ_KEY, PROJECT_TDQ_PROPERTY);
    return newProjectHandle;
}

Output:
     if (!newProjectHandle.exists()) {
-        ProgressUI.popProgressDialog(op, shell);
+        ProgressUI.popProgressDialog(op);
     }


Input:
public FormStatus execute(Dictionary<String, String> dictionary) {
    status = FormStatus.Processing;
    String localDir = dictionary.get("String_Node_Str");
    String hostName = dictionary.get("String_Node_Str");
    ExecutionHelper helper = new ExecutionHelper(dictionary);
    if (localDir == null || hostName == null) {
        return actionError("String_Node_Str", null);
    }
    String connectionName = dictionary.get("String_Node_Str");
    if (connectionName == null) {
        connection = getRemoteConnection(hostName);
    } else {
        IRemoteConnectionType connectionType = getService(IRemoteServicesManager.class).getRemoteConnectionTypes().get(0);
        for (IRemoteConnection c : connectionType.getConnections()) {
            if (connectionName.equals(c.getName())) {
                connection = c;
            }
        }
    }
    if (connection == null) {
        return actionError("String_Node_Str" + hostName, null);
    }
    if (!connection.isOpen()) {
        try {
            connection.open(null);
        } catch (RemoteConnectionException e) {
            return actionError("String_Node_Str", e);
        }
    }
    IRemoteFileService fileManager = connection.getService(IRemoteFileService.class);
    IFileStore localDirectory = EFS.getLocalFileSystem().fromLocalFile(helper.getLocalLaunchFolder().getLocation().toFile());
    String remoteSeparator = connection.getProperty(IRemoteConnection.FILE_SEPARATOR_PROPERTY);
    String userHome = connection.getProperty(IRemoteConnection.USER_HOME_PROPERTY);
    IFileStore downloadFileStore = fileManager.getResource(userHome + remoteSeparator + "String_Node_Str" + remoteSeparator + localDir);
    try {
        IFileStore[] remoteStores = downloadFileStore.childStores(EFS.NONE, null);
        for (IFileStore remoteFile : remoteStores) {
            IFileInfo fileInfo = remoteFile.fetchInfo();
            if (fileInfo.getLength() < maxFileSize) {
                String msg = "String_Node_Str" + "String_Node_Str" + fileInfo.getName() + "String_Node_Str" + fileInfo.getLength() + "String_Node_Str";
                logger.info(msg);
                postConsoleText(msg);
                IFileStore childStore = localDirectory.getChild(remoteFile.getName());
                remoteFile.copy(childStore, EFS.OVERWRITE, null);
            } else {
                long sizeDiff = fileInfo.getLength() - maxFileSize;
                String msg = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + fileInfo.getLength() + "String_Node_Str" + sizeDiff + "String_Node_Str" + maxFileSize + "String_Node_Str";
                postConsoleText(msg);
                logger.info(msg);
            }
        }
    } catch (CoreException e) {
        return actionError(getClass().getName() + "String_Node_Str", e);
    }
    status = FormStatus.Processed;
    return status;
}

Output:
     } else {
-        IRemoteConnectionType connectionType = getService(IRemoteServicesManager.class).getRemoteConnectionTypes().get(0);
+        List<IRemoteConnectionType> types = getService(IRemoteServicesManager.class).getRemoteConnectionTypes();
+        IRemoteConnectionType connectionType = null;
+        for (IRemoteConnectionType type : types) {
+            if ("String_Node_Str".equals(type.getName())) {
+                connectionType = type;
+                break;
+            }
+        }
+        if (connectionType == null) {
+            return actionError("String_Node_Str", null);
+        }
         for (IRemoteConnection c : connectionType.getConnections()) {


Input:
public void syncRepayments() {
    List<RepaymentTransaction> transactions = Select.from(RepaymentTransaction.class).list();
    Log.i(TAG, "String_Node_Str" + transactions);
    List<MeetingCenter> centerList = Select.from(MeetingCenter.class).where(com.orm.query.Condition.prop("String_Node_Str").eq(centerId)).list();
    MeetingCenter center = centerList.get(0);
    if (transactions.size() > 0) {
        List<BulkRepaymentTransactions> repaymentTransactions = new ArrayList<BulkRepaymentTransactions>();
        for (RepaymentTransaction transaction : transactions) {
            Loan loan = transaction.getLoan();
            if (loan.getAccountStatusId() == 300) {
                repaymentTransactions.add(new BulkRepaymentTransactions(loan.getLoanId(), transaction.getTransactionAmount()));
            }
        }
        BulkRepaymentTransactions[] repaymentTransactionArray = new BulkRepaymentTransactions[repaymentTransactions.size()];
        repaymentTransactions.toArray(repaymentTransactionArray);
        CollectionSheetPayload payload = new CollectionSheetPayload();
        payload.bulkRepaymentTransactions = repaymentTransactionArray;
        payload.setCalendarId(center.getCollectionMeetingCalendar().getCalendarId());
        payload.setTransactionDate(DateHelper.getPayloadDate());
        SaveCollectionSheetTask task = new SaveCollectionSheetTask();
        task.execute(payload);
    } else
        syncFinishListener.onSyncFinish("String_Node_Str", false);
}

Output:
         payload.setCalendarId(center.getCollectionMeetingCalendar().getCalendarId());
-        payload.setTransactionDate(DateHelper.getPayloadDate());
+        payload.setTransactionDate(DateHelper.getPayloadDate(context));
         SaveCollectionSheetTask task = new SaveCollectionSheetTask();


Input:
public static Collection<Object[]> getData() {
    return Arrays.asList(new Object[][] { { "String_Node_Str", 0 }, { "String_Node_Str", 2 }, { "String_Node_Str", 5 }, { "String_Node_Str", 0 }, { "String_Node_Str", 2 }, { "String_Node_Str", 5 } });
}

Output:
 public static Collection<Object[]> getData() {
-    return Arrays.asList(new Object[][] { { "String_Node_Str", 0 }, { "String_Node_Str", 2 }, { "String_Node_Str", 5 }, { "String_Node_Str", 0 }, { "String_Node_Str", 2 }, { "String_Node_Str", 5 } });
+    return Arrays.asList(new Object[][] { { "String_Node_Str", 0 }, { "String_Node_Str", 2 }, { "String_Node_Str", 5 }, { "String_Node_Str", 0 }, { "String_Node_Str", 1 }, { "String_Node_Str", 5 } });
 }


Input:
public static void testProcessGmonFile(File gmonFile, File binaryFile, File parserRefFile, File parserDumpFile) throws Exception {
    IBinaryObject binary = STSymbolManager.sharedInstance.getBinaryObject(binaryFile.getAbsolutePath());
    final GmonDecoder gmondecoder = new GmonDecoder(binary, new PrintStream(parserRefFile));
    gmondecoder.setShouldDump(true);
    gmondecoder.read(gmonFile.getAbsolutePath());
    STJunitUtils.compareIgnoreEOL(parserDumpFile.getAbsolutePath(), parserRefFile.getAbsolutePath(), true);
}

Output:
     IBinaryObject binary = STSymbolManager.sharedInstance.getBinaryObject(binaryFile.getAbsolutePath());
-    final GmonDecoder gmondecoder = new GmonDecoder(binary, new PrintStream(parserRefFile));
+    final GmonDecoder gmondecoder = new GmonDecoder(binary, new PrintStream(parserDumpFile));
     gmondecoder.setShouldDump(true);


Input:
public void handleLoadPackage(final LoadPackageParam lpparam) throws Throwable {
    findAndHookConstructor(DefaultHttpClient.class, new XC_MethodHook() {
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
            setObjectField(param.thisObject, "String_Node_Str", null);
            setObjectField(param.thisObject, "String_Node_Str", getSCCM());
        }
    });
    findAndHookConstructor(DefaultHttpClient.class, HttpParams.class, new XC_MethodHook() {
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
            setObjectField(param.thisObject, "String_Node_Str", (HttpParams) param.args[0]);
            setObjectField(param.thisObject, "String_Node_Str", getSCCM());
        }
    });
    findAndHookConstructor(DefaultHttpClient.class, ClientConnectionManager.class, HttpParams.class, new XC_MethodHook() {
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
            HttpParams params = (HttpParams) param.args[1];
            setObjectField(param.thisObject, "String_Node_Str", params);
            setObjectField(param.thisObject, "String_Node_Str", getCCM(param.args[0], params));
        }
    });
    findAndHookConstructor(SSLSocketFactory.class, String.class, KeyStore.class, String.class, KeyStore.class, SecureRandom.class, HostNameResolver.class, new XC_MethodHook() {
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
            String algorithm = (String) param.args[0];
            KeyStore keystore = (KeyStore) param.args[1];
            String keystorePassword = (String) param.args[2];
            SecureRandom random = (SecureRandom) param.args[4];
            KeyManager[] keymanagers = null;
            TrustManager[] trustmanagers = null;
            if (keystore != null) {
                keymanagers = (KeyManager[]) callStaticMethod(SSLSocketFactory.class, "String_Node_Str", keystore, keystorePassword);
            }
            trustmanagers = new TrustManager[] { new ImSureItsLegitTrustManager() };
            setObjectField(param.thisObject, "String_Node_Str", SSLContext.getInstance(algorithm));
            callMethod(getObjectField(param.thisObject, "String_Node_Str"), "String_Node_Str", keymanagers, trustmanagers, random);
            setObjectField(param.thisObject, "String_Node_Str", callMethod(getObjectField(param.thisObject, "String_Node_Str"), "String_Node_Str"));
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return (SSLSocketFactory) newInstance(SSLSocketFactory.class);
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", Socket.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return true;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", new XC_MethodHook() {
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
            Class<?> cls = findClass("String_Node_Str", lpparam.classLoader);
            TrustManager[] managers = (TrustManager[]) param.getResult();
            if (managers.length > 0 && cls.isInstance(managers[0]))
                return;
            param.setResult(new TrustManager[] { new ImSureItsLegitTrustManager() });
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", HostnameVerifier.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return null;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", javax.net.ssl.SSLSocketFactory.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return null;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", HostnameVerifier.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return null;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", WebView.class, SslErrorHandler.class, SslError.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            ((android.webkit.SslErrorHandler) param.args[1]).proceed();
            return null;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", WebView.class, int.class, String.class, String.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            return null;
        }
    });
    findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", X509Certificate[].class, String.class, String.class, new XC_MethodReplacement() {
        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
            ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
            return list;
        }
    });
}

Output:
     findAndHookMethod("String_Node_Str", lpparam.classLoader, "String_Node_Str", X509Certificate[].class, String.class, String.class, new XC_MethodReplacement() {
-        protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
-            ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
-            return list;
-        }
-    });
+            protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
+                ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
+                return list;
+            }
+        });
+    }
 }


Input:
private SeriesDefinition getCurrentSeriesDefinition() {
    if (seriesDefns.isEmpty()) {
        addNewSeriesDefinition();
        refreshSeriesCombo();
        cmbSeriesSelect.select(0);
    }
    return (SeriesDefinition) seriesDefns.get(cmbSeriesSelect.getSelectionIndex());
}

Output:
     }
-    return (SeriesDefinition) seriesDefns.get(cmbSeriesSelect.getSelectionIndex());
+    return seriesDefns.get(cmbSeriesSelect.getSelectionIndex());
 }


Input:
public List validateForAddingGroup(ListingHandle element, String groupName) {
    List groupList = Collections.EMPTY_LIST;
    ListingElement targetElement = getListingElement(element.getModule(), (ListingElement) element.getElement());
    if (targetElement == null) {
        targetElement = (ListingElement) element.getElement();
        groupList = getGroups(element.getModule(), (ListingElement) element.getElement());
    } else {
        groupList = getGroupsWithContents(element.getModule(), targetElement);
    }
    List list = new ArrayList();
    if (isDuplicateGroupName(element.getModule(), groupList, groupName)) {
        list.add(new SemanticError(targetElement, new String[] { groupName }, SemanticError.DESIGN_EXCEPTION_DUPLICATE_GROUP_NAME));
        return list;
    }
    return list;
}

Output:
     if (isDuplicateGroupName(element.getModule(), groupList, groupName)) {
-        list.add(new SemanticError(targetElement, new String[] { groupName }, SemanticError.DESIGN_EXCEPTION_DUPLICATE_GROUP_NAME));
+        list.add(new NameException(targetElement, groupName, NameException.DESIGN_EXCEPTION_DUPLICATE));
         return list;


Input:
public void writeGet(MethodWriter writer, IValue instance) throws BytecodeException {
    if (this.isConstant()) {
        this.value.writeExpression(writer);
        return;
    }
    if (this.className == null) {
        this.type.writeDefaultValue(writer);
        return;
    }
    String extended = this.type.getExtendedName();
    writer.writeFieldInsn(Opcodes.GETSTATIC, this.className, "String_Node_Str", extended);
}

Output:
     String extended = this.type.getExtendedName();
-    writer.writeFieldInsn(Opcodes.GETSTATIC, this.className, "String_Node_Str", extended);
+    writer.writeFieldInsn(Opcodes.GETSTATIC, this.className, this.name.qualified, extended);
 }


Input:
public List<String> getAllActiveTrapExpressions() {
    Connection conn = DBConnect.getDBConnection();
    List<String> result = new ArrayList<String>();
    try {
        PreparedStatement stmt = conn.prepareStatement(SELECT_EXPRS_STMT);
        ResultSet rs = stmt.executeQuery();
        while (rs.next()) {
            result.add(rs.getString(1));
        }
        return result;
    } catch (SQLException e) {
        String message = "String_Node_Str" + ExceptionUtils.getSQLExceptionCause(e);
        log.warn(message, e);
        throw new IOFailure(message, e);
    }
}

Output:
     try {
-        PreparedStatement stmt = conn.prepareStatement(SELECT_EXPRS_STMT);
+        stmt = conn.prepareStatement("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+        stmt.setBoolean(1, true);
         ResultSet rs = stmt.executeQuery();


Input:
public final CounterSample sample() {
    return new CounterSample((org.javasimon.CounterSample) counter.sample());
}

Output:
 public final CounterSample sample() {
-    return new CounterSample((org.javasimon.CounterSample) counter.sample());
+    return new CounterSample(counter.sample());
 }


Input:
protected void visitHtmlCloseTagNode(HtmlCloseTagNode node) {
    TagName closeTag = node.getTagName();
    if (isDefinitelyVoid(node)) {
        errorReporter.report(node.getSourceLocation(), INVALID_CLOSE_TAG, closeTag.getStaticTagName().getRawText());
        return;
    }
    if (closeTag.isForeignContent()) {
        foreignContentEndLocation = node.getSourceLocation();
        inForeignContent = false;
    }
    if (!closeTag.isDefinitelyOptional()) {
        popOptionalTags(false);
    }
    if (!openTagStack.isEmpty() && openTagStack.peekFirst().hasTagName()) {
        TagName openTag = openTagStack.peekFirst().getTagName();
        if (HtmlTagEntry.matchOrError(openTag, closeTag, errorReporter)) {
            openTagStack.pollFirst();
        }
    } else {
        closeTagQueue.addLast(new HtmlTagEntry(closeTag));
    }
}

Output:
     }
-    if (!closeTag.isDefinitelyOptional()) {
-        popOptionalTags(false);
+    HtmlTagEntry openTag = openTagStack.peekFirst();
+    while (openTag != null && openTag.hasTagName() && !openTag.getTagName().equals(closeTag) && openTag.isDefinitelyOptional()) {
+        openTagStack.pollFirst();
+        openTag = openTagStack.peekFirst();
     }


Input:
public final boolean incrementToken() throws IOException {
    if (!emitSingleTokens && unusedTokens.size() > 0) {
        Log.debug("String_Node_Str");
        Token aToken = unusedTokens.remove(0);
        emit(aToken);
        return true;
    }
    if (lastToken != null) {
        emit(lastToken);
        lastToken = null;
        return true;
    }
    char[] nextToken = nextToken();
    if (nextToken == null) {
        if (lastValid != null) {
            emit(lastValid);
            lastValid = null;
            return true;
        }
        if (emitSingleTokens && currentSetToCheck != null && currentSetToCheck.size() > 0) {
            char[] phrase = getFirst(currentSetToCheck);
            char[] lastTok = getCurrentBuffer(new char[0]);
            if (phrase != null && endsWith(lastTok, phrase)) {
                currentSetToCheck = remove(currentSetToCheck, phrase);
                emit(phrase);
                return true;
            }
        } else if (!emitSingleTokens && currentSetToCheck != null && currentSetToCheck.size() > 0) {
            if (lastEmitted != null && !equals(fixWhitespace(lastEmitted), getCurrentBuffer(new char[0]))) {
                discardCharTokens(currentPhrase, unusedTokens);
                currentSetToCheck = null;
                if (unusedTokens.size() > 0) {
                    Token aToken = unusedTokens.remove(0);
                    Log.debug("String_Node_Str");
                    emit(aToken);
                    return true;
                }
            }
        }
        if (lastEmitted == null && (currentPhrase != null && currentPhrase.length() > 0)) {
            char[] lastTok = getCurrentBuffer(new char[0]);
            if (currentSetToCheck.contains(lastTok, 0, lastTok.length)) {
                emit(lastTok);
                currentPhrase.setLength(0);
                return true;
            } else if (!emitSingleTokens) {
                discardCharTokens(currentPhrase, unusedTokens);
                currentSetToCheck = null;
                currentPhrase.setLength(0);
                if (unusedTokens.size() > 0) {
                    Token aToken = unusedTokens.remove(0);
                    Log.debug("String_Node_Str");
                    emit(aToken);
                    return true;
                }
            }
        }
        return false;
    }
    if (emitSingleTokens) {
        lastToken = nextToken;
    }
    if (currentSetToCheck == null || currentSetToCheck.size() == 0) {
        Log.debug("String_Node_Str" + new String(nextToken) + "String_Node_Str");
        if (phraseMap.keySet().contains(nextToken, 0, nextToken.length)) {
            currentSetToCheck = phraseMap.get(nextToken, 0, nextToken.length);
            if (currentPhrase == null)
                currentPhrase = new StringBuffer();
            else
                currentPhrase.setLength(0);
            currentPhrase.append(nextToken);
            return incrementToken();
        } else {
            emit(nextToken);
            lastToken = null;
            return true;
        }
    } else {
        char[] currentBuffer = getCurrentBuffer(nextToken);
        if (currentSetToCheck.contains(currentBuffer, 0, currentBuffer.length)) {
            currentSetToCheck = remove(currentSetToCheck, currentBuffer);
            if (currentSetToCheck.size() == 0) {
                emit(currentBuffer);
                lastValid = null;
                --positionIncr;
            } else {
                if (emitSingleTokens) {
                    lastToken = currentBuffer;
                    return true;
                }
                lastValid = currentBuffer;
            }
            if (phraseMap.keySet().contains(nextToken, 0, nextToken.length)) {
                currentSetToCheck = phraseMap.get(nextToken, 0, nextToken.length);
                if (currentPhrase == null)
                    currentPhrase = new StringBuffer();
                else
                    currentPhrase.setLength(0);
                currentPhrase.append(nextToken);
            }
            return (lastValid != null) ? incrementToken() : true;
        }
        if (phraseMap.keySet().contains(nextToken, 0, nextToken.length)) {
            CharArraySet newSet = phraseMap.get(nextToken, 0, nextToken.length);
            Iterator<Object> phraseIt = newSet.iterator();
            while (phraseIt != null && phraseIt.hasNext()) {
                char[] phrase = (char[]) phraseIt.next();
                currentSetToCheck.add(phrase);
            }
        }
        Iterator<Object> phraseIt = currentSetToCheck.iterator();
        while (phraseIt != null && phraseIt.hasNext()) {
            char[] phrase = (char[]) phraseIt.next();
            if (startsWith(phrase, currentBuffer)) {
                return incrementToken();
            }
        }
        if (lastValid != null) {
            emit(lastValid);
            lastValid = null;
            return true;
        }
        if (!emitSingleTokens) {
            discardCharTokens(currentPhrase, unusedTokens);
            currentPhrase.setLength(0);
            currentSetToCheck = null;
            if (unusedTokens.size() > 0) {
                Token aToken = unusedTokens.remove(0);
                Log.debug("String_Node_Str");
                emit(aToken);
                return true;
            }
        }
        currentSetToCheck = null;
        Log.debug("String_Node_Str");
        return incrementToken();
    }
}

Output:
         } else if (!emitSingleTokens && currentSetToCheck != null && currentSetToCheck.size() > 0) {
-            if (lastEmitted != null && !equals(fixWhitespace(lastEmitted), getCurrentBuffer(new char[0]))) {
+            char[] currBuff = getCurrentBuffer(new char[0]);
+            if (lastEmitted != null && !equals(fixWhitespace(lastEmitted), currBuff)) {
                 discardCharTokens(currentPhrase, unusedTokens);


Input:
public void onConfigChange(ConfigurationChange evt) {
    if (evt.check("String_Node_Str", "String_Node_Str")) {
        fullBlacklist = Sets.newHashSet(imcBlacklist);
        for (String cls : Config.teBlacklist) fullBlacklist.add(cls.toLowerCase());
    }
}

Output:
         fullBlacklist = Sets.newHashSet(imcBlacklist);
-        for (String cls : Config.teBlacklist) fullBlacklist.add(cls.toLowerCase());
+        for (String cls : Config.teBlacklist) fullBlacklist.add(cls.toLowerCase(Locale.ENGLISH));
     }


Input:
public void run() {
    int bugID = 1;
    Program program = Program.g();
    Hashtable<String, Integer> warningMap = new Hashtable<String, Integer>();
    printer = new CodePrinting();
    for (jq_Method m : program.getMethods()) {
        if (!m.isAbstract()) {
            System.out.println("String_Node_Str" + m);
            String srcFile = m.getDeclaringClass().getSourceFileName();
            ControlFlowGraph cfg = null;
            try {
                cfg = m.getCFG();
            } catch (Throwable e) {
                System.out.println("String_Node_Str" + m + "String_Node_Str" + e);
                continue;
            }
            if (cfg == null) {
                System.out.println("String_Node_Str" + m + "String_Node_Str");
                continue;
            }
            for (BasicBlock bb : cfg.reversePostOrder()) {
                boolean throws_exception = false;
                startingLine = 100000;
                Hashtable<jq_Class, List<String>> exceptionsThrown = new Hashtable<jq_Class, List<String>>();
                if (Config.verbose > 1) {
                    System.out.println("String_Node_Str" + bb);
                }
                for (int i = 0; i < bb.size(); i++) {
                    Quad q = bb.getQuad(i);
                    try {
                        if (Config.verbose > 1) {
                            System.out.println("String_Node_Str" + q.getLineNumber() + "String_Node_Str" + q);
                        }
                        if (q.getLineNumber() < startingLine && q.getLineNumber() != 0) {
                            startingLine = q.getLineNumber();
                        }
                    } catch (Throwable e) {
                    }
                    for (jq_Class exc : q.getThrownExceptions()) {
                        String excStr = exc.getName();
                        if (excStr.equals("String_Node_Str") || excStr.equals("String_Node_Str")) {
                            continue;
                        }
                        throws_exception = true;
                        if (!exceptionsThrown.containsKey(exc)) {
                            exceptionsThrown.put(exc, new ArrayList<String>());
                        }
                        exceptionsThrown.get(exc).add("String_Node_Str" + q.getLineNumber() + "String_Node_Str" + q);
                        System.out.println("String_Node_Str" + q + "String_Node_Str" + q.getLineNumber() + "String_Node_Str" + excStr);
                    }
                }
                if (throws_exception == false) {
                    continue;
                }
                for (ExceptionHandler eh : bb.getExceptionHandlers()) {
                    jq_Class handledEx = eh.getExceptionType();
                    System.out.println("String_Node_Str" + handledEx.toString() + "String_Node_Str" + bb + "String_Node_Str" + bb.getLastQuad().getLineNumber() + "String_Node_Str" + srcFile);
                    if (checkTerminatingHandler(eh) == true) {
                        String bugInfo = eh.toString() + m.toString() + m.getDeclaringClass().toString();
                        if (warningMap.containsKey(bugInfo)) {
                            continue;
                        }
                        warningMap.put(bugInfo, 1);
                        System.out.println("String_Node_Str");
                        System.out.println("String_Node_Str" + bugID + "String_Node_Str" + handledEx.getName());
                        System.out.println("String_Node_Str" + eh.getEntry().getLastQuad().getLineNumber() + "String_Node_Str" + srcFile + "String_Node_Str");
                        System.out.println("String_Node_Str");
                        int numHandledEx = 0;
                        Iterator<jq_Class> exIterator = exceptionsThrown.keySet().iterator();
                        while (exIterator.hasNext()) {
                            jq_Class thrownEx = exIterator.next();
                            if (isSubClass(thrownEx, handledEx) >= 0) {
                                numHandledEx++;
                                System.out.println("String_Node_Str" + thrownEx.getName());
                                List<String> thrownExes = exceptionsThrown.get(thrownEx);
                                for (String throwInfo : thrownExes) {
                                    System.out.println("String_Node_Str" + throwInfo);
                                }
                            }
                        }
                        if (numHandledEx > 1) {
                            System.out.println("String_Node_Str");
                        } else {
                            System.out.println("String_Node_Str");
                        }
                        try {
                            printer.printCode(startingLine, endingLine, srcFile);
                        } catch (IOException ioe) {
                            System.out.println("String_Node_Str" + srcFile + "String_Node_Str" + startingLine + "String_Node_Str" + endingLine);
                        }
                        System.out.println("String_Node_Str");
                        bugID++;
                    }
                }
            }
        }
    }
}

Output:
                         try {
-                            printer.printCode(startingLine, endingLine, srcFile);
+                            printer.printCode(startingLine, endingLine, srcFile, true);
                         } catch (IOException ioe) {


Input:
public boolean allowClick(BaseCommodityViewModel commodityViewModel) {
    if (spinnerSource.getSelectedItem().equals(getString(R.string.zonal_store))) {
        return commodityViewModel.getCommodity().isNonLGA();
    } else {
        return !commodityViewModel.getCommodity().isNonLGA();
    }
}

Output:
     } else {
-        return !commodityViewModel.getCommodity().isNonLGA();
+        if ("String_Node_Str".equals(commodityViewModel.getCommodity().getCategory().getName())) {
+            return false;
+        } else {
+            return !commodityViewModel.getCommodity().isNonLGA();
+        }
     }


Input:
private void composeProfileProfileStructureComponent(String name, Profile.ProfileStructureComponent element) throws Exception {
    if (element != null) {
        open(name);
        composeBackbone(element);
        composeCodeCore("String_Node_Str", element.getType(), false);
        composeCodeExtras("String_Node_Str", element.getType(), false);
        composeUriCore("String_Node_Str", element.getBase(), false);
        composeUriExtras("String_Node_Str", element.getBase(), false);
        composeStringCore("String_Node_Str", element.getName(), false);
        composeStringExtras("String_Node_Str", element.getName(), false);
        composeBooleanCore("String_Node_Str", element.getPublish(), false);
        composeBooleanExtras("String_Node_Str", element.getPublish(), false);
        composeStringCore("String_Node_Str", element.getPurpose(), false);
        composeStringExtras("String_Node_Str", element.getPurpose(), false);
        composeProfileConstraintComponent("String_Node_Str", element.getSnapshot());
        composeProfileConstraintComponent("String_Node_Str", element.getDifferential());
        if (element.getSearchParam().size() > 0) {
            openArray("String_Node_Str");
            for (Profile.ProfileStructureSearchParamComponent e : element.getSearchParam()) composeProfileProfileStructureSearchParamComponent(null, e);
            closeArray();
        }
        ;
        close();
    }
}

Output:
         composeUriExtras("String_Node_Str", element.getBase(), false);
-        composeStringCore("String_Node_Str", element.getName(), false);
-        composeStringExtras("String_Node_Str", element.getName(), false);
+        composeIdCore("String_Node_Str", element.getName(), false);
+        composeIdExtras("String_Node_Str", element.getName(), false);
         composeBooleanCore("String_Node_Str", element.getPublish(), false);


Input:
public void create(String name, char[] password) {
    CommandInvocation cmd = commandRunner.getCommandInvocation("String_Node_Str", actionReport);
    ParameterMap map = new ParameterMap();
    map.add("String_Node_Str", password.toString());
    map.add("String_Node_Str", name);
    cmd.parameters(map);
    cmd.execute();
    if (actionReport.getActionExitCode() == ActionReport.ExitCode.FAILURE) {
        Throwable cause = actionReport.getFailureCause();
        if (cause instanceof IllegalArgumentException) {
            throw (IllegalArgumentException) cause;
        } else {
            throw new RuntimeException(cause);
        }
    } else if (actionReport.getActionExitCode() == ActionReport.ExitCode.FAILURE) {
        logger.fine(actionReport.getMessage());
    }
}

Output:
     ParameterMap map = new ParameterMap();
-    map.add("String_Node_Str", password.toString());
+    map.add("String_Node_Str", String.valueOf(password));
     map.add("String_Node_Str", name);


Input:
public void openConsole() {
    List<MDMServerDef> allServerDefs = ServerDefService.getAllServerDefs();
    if (allServerDefs == null || allServerDefs.isEmpty()) {
        MessageDialog.openInformation(null, Messages.ShowMDMServerConsole_InfoDialog_Title, Messages.ShowMDMServerConsole_InfoDialog_Message);
    } else if (allServerDefs.size() == 1) {
        MDMServerDef serverDef = allServerDefs.get(0).getDecryptedServerDef();
        showMDMServerConsole(serverDef);
    } else {
        SelectServerDefDialog d = new SelectServerDefDialog(new Shell());
        d.create();
        d.setSelectServer(allServerDefs.get(0));
        if (d.open() == IDialogConstants.OK_ID) {
            MDMServerDef serverDef = d.getSelectedServerDef();
            showMDMServerConsole(serverDef);
        }
    }
}

Output:
     } else if (allServerDefs.size() == 1) {
-        MDMServerDef serverDef = allServerDefs.get(0).getDecryptedServerDef();
+        MDMServerDef serverDef = allServerDefs.get(0);
         showMDMServerConsole(serverDef);


Input:
private File getConfiguredWorkDirectory() throws ComponentLookupException {
    File workDirectory = null;
    String workDirectoryName = this.componentManager.lookup(ConfigurationSource.class, "String_Node_Str").getProperty(PROPERTY_WORKDIRECTORY);
    if (workDirectoryName != null) {
        workDirectory = new File(workDirectoryName);
        if (workDirectory.exists()) {
            if (!workDirectory.isDirectory()) {
                LOGGER.error("String_Node_Str", workDirectory.getAbsolutePath());
                workDirectory = null;
            } else if (!workDirectory.canWrite()) {
                LOGGER.error("String_Node_Str", workDirectory.getAbsolutePath());
                workDirectory = null;
            }
        } else {
            workDirectory.mkdirs();
        }
    }
    return workDirectory;
}

Output:
 private File getConfiguredWorkDirectory() throws ComponentLookupException {
-    File workDirectory = null;
+    File directory = null;
     String workDirectoryName = this.componentManager.lookup(ConfigurationSource.class, "String_Node_Str").getProperty(PROPERTY_WORKDIRECTORY);


Input:
public void onViewCreated(final View view, final Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    Log.i(TAG, "String_Node_Str" + sectionNumber);
    initFloatingMenu(sectionNumber, savedInstanceState);
    if (null != mFloatingMenu) {
        view.postDelayed(new Runnable() {
            public void run() {
                int currentItem = ((MainActivity2) getActivity()).mViewPager.getCurrentItem();
                if (currentItem == sectionNumber) {
                    mFloatingMenu.show(false);
                }
            }
        }, 20);
    }
}

Output:
             }
-        }, 20);
+        }, 100);
     }


Input:
public void endRow(IRowContent row) throws BirtException {
    if (cellEmitter != null) {
        cellEmitter.endRow(row);
    } else {
        if (!isNestTable()) {
            layout.endRow(row);
            lastRowId = row.getRowID();
            hasDropCell = layout.hasDropCell();
            if (hasDropCell()) {
                return;
            }
            if (layoutEvents.size() > 0) {
                flush();
                return;
            }
        }
        boolean isHidden = LayoutUtil.isHidden(row, emitter.getOutputFormat(), context.getOutputDisplayNone());
        if (context.isFixedLayout() && (Integer) context.getLayoutEngine().getOption(EngineTask.TASK_TYPE) == IEngineTask.TASK_RUN) {
            isHidden = false;
        }
        if (!isHidden) {
            emitter.endRow(row);
        }
    }
}

Output:
         }
-        boolean isHidden = LayoutUtil.isHidden(row, emitter.getOutputFormat(), context.getOutputDisplayNone());
-        if (context.isFixedLayout() && (Integer) context.getLayoutEngine().getOption(EngineTask.TASK_TYPE) == IEngineTask.TASK_RUN) {
-            isHidden = false;
-        }
+        boolean hiddenMask = context.isFixedLayout() && (Integer) context.getLayoutEngine().getOption(EngineTask.TASK_TYPE) == IEngineTask.TASK_RUN;
+        boolean isHidden = LayoutUtil.isHidden(row, emitter.getOutputFormat(), context.getOutputDisplayNone(), hiddenMask);
         if (!isHidden) {


Input:
public Collection<ScenarioParameter> lookupScenarioParameters(String scenarioName) {
    if (scenarioStarters.containsKey(scenarioName)) {
        return scenarioStarters.get(scenarioName).getScenarioParameters();
    }
    return Collections.EMPTY_LIST;
}

Output:
     }
-    return Collections.EMPTY_LIST;
+    return Collections.emptyList();
 }


Input:
private final int nextSelectedPositionForDirection(int selectedPos, int direction) {
    int nextSelected;
    if (direction == View.FOCUS_DOWN) {
        nextSelected = selectedPos != INVALID_POSITION && selectedPos >= mFirstPosition ? selectedPos + 1 : mFirstPosition;
    } else {
        final int lastPos = mFirstPosition + getChildCount() - 1;
        nextSelected = selectedPos != INVALID_POSITION && selectedPos <= lastPos ? selectedPos - 1 : lastPos;
    }
    if (nextSelected < 0 || nextSelected >= mAdapter.getCount()) {
        return INVALID_POSITION;
    }
    return lookForSelectablePosition(nextSelected, direction == View.FOCUS_DOWN);
}

Output:
     if (direction == View.FOCUS_DOWN) {
-        nextSelected = selectedPos != INVALID_POSITION && selectedPos >= mFirstPosition ? selectedPos + 1 : mFirstPosition;
+        final int listBottom = getHeight() - mListPadding.bottom;
+        if (selectedView != null && selectedView.getBottom() <= listBottom) {
+            nextSelected = selectedPos != INVALID_POSITION && selectedPos >= mFirstPosition ? selectedPos + 1 : mFirstPosition;
+        } else {
+            return INVALID_POSITION;
+        }
     } else {


Input:
public View getView(int position, View convertView, ViewGroup parent) {
    LayoutInflater inflater = (LayoutInflater.from(getContext()));
    View itemView = inflater.inflate(R.layout.fragment_armor_set_builder_skills_item, parent, false);
    TextView treeName = (TextView) itemView.findViewById(R.id.skill_tree_name);
    TextView headPoints = (TextView) itemView.findViewById(R.id.helmet);
    TextView bodyPoints = (TextView) itemView.findViewById(R.id.body);
    TextView armsPoints = (TextView) itemView.findViewById(R.id.arms);
    TextView waistPoints = (TextView) itemView.findViewById(R.id.waist);
    TextView legsPoints = (TextView) itemView.findViewById(R.id.legs);
    TextView totalPoints = (TextView) itemView.findViewById(R.id.total);
    treeName.setText(getItem(position).getSkillTree().getName());
    if (session.isEquipmentSelected(ArmorSetBuilderSession.HEAD)) {
        headPoints.setText(String.valueOf(getItem(position).getHeadPoints()));
    }
    if (session.isEquipmentSelected(ArmorSetBuilderSession.BODY)) {
        bodyPoints.setText(String.valueOf(getItem(position).getBodyPoints()));
    }
    if (session.isEquipmentSelected(ArmorSetBuilderSession.ARMS)) {
        armsPoints.setText(String.valueOf(getItem(position).getArmsPoints()));
    }
    if (session.isEquipmentSelected(ArmorSetBuilderSession.WAIST)) {
        waistPoints.setText(String.valueOf(getItem(position).getWaistPoints()));
    }
    if (session.isEquipmentSelected(ArmorSetBuilderSession.LEGS)) {
        legsPoints.setText(String.valueOf(getItem(position).getLegsPoints()));
    }
    totalPoints.setText(String.valueOf(getItem(position).getTotal()));
    itemView.setOnClickListener(new SkillClickListener(getContext(), getItem(position).getSkillTree().getId()));
    return itemView;
}

Output:
     totalPoints.setText(String.valueOf(getItem(position).getTotal()));
-    itemView.setOnClickListener(new SkillClickListener(getContext(), getItem(position).getSkillTree().getId()));
+    itemView.setOnClickListener(new SkillClickListener(ArmorSetBuilderSkillsListFragment.this.getActivity(), getItem(position).getSkillTree().getId()));
     return itemView;


Input:
public int compareTo(Object o) {
    return value.compareTo(((Prefix) o).value);
}

Output:
 public int compareTo(Object o) {
-    return value.compareTo(((Prefix) o).value);
+    return -value.compareTo(((Prefix) o).value);
 }


Input:
public void registerCommandProvider(Object provider) {
    Predicate<? super Method> predicate = Predicates.<Method>and(withModifier(Modifier.PUBLIC), ReflectionUtils.withAnnotation(Command.class));
    Set<Method> commandMethods = ReflectionUtils.getAllMethods(provider.getClass(), predicate);
    if (!commandMethods.isEmpty()) {
        for (Method method : commandMethods) {
            CommandInfo command = new CommandInfo(method, provider);
            commands.add(command);
            commandLookup.put(command.getName(), command.getParameterCount(), command);
        }
        commandsSorted = false;
    }
}

Output:
             CommandInfo command = new CommandInfo(method, provider);
-            commands.add(command);
-            commandLookup.put(command.getName(), command.getParameterCount(), command);
+            if (commandLookup.contains(command.getName(), command.getParameterCount())) {
+                logger.warn("String_Node_Str", command.getName(), command.getParameterCount());
+            } else {
+                commands.add(command);
+                commandLookup.put(command.getName(), command.getParameterCount(), command);
+            }
         }


Input:
void openForWriting(int firstTrunkPage) throws SQLException {
    trace.debug("String_Node_Str" + firstTrunkPage);
    this.firstTrunkPage = firstTrunkPage;
    pageOut = new PageOutputStream(store, firstTrunkPage);
    pageOut.reserve(1);
    store.setLogFirstPage(firstTrunkPage, pageOut.getCurrentDataPageId());
    buffer = new ByteArrayOutputStream();
    out = new DataOutputStream(buffer);
}

Output:
     this.firstTrunkPage = firstTrunkPage;
-    pageOut = new PageOutputStream(store, firstTrunkPage);
+    pageOut = new PageOutputStream(store, firstTrunkPage, undoAll);
     pageOut.reserve(1);


Input:
public boolean hasHashTree() {
    return (_thexUri != null && _root32 != null && !_rfd.hasTHEXFailed());
}

Output:
 public boolean hasHashTree() {
-    return (_thexUri != null && _root32 != null && !_rfd.hasTHEXFailed());
+    return _thexUri != null && _root32 != null && !_rfd.hasTHEXFailed() && !_thexSucceeded;
 }


Input:
public static void copyRow(HSSFSheet srcSheet, HSSFSheet destSheet, HSSFRow srcRow, HSSFRow destRow, String expressionToReplace, String expressionReplacement) {
    Set mergedRegions = new TreeSet();
    if (srcRow.getHeight() >= 0) {
        destRow.setHeight(srcRow.getHeight());
    }
    for (int j = srcRow.getFirstCellNum(); j <= srcRow.getLastCellNum(); j++) {
        HSSFCell oldCell = srcRow.getCell(j);
        HSSFCell newCell = destRow.getCell(j);
        if (oldCell != null) {
            if (newCell == null) {
                newCell = destRow.createCell(j);
            }
            copyCell(oldCell, newCell, true, expressionToReplace, expressionReplacement);
            CellRangeAddress mergedRegion = getMergedRegion(srcSheet, srcRow.getRowNum(), oldCell.getColumnIndex());
            if (mergedRegion != null) {
                CellRangeAddress newMergedRegion = new CellRangeAddress(mergedRegion.getFirstRow(), mergedRegion.getLastRow(), mergedRegion.getFirstColumn(), mergedRegion.getLastColumn());
                if (isNewMergedRegion(newMergedRegion, mergedRegions)) {
                    mergedRegions.add(newMergedRegion);
                    destSheet.addMergedRegion(newMergedRegion);
                }
            }
        }
    }
}

Output:
 public static void copyRow(HSSFSheet srcSheet, HSSFSheet destSheet, HSSFRow srcRow, HSSFRow destRow, String expressionToReplace, String expressionReplacement) {
-    Set mergedRegions = new TreeSet();
+    Set mergedRegions = new HashSet();
     if (srcRow.getHeight() >= 0) {


Input:
public void partOpened(IWorkbenchPart part) {
    IProcess2 process = getProcess();
    ((Process) process).setEditor(AbstractMultiPageTalendEditor.this);
}

Output:
 public void partOpened(IWorkbenchPart part) {
-    IProcess2 process = getProcess();
-    ((Process) process).setEditor(AbstractMultiPageTalendEditor.this);
+    if (part == AbstractMultiPageTalendEditor.this) {
+        IProcess2 process = getProcess();
+        ((Process) process).setEditor(AbstractMultiPageTalendEditor.this);
+    }
 }


Input:
public void startThread() {
    if (isThreadRunning())
        return;
    HeadsetMode fallbackMode = getHeadsetMode();
    if (getHeadsetMode() == HeadsetMode.WIRED_HEADSET && !headset.isWiredHeadsetOn()) {
        if (listener != null) {
            listener.onServiceFailed();
        }
        return;
    }
    if (getHeadsetMode() == HeadsetMode.BLUETOOTH_HEADSET) {
        if (headset.isBluetoothHeadsetOn()) {
            if (!headset.isBluetoothScoOn()) {
                headset.setBluetoothScoOn(true);
                if (!headset.waitForBluetoothSco()) {
                    headset.setBluetoothScoOn(false);
                    fallbackMode = HeadsetMode.WIRED_HEADSET;
                }
            }
        } else {
            fallbackMode = HeadsetMode.WIRED_HEADSET;
        }
        if (fallbackMode == HeadsetMode.WIRED_HEADSET && !headset.isWiredHeadsetOn()) {
            if (listener != null) {
                listener.onServiceFailed();
            }
            return;
        }
    }
    if (!initAudioDevices(fallbackMode)) {
        if (listener != null) {
            listener.onServiceFailed();
        }
        return;
    }
    headset.restoreVolumeLevel(getHeadsetMode());
    thread = createAudioThread(input, output);
    if (threadParams != null) {
        thread.configure(threadParams);
    }
    thread.start();
}

Output:
         return;
-    HeadsetMode fallbackMode = getHeadsetMode();
-    if (getHeadsetMode() == HeadsetMode.WIRED_HEADSET && !headset.isWiredHeadsetOn()) {
-        if (listener != null) {
-            listener.onServiceFailed();
-        }
-        return;
-    }
-    if (getHeadsetMode() == HeadsetMode.BLUETOOTH_HEADSET) {
+    setActualHeadsetMode(getHeadsetMode());
+    if (getActualHeadsetMode() == HeadsetMode.BLUETOOTH_HEADSET) {
         if (headset.isBluetoothHeadsetOn()) {


Input:
protected boolean releaseAll(long deadline) {
    long threadId = Thread.currentThread().getId();
    boolean removed = false;
    final int reason = deadline == Long.MAX_VALUE ? FactoryConstants.CR_POOL_CLOSE : FactoryConstants.CR_IDLE;
    Iterator<Entry> iterator = entries.values().iterator();
    while (iterator.hasNext()) {
        Entry e = iterator.next();
        if ((deadline > e.lastReleaseTime && e.owner == -1)) {
            if (Unsafe.getUnsafe().compareAndSwapLong(e, ENTRY_OWNER, -1L, threadId)) {
                closeWriter(threadId, e, FactoryEventListener.EV_EXPIRE, FactoryEventListener.EV_EXPIRE_EX, reason);
                iterator.remove();
                removed = true;
                Unsafe.getUnsafe().putOrderedLong(e, ENTRY_OWNER, -1L);
            }
        } else if (e.ex != null) {
            LOG.info().$("String_Node_Str").$();
            iterator.remove();
            removed = true;
        }
    }
    return removed;
}

Output:
 protected boolean releaseAll(long deadline) {
-    long threadId = Thread.currentThread().getId();
+    long thread = Thread.currentThread().getId();
     boolean removed = false;


Input:
public void fillContextMenu(TreeObject xobject, IMenuManager manager) {
    switch(xobject.getType()) {
        case TreeObject._SERVER_:
            manager.add(new VersioningXObjectAction(ServerView.show(), VersioningXObjectAction.ACTION_TYPE_TAGUNIVERSE));
            break;
        default:
            if (xobject.getType() != TreeObject.WORKFLOW_PROCESS && xobject.getType() != TreeObject.JOB && Util.hasTags(xobject))
                manager.add(new VersioningXObjectAction(ServerView.show(), VersioningXObjectAction.ACTION_TYPE_VERSIONS));
            break;
    }
}

Output:
         default:
-            if (xobject.getType() != TreeObject.WORKFLOW_PROCESS && xobject.getType() != TreeObject.JOB && Util.hasTags(xobject))
+            if (xobject.getType() != TreeObject.WORKFLOW_PROCESS && xobject.getType() != TreeObject.JOB && Util.hasTags(xobject) && xobject.getType() != TreeObject.DATA_MODEL_TYPES_RESOURCE && xobject.getType() != TreeObject.DATA_MODEL_RESOURCE)
                 manager.add(new VersioningXObjectAction(ServerView.show(), VersioningXObjectAction.ACTION_TYPE_VERSIONS));


Input:
public Map<String, String> getMap() {
    return null;
}

Output:
 public Map<String, String> getMap() {
-    return null;
+    return map;
 }


Input:
public Object invoke(XRServiceAdapter xrService, Invocation invocation) {
    DatabaseQuery query = queryHandler.getDatabaseQuery();
    Vector queryArguments = query.getArguments();
    int queryArgumentsSize = queryArguments.size();
    Vector executeArguments = new NonSynchronizedVector();
    for (int i = 0; i < queryArgumentsSize; i++) {
        String argName = (String) queryArguments.get(i);
        executeArguments.add(invocation.getParameter(argName));
    }
    Object value = xrService.getORSession().getActiveSession().executeQuery(query, executeArguments);
    if (value != null) {
        if (isSimpleXMLFormat()) {
            value = createSimpleXMLFormat(xrService, value);
        } else {
            QName resultType = getResultType();
            if (isAttachment() || (!isCollection() && resultType.equals(BASE_64_BINARY_QNAME))) {
                String mimeType = DEFAULT_ATTACHMENT_MIMETYPE;
                if (isAttachment() && result.getAttachment().getMimeType() != null) {
                    mimeType = result.getAttachment().getMimeType();
                }
                return AttachmentHelper.buildAttachmentHandler((byte[]) value, mimeType);
            }
            if (resultType != null && resultType.getNamespaceURI().equals(W3C_XML_SCHEMA_NS_URI)) {
                ValueObject vo = new ValueObject();
                vo.value = value;
                value = vo;
            }
        }
    }
    return value;
}

Output:
     DatabaseQuery query = queryHandler.getDatabaseQuery();
-    Vector queryArguments = query.getArguments();
+    List queryArguments = query.getArguments();
     int queryArgumentsSize = queryArguments.size();


Input:
private synchronized void _openWebSocket() {
    if (!_stopRequested) {
        MultiMap map = new CaseInsensitiveMultiMap();
        map.add("String_Node_Str", "String_Node_Str");
        _client.setConnectTimeout(100000000);
        _client.connectWebsocket("String_Node_Str", WebSocketVersion.RFC6455, map, new Handler<WebSocket>() {

            public void handle(WebSocket websocket) {
                JsonObject msg = new JsonObject().putString("String_Node_Str", "String_Node_Str").putString("String_Node_Str", _address);
                websocket.writeTextFrame(msg.encode());
                _websocket = websocket;
                websocket.dataHandler(new Handler<Buffer>() {
                    public void handle(Buffer buff) {
                        String msg = buff.toString();
                        JsonObject received = new JsonObject(msg);
                        if (_buffer == null) {
                            _buffer = new ArrayList<StringToken>();
                        }
                        synchronized (_buffer) {
                            _buffer.add(new StringToken(received.getField("String_Node_Str").toString()));
                        }
                        try {
                            getDirector().fireAtCurrentRealTime((Actor) subscribe.getContainer());
                        } catch (IllegalActionException e) {
                            e.printStackTrace();
                        }
                    }
                });
                websocket.closeHandler(new Handler<Void>() {
                    public void handle(final Void event) {
                    }
                });
            }
        });
    }
}

Output:
     if (!_stopRequested) {
-        MultiMap map = new CaseInsensitiveMultiMap();
-        map.add("String_Node_Str", "String_Node_Str");
-        _client.setConnectTimeout(100000000);
-        _client.connectWebsocket("String_Node_Str", WebSocketVersion.RFC6455, map, new Handler<WebSocket>() {
+        _client.connectWebsocket("String_Node_Str", new Handler<WebSocket>() {


Input:
public V replace(Bytes keyBytes, K key, V expectedValue, V newValue, int hash2, long timestamp) {
    lock();
    try {
        long keyLen = keyBytes.remaining();
        hashLookupLiveOnly.startSearch(hash2);
        for (int pos; (pos = hashLookupLiveOnly.nextPos()) >= 0; ) {
            long offset = offsetFromPos(pos);
            NativeBytes entry = entry(offset);
            if (!keyEquals(keyBytes, keyLen, entry))
                continue;
            entry.skip(keyLen);
            if (canReplicate) {
                if (shouldIgnore(entry, timestamp, localIdentifier))
                    return null;
                entry.skip(1);
            }
            return onKeyPresentOnReplace(key, expectedValue, newValue, pos, offset, entry);
        }
        return null;
    } finally {
        unlock();
    }
}

Output:
             }
-            return onKeyPresentOnReplace(key, expectedValue, newValue, pos, offset, entry);
+            return onKeyPresentOnReplace(key, expectedValue, newValue, pos, offset, entry, hashLookupLiveOnly);
         }


Input:
public void doneLoading(FMLLoadCompleteEvent event) {
    int meta = 4;
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xAD6726, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF3D2D2, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x6B566B, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x3D2C1F, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFAFA6C, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x919191, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x9E83B4, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x5F5269, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x742EA8, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x5A8156, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x495B69, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xCB6293, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x395679, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDCA82E, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xC8D4D5, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xA99733, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x08B5C3, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x8E2727, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x7CD3C7, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xD1531E, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x547A38, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x94CC48, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF04040, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF4D603, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFF763C, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xE87400, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x8D7565, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xEFEFEF, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFFA826, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x55E001, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x458FAB, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xA3DEDE, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xAA5BBD, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFF8448, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xB90000, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x887362, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x40AA7D, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xA98DB1, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDCDFA4, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xD89634, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDFD0AA, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xEDEDED, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF28900, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xAB7EE3, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x0064FF, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xBF5E1F, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x808096, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xBAB0A4, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xABCDEF, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xB3B3B3, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta, "String_Node_Str", 0xF2F2F2, DustTypes.METAL_DUST);
    meta = 61;
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x1A89C1, DustTypes.GEM_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x92A6B8, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFFDB50, DustTypes.SULFUR_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDEDEDE, DustTypes.SALTPETER_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xBAC5F2, DustTypes.CERTUS_QUARTZ_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF0D467, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF4CCEC, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF0A8A4, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x959E99, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFF5B00, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xE7D648, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x4B7A9A, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x0F7575, DustTypes.ENDERIUM_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x949494, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xE47700, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xB2D44D, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x942323, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x945758, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x2E6C3D, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x4B4B4B, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x654D31, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta, "String_Node_Str", 0x6700BE, DustTypes.METAL_DUST);
    meta = 84;
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xD7EF00, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x515151, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x0087EF, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x1B00E6, DustTypes.METAL_DUST);
    BCAItemManager.dusts.addDust(meta, "String_Node_Str", 0xEF00EF, DustTypes.METAL_DUST);
    addOreDictDusterRecipe("String_Node_Str", "String_Node_Str", 6);
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 3, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 4, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, "String_Node_Str", "String_Node_Str", "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, Blocks.soul_sand, "String_Node_Str");
    addDustRecipe("String_Node_Str", 1, Blocks.sand, "String_Node_Str");
    addDustSmelting("String_Node_Str", 1, "String_Node_Str");
    addDustSmelting("String_Node_Str", 1, "String_Node_Str");
}

Output:
     BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0x92A6B8, DustTypes.METAL_DUST);
-    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFFDB50, DustTypes.SULFUR_DUST);
-    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDEDEDE, DustTypes.SALTPETER_DUST);
-    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xBAC5F2, DustTypes.CERTUS_QUARTZ_DUST);
+    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xFFDB50, new DustTypes.SimpleDustWithOre(6));
+    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xDEDEDE, new DustTypes.SimpleDustWithOre(4));
+    BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xBAC5F2, new DustTypes.SimpleDustWithOre(2));
     BCAItemManager.dusts.addDust(meta++, "String_Node_Str", 0xF0D467, DustTypes.METAL_DUST);


Input:
private void configure(URI uri, HttpURLConnection urlConnection, Request request) throws IOException, AuthenticationException {
    PerRequestConfig conf = request.getPerRequestConfig();
    int requestTimeout = (conf != null && conf.getRequestTimeoutInMs() != 0) ? conf.getRequestTimeoutInMs() : config.getRequestTimeoutInMs();
    urlConnection.setConnectTimeout(config.getConnectionTimeoutInMs());
    if (requestTimeout != -1)
        urlConnection.setReadTimeout(requestTimeout);
    urlConnection.setInstanceFollowRedirects(false);
    String host = uri.getHost();
    String method = request.getMethod();
    if (request.getVirtualHost() != null) {
        host = request.getVirtualHost();
    }
    if (uri.getPort() == -1) {
        urlConnection.setRequestProperty("String_Node_Str", host);
    } else {
        urlConnection.setRequestProperty("String_Node_Str", host + "String_Node_Str" + uri.getPort());
    }
    if (config.isCompressionEnabled()) {
        urlConnection.setRequestProperty("String_Node_Str", "String_Node_Str");
    }
    boolean contentTypeSet = false;
    if (!method.equalsIgnoreCase("String_Node_Str")) {
        FluentCaseInsensitiveStringsMap h = request.getHeaders();
        if (h != null) {
            for (String name : h.keySet()) {
                if (!"String_Node_Str".equalsIgnoreCase(name)) {
                    for (String value : h.get(name)) {
                        urlConnection.setRequestProperty(name, value);
                        if (name.equalsIgnoreCase("String_Node_Str")) {
                            throw new IllegalStateException("String_Node_Str");
                        }
                    }
                }
            }
        }
    }
    String ka = config.getAllowPoolingConnection() ? "String_Node_Str" : "String_Node_Str";
    urlConnection.setRequestProperty("String_Node_Str", ka);
    ProxyServer proxyServer = request.getProxyServer() != null ? request.getProxyServer() : config.getProxyServer();
    if (proxyServer != null) {
        urlConnection.setRequestProperty("String_Node_Str", ka);
        if (proxyServer.getPrincipal() != null) {
            urlConnection.setRequestProperty("String_Node_Str", AuthenticatorUtils.computeBasicAuthentication(proxyServer));
        }
    }
    Realm realm = request.getRealm() != null ? request.getRealm() : config.getRealm();
    if (realm != null && realm.getUsePreemptiveAuth()) {
        switch(realm.getAuthScheme()) {
            case BASIC:
                urlConnection.setRequestProperty("String_Node_Str", AuthenticatorUtils.computeBasicAuthentication(realm));
                break;
            case DIGEST:
                if (realm.getNonce() != null && !realm.getNonce().equals("String_Node_Str")) {
                    try {
                        urlConnection.setRequestProperty("String_Node_Str", AuthenticatorUtils.computeDigestAuthentication(realm));
                    } catch (NoSuchAlgorithmException e) {
                        throw new SecurityException(e);
                    }
                }
                break;
            case NTLM:
                jdkNtlmDomain = System.getProperty(NTLM_DOMAIN);
                System.setProperty(NTLM_DOMAIN, realm.getDomain());
                break;
            default:
                throw new IllegalStateException(String.format("String_Node_Str", realm.toString()));
        }
    }
    if (request.getHeaders().getFirstValue("String_Node_Str") == null) {
        urlConnection.setRequestProperty("String_Node_Str", "String_Node_Str");
    }
    if (request.getHeaders().getFirstValue("String_Node_Str") == null && config.getUserAgent() != null) {
        urlConnection.setRequestProperty("String_Node_Str", config.getUserAgent());
    } else {
        urlConnection.setRequestProperty("String_Node_Str", AsyncHttpProviderUtils.constructUserAgent(JDKAsyncHttpProvider.class));
    }
    if (request.getCookies() != null && !request.getCookies().isEmpty()) {
        urlConnection.setRequestProperty("String_Node_Str", AsyncHttpProviderUtils.encodeCookies(request.getCookies()));
    }
    String reqType = request.getMethod();
    urlConnection.setRequestMethod(reqType);
    if ("String_Node_Str".equals(reqType) || "String_Node_Str".equals(reqType)) {
        urlConnection.setRequestProperty("String_Node_Str", "String_Node_Str");
        urlConnection.setDoOutput(true);
        if (cachedBytes != null) {
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(cachedBytesLenght));
            urlConnection.setFixedLengthStreamingMode(cachedBytesLenght);
            urlConnection.getOutputStream().write(cachedBytes, 0, cachedBytesLenght);
        } else if (request.getByteData() != null) {
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(request.getByteData().length));
            urlConnection.setFixedLengthStreamingMode(request.getByteData().length);
            urlConnection.getOutputStream().write(request.getByteData());
        } else if (request.getStringData() != null) {
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(request.getStringData().length()));
            urlConnection.getOutputStream().write(request.getStringData().getBytes("String_Node_Str"));
        } else if (request.getStreamData() != null) {
            int[] lengthWrapper = new int[1];
            cachedBytes = AsyncHttpProviderUtils.readFully(request.getStreamData(), lengthWrapper);
            cachedBytesLenght = lengthWrapper[0];
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(cachedBytesLenght));
            urlConnection.setFixedLengthStreamingMode(cachedBytesLenght);
            urlConnection.getOutputStream().write(cachedBytes, 0, cachedBytesLenght);
        } else if (request.getParams() != null) {
            StringBuilder sb = new StringBuilder();
            for (final Map.Entry<String, List<String>> paramEntry : request.getParams()) {
                final String key = paramEntry.getKey();
                for (final String value : paramEntry.getValue()) {
                    if (sb.length() > 0) {
                        sb.append("String_Node_Str");
                    }
                    UTF8UrlEncoder.appendEncoded(sb, key);
                    sb.append("String_Node_Str");
                    UTF8UrlEncoder.appendEncoded(sb, value);
                }
            }
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(sb.length()));
            urlConnection.setFixedLengthStreamingMode(sb.length());
            if (!request.getHeaders().containsKey("String_Node_Str")) {
                urlConnection.setRequestProperty("String_Node_Str", "String_Node_Str");
            }
            urlConnection.getOutputStream().write(sb.toString().getBytes("String_Node_Str"));
        } else if (request.getParts() != null) {
            int lenght = (int) request.getLength();
            if (lenght != -1) {
                urlConnection.setRequestProperty("String_Node_Str", String.valueOf(lenght));
                urlConnection.setFixedLengthStreamingMode(lenght);
            }
            if (lenght == -1) {
                lenght = MAX_BUFFERED_BYTES;
            }
            MultipartRequestEntity mre = AsyncHttpProviderUtils.createMultipartRequestEntity(request.getParts(), request.getParams());
            urlConnection.setRequestProperty("String_Node_Str", mre.getContentType());
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(mre.getContentLength()));
            ChannelBuffer b = ChannelBuffers.dynamicBuffer(lenght);
            mre.writeRequest(urlConnection.getOutputStream());
        } else if (request.getEntityWriter() != null) {
            int lenght = (int) request.getLength();
            if (lenght != -1) {
                urlConnection.setRequestProperty("String_Node_Str", String.valueOf(lenght));
                urlConnection.setFixedLengthStreamingMode(lenght);
            }
            request.getEntityWriter().writeEntity(urlConnection.getOutputStream());
        } else if (request.getFile() != null) {
            File file = request.getFile();
            if (!file.isFile()) {
                throw new IOException(String.format(Thread.currentThread() + "String_Node_Str", file.getAbsolutePath()));
            }
            urlConnection.setRequestProperty("String_Node_Str", String.valueOf(file.length()));
            urlConnection.setFixedLengthStreamingMode((int) file.length());
            FileInputStream fis = new FileInputStream(file);
            try {
                OutputStream os = urlConnection.getOutputStream();
                for (final byte[] buffer = new byte[1024 * 16]; ; ) {
                    int read = fis.read(buffer);
                    if (read < 0) {
                        break;
                    }
                    os.write(buffer, 0, read);
                }
            } finally {
                fis.close();
            }
        } else if (request.getBodyGenerator() != null) {
            Body body = request.getBodyGenerator().createBody();
            try {
                int length = (int) body.getContentLength();
                if (length < 0) {
                    length = (int) request.getLength();
                }
                if (length >= 0) {
                    urlConnection.setRequestProperty("String_Node_Str", String.valueOf(length));
                    urlConnection.setFixedLengthStreamingMode(length);
                }
                OutputStream os = urlConnection.getOutputStream();
                for (ByteBuffer buffer = ByteBuffer.allocate(1024 * 8); ; ) {
                    buffer.clear();
                    if (body.read(buffer) < 0) {
                        break;
                    }
                    os.write(buffer.array(), buffer.arrayOffset(), buffer.position());
                }
            } finally {
                try {
                    body.close();
                } catch (IOException e) {
                    logger.warn("String_Node_Str", e.getMessage(), e);
                }
            }
        }
    }
}

Output:
             urlConnection.setRequestProperty("String_Node_Str", String.valueOf(request.getStringData().length()));
-            urlConnection.getOutputStream().write(request.getStringData().getBytes("String_Node_Str"));
+            byte[] b = request.getStringData().getBytes("String_Node_Str");
+            urlConnection.setFixedLengthStreamingMode(b.length);
+            urlConnection.getOutputStream().write(b);
         } else if (request.getStreamData() != null) {


Input:
public void testCreateConsumer() throws Exception {
    final ConsumerConfig consumerConfig = new ConsumerConfig();
    consumerConfig.setGroup("String_Node_Str");
    final MessageConsumer messageConsumer = this.messageSessionFactory.createConsumer(consumerConfig);
    assertNotNull(messageConsumer);
    assertTrue(this.messageSessionFactory.getChildren().contains(messageConsumer));
    messageConsumer.shutdown();
    assertFalse(this.messageSessionFactory.getChildren().contains(messageConsumer));
}

Output:
     consumerConfig.setGroup("String_Node_Str");
-    final MessageConsumer messageConsumer = this.messageSessionFactory.createConsumer(consumerConfig);
+    final MessageConsumer messageConsumer = messageSessionFactory.createConsumer(consumerConfig);
     assertNotNull(messageConsumer);


Input:
public void actionPerformed(ActionEvent e) {
    traceInput();
    if (e.getActionCommand().equals("String_Node_Str")) {
        NamedClass nc = classesTable.getSelectedClass(currentClassIndex);
        if (!showingMultiTables) {
        }
        if (showingMultiTables && showingEquivalentSuggestions) {
            if (defaultSuperMap.get(nc) != null) {
                showSuperSuggestions(nc);
                showSingleTable();
            } else {
                currentClassIndex++;
                classesTable.setSelectedClass(currentClassIndex);
                graphPanel.setConcept(classesTable.getSelectedClass(currentClassIndex));
                showEquivalentSuggestions(classesTable.getSelectedClass(currentClassIndex));
                showSingleTable();
            }
        } else if (!showingMultiTables && showingEquivalentSuggestions) {
            if (owlEquivalenceStandardMap.get(nc) != null) {
                showMultiTables();
            } else if (defaultSuperMap.get(nc) != null) {
                showSuperSuggestions(nc);
                showSingleTable();
                if (currentClassIndex + 1 >= defaultEquivalenceMap.keySet().size()) {
                    nextFinishButton.setText("String_Node_Str");
                    nextFinishButton.setActionCommand("String_Node_Str");
                }
            } else {
                currentClassIndex++;
                classesTable.setSelectedClass(currentClassIndex);
                graphPanel.setConcept(classesTable.getSelectedClass(currentClassIndex));
                showEquivalentSuggestions(classesTable.getSelectedClass(currentClassIndex));
                showSingleTable();
            }
        } else if (!showingMultiTables && !showingEquivalentSuggestions) {
            if (owlSuperStandardMap.get(nc) != null) {
                showMultiTables();
            } else {
                currentClassIndex++;
                classesTable.setSelectedClass(currentClassIndex);
                NamedClass newNc = classesTable.getSelectedClass(currentClassIndex);
                graphPanel.setConcept(newNc);
                if (defaultEquivalenceMap.get(newNc) != null) {
                    showEquivalentSuggestions(newNc);
                } else {
                    showSuperSuggestions(newNc);
                }
                showSingleTable();
            }
        } else {
            currentClassIndex++;
            classesTable.setSelectedClass(currentClassIndex);
            graphPanel.setConcept(classesTable.getSelectedClass(currentClassIndex));
            showEquivalentSuggestions(classesTable.getSelectedClass(currentClassIndex));
            showSingleTable();
        }
        setFinished();
        resetSingleTablePanel();
    } else if (e.getActionCommand().equals("String_Node_Str")) {
        closeDialog();
        saveInput();
    }
}

Output:
             classesTable.setSelectedClass(currentClassIndex);
-            graphPanel.setConcept(classesTable.getSelectedClass(currentClassIndex));
-            showEquivalentSuggestions(classesTable.getSelectedClass(currentClassIndex));
+            NamedClass newCl = classesTable.getSelectedClass(currentClassIndex);
+            graphPanel.setConcept(newCl);
+            if (defaultEquivalenceMap.containsKey(newCl)) {
+                showEquivalentSuggestions(newCl);
+            } else {
+                showSuperSuggestions(newCl);
+            }
             showSingleTable();


Input:
private VmResultObject composeResultObject(UserVmVO vm, ManagementServer ms) {
    if (vm == null)
        return null;
    VmResultObject resultObj = new VmResultObject();
    Account acct = ms.findAccountById(Long.valueOf(vm.getAccountId()));
    resultObj.setAccount(acct.getAccountName());
    ServiceOfferingVO offering = ms.findServiceOfferingById(vm.getServiceOfferingId());
    resultObj.setCpuSpeed(offering.getSpeed());
    resultObj.setMemory(offering.getRamSize());
    if (offering.getDisplayText() != null)
        resultObj.setServiceOfferingName(offering.getDisplayText());
    else
        resultObj.setServiceOfferingName(offering.getName());
    resultObj.setServiceOfferingId(vm.getServiceOfferingId());
    VmStats vmStats = ms.getVmStatistics(vm.getId());
    if (vmStats != null) {
        resultObj.setCpuUsed((long) vmStats.getCPUUtilization());
        resultObj.setNetworkKbsRead((long) vmStats.getNetworkReadKBs());
        resultObj.setNetworkKbsWrite((long) vmStats.getNetworkWriteKBs());
    }
    resultObj.setCreated(vm.getCreated());
    resultObj.setDisplayName(vm.getDisplayName());
    resultObj.setDomain(ms.findDomainIdById(acct.getDomainId()).getName());
    resultObj.setDomainId(acct.getDomainId());
    resultObj.setHaEnable(vm.isHaEnabled());
    if (vm.getHostId() != null) {
        resultObj.setHostId(vm.getHostId());
        resultObj.setHostName(ms.getHostBy(vm.getHostId()).getName());
    }
    resultObj.setIpAddress(vm.getPrivateIpAddress());
    resultObj.setName(vm.getName());
    resultObj.setState(vm.getState().toString());
    resultObj.setZoneId(vm.getDataCenterId());
    resultObj.setZoneName(ms.findDataCenterById(vm.getDataCenterId()).getName());
    VMTemplateVO template = ms.findTemplateById(vm.getTemplateId());
    resultObj.setPasswordEnabled(template.getEnablePassword());
    resultObj.setTemplateDisplayText(template.getDisplayText());
    resultObj.setTemplateId(template.getId());
    resultObj.setTemplateName(template.getName());
    return resultObj;
}

Output:
     resultObj.setMemory(offering.getRamSize());
-    if (offering.getDisplayText() != null)
-        resultObj.setServiceOfferingName(offering.getDisplayText());
-    else
+    if (offering.getName() != null)
         resultObj.setServiceOfferingName(offering.getName());


Input:
protected final boolean determineElementFlushers(UpdateContext context, TypeDescriptor typeDescriptor, List<CollectionElementAttributeFlusher<E, V>> elementFlushers, Iterable<?> current) {
    if (typeDescriptor.shouldFlushMutations()) {
        if (typeDescriptor.isSubview()) {
            final ViewToEntityMapper mapper = typeDescriptor.getViewToEntityMapper();
            if (typeDescriptor.isIdentifiable()) {
                for (Object o : current) {
                    if (o instanceof MutableStateTrackable) {
                        MutableStateTrackable element = (MutableStateTrackable) o;
                        DirtyAttributeFlusher<?, E, V> flusher = (DirtyAttributeFlusher<?, E, V>) mapper.getNestedDirtyFlusher(context, element, null);
                        if (flusher != null) {
                            elementFlushers.add(new UpdateCollectionElementAttributeFlusher<E, V>(flusher, element, optimisticLockProtected, mapper));
                        }
                    }
                }
            } else {
                for (Object o : current) {
                    if (o instanceof MutableStateTrackable) {
                        MutableStateTrackable element = (MutableStateTrackable) o;
                        DirtyAttributeFlusher<?, E, V> flusher = (DirtyAttributeFlusher<?, E, V>) mapper.getNestedDirtyFlusher(context, element, null);
                        if (flusher != null) {
                            return true;
                        }
                    }
                }
            }
        } else if (typeDescriptor.isJpaEntity()) {
            for (Object element : current) {
                if (typeDescriptor.getBasicUserType().shouldPersist(element) && typeDescriptor.shouldJpaPersist()) {
                    elementFlushers.add(new PersistCollectionElementAttributeFlusher<E, V>(element, optimisticLockProtected));
                } else if (typeDescriptor.shouldJpaMerge()) {
                    return true;
                }
            }
        } else if (typeDescriptor.getBasicUserType().supportsDirtyChecking()) {
            for (Object element : current) {
                String[] dirtyProperties = typeDescriptor.getBasicUserType().getDirtyProperties(element);
                if (dirtyProperties != null) {
                    return true;
                }
            }
        } else {
            throw new IllegalArgumentException("String_Node_Str" + typeDescriptor);
        }
    }
    return false;
}

Output:
                         MutableStateTrackable element = (MutableStateTrackable) o;
-                        DirtyAttributeFlusher<?, E, V> flusher = (DirtyAttributeFlusher<?, E, V>) mapper.getNestedDirtyFlusher(context, element, null);
+                        DirtyAttributeFlusher<?, E, V> flusher = (DirtyAttributeFlusher<?, E, V>) (DirtyAttributeFlusher) mapper.getNestedDirtyFlusher(context, element, (DirtyAttributeFlusher) null);
                         if (flusher != null) {


Input:
private void scatter(Graphics g, MeasureCollection m, double variedParamValue) {
    int height = getHeight();
    int width = getWidth();
    int x = (int) (width * variedParamValue);
    double value = m.getLastValue(this.measureSelected);
    if (Double.isNaN(value)) {
        return;
    }
    int y = (int) (height - (value / this.max_value) * height);
    g.fillOval(x - DOT_SIZE / 2, y - DOT_SIZE / 2, DOT_SIZE, DOT_SIZE);
}

Output:
     }
-    int y = (int) (height - (value / this.max_value) * height);
+    int y = (int) (height - (value / this.upper_value) * height);
     g.fillOval(x - DOT_SIZE / 2, y - DOT_SIZE / 2, DOT_SIZE, DOT_SIZE);


Input:
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    channel.write(new InvocationRequest(method.getDeclaringClass().getName(), method.getName(), toSerializable(args), foldClassesToStrings(new HashSet<Class<?>>(Arrays.asList(method.getParameterTypes())))));
    return null;
}

Output:
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-    channel.write(new InvocationRequest(method.getDeclaringClass().getName(), method.getName(), toSerializable(args), foldClassesToStrings(new HashSet<Class<?>>(Arrays.asList(method.getParameterTypes())))));
+    channel.write(new InvocationRequest(method.getDeclaringClass().getName(), method.getName(), toSerializable(args), foldClassesToStrings(Arrays.asList(method.getParameterTypes()))));
     return null;