Input:
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
    switch(code) {
        case START_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                Intent intent = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
                int grantedMode = data.readInt();
                IBinder resultTo = data.readStrongBinder();
                String resultWho = data.readString();
                int requestCode = data.readInt();
                boolean onlyIfNeeded = data.readInt() != 0;
                boolean debug = data.readInt() != 0;
                int result = startActivity(app, intent, resolvedType, grantedUriPermissions, grantedMode, resultTo, resultWho, requestCode, onlyIfNeeded, debug);
                reply.writeNoException();
                reply.writeInt(result);
                return true;
            }
        case START_NEXT_MATCHING_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder callingActivity = data.readStrongBinder();
                Intent intent = Intent.CREATOR.createFromParcel(data);
                boolean result = startNextMatchingActivity(callingActivity, intent);
                reply.writeNoException();
                reply.writeInt(result ? 1 : 0);
                return true;
            }
        case FINISH_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Intent resultData = null;
                int resultCode = data.readInt();
                if (data.readInt() != 0) {
                    resultData = Intent.CREATOR.createFromParcel(data);
                }
                boolean res = finishActivity(token, resultCode, resultData);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case FINISH_SUB_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                String resultWho = data.readString();
                int requestCode = data.readInt();
                finishSubActivity(token, resultWho, requestCode);
                reply.writeNoException();
                return true;
            }
        case REGISTER_RECEIVER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
                b = data.readStrongBinder();
                IIntentReceiver rec = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
                IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
                String perm = data.readString();
                Intent intent = registerReceiver(app, rec, filter, perm);
                reply.writeNoException();
                if (intent != null) {
                    reply.writeInt(1);
                    intent.writeToParcel(reply, 0);
                } else {
                    reply.writeInt(0);
                }
                return true;
            }
        case UNREGISTER_RECEIVER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                if (b == null) {
                    return true;
                }
                IIntentReceiver rec = IIntentReceiver.Stub.asInterface(b);
                unregisterReceiver(rec);
                reply.writeNoException();
                return true;
            }
        case BROADCAST_INTENT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
                Intent intent = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                b = data.readStrongBinder();
                IIntentReceiver resultTo = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
                int resultCode = data.readInt();
                String resultData = data.readString();
                Bundle resultExtras = data.readBundle();
                String perm = data.readString();
                boolean serialized = data.readInt() != 0;
                boolean sticky = data.readInt() != 0;
                int res = broadcastIntent(app, intent, resolvedType, resultTo, resultCode, resultData, resultExtras, perm, serialized, sticky);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case UNBROADCAST_INTENT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = b != null ? ApplicationThreadNative.asInterface(b) : null;
                Intent intent = Intent.CREATOR.createFromParcel(data);
                unbroadcastIntent(app, intent);
                reply.writeNoException();
                return true;
            }
        case FINISH_RECEIVER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder who = data.readStrongBinder();
                int resultCode = data.readInt();
                String resultData = data.readString();
                Bundle resultExtras = data.readBundle();
                boolean resultAbort = data.readInt() != 0;
                if (who != null) {
                    finishReceiver(who, resultCode, resultData, resultExtras, resultAbort);
                }
                reply.writeNoException();
                return true;
            }
        case SET_PERSISTENT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                boolean isPersistent = data.readInt() != 0;
                if (token != null) {
                    setPersistent(token, isPersistent);
                }
                reply.writeNoException();
                return true;
            }
        case ATTACH_APPLICATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IApplicationThread app = ApplicationThreadNative.asInterface(data.readStrongBinder());
                if (app != null) {
                    attachApplication(app);
                }
                reply.writeNoException();
                return true;
            }
        case ACTIVITY_IDLE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                if (token != null) {
                    activityIdle(token);
                }
                reply.writeNoException();
                return true;
            }
        case ACTIVITY_PAUSED_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Bundle map = data.readBundle();
                activityPaused(token, map);
                reply.writeNoException();
                return true;
            }
        case ACTIVITY_STOPPED_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Bitmap thumbnail = data.readInt() != 0 ? Bitmap.CREATOR.createFromParcel(data) : null;
                CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
                activityStopped(token, thumbnail, description);
                reply.writeNoException();
                return true;
            }
        case ACTIVITY_DESTROYED_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                activityDestroyed(token);
                reply.writeNoException();
                return true;
            }
        case GET_CALLING_PACKAGE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                String res = token != null ? getCallingPackage(token) : null;
                reply.writeNoException();
                reply.writeString(res);
                return true;
            }
        case GET_CALLING_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                ComponentName cn = getCallingActivity(token);
                reply.writeNoException();
                ComponentName.writeToParcel(cn, reply);
                return true;
            }
        case GET_TASKS_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int maxNum = data.readInt();
                int fl = data.readInt();
                IBinder receiverBinder = data.readStrongBinder();
                IThumbnailReceiver receiver = receiverBinder != null ? IThumbnailReceiver.Stub.asInterface(receiverBinder) : null;
                List list = getTasks(maxNum, fl, receiver);
                reply.writeNoException();
                int N = list != null ? list.size() : -1;
                reply.writeInt(N);
                int i;
                for (i = 0; i < N; i++) {
                    ActivityManager.RunningTaskInfo info = (ActivityManager.RunningTaskInfo) list.get(i);
                    info.writeToParcel(reply, 0);
                }
                return true;
            }
        case GET_RECENT_TASKS_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int maxNum = data.readInt();
                int fl = data.readInt();
                List<ActivityManager.RecentTaskInfo> list = getRecentTasks(maxNum, fl);
                reply.writeNoException();
                reply.writeTypedList(list);
                return true;
            }
        case GET_SERVICES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int maxNum = data.readInt();
                int fl = data.readInt();
                List list = getServices(maxNum, fl);
                reply.writeNoException();
                int N = list != null ? list.size() : -1;
                reply.writeInt(N);
                int i;
                for (i = 0; i < N; i++) {
                    ActivityManager.RunningServiceInfo info = (ActivityManager.RunningServiceInfo) list.get(i);
                    info.writeToParcel(reply, 0);
                }
                return true;
            }
        case GET_PROCESSES_IN_ERROR_STATE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                List<ActivityManager.ProcessErrorStateInfo> list = getProcessesInErrorState();
                reply.writeNoException();
                reply.writeTypedList(list);
                return true;
            }
        case GET_RUNNING_APP_PROCESSES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                List<ActivityManager.RunningAppProcessInfo> list = getRunningAppProcesses();
                reply.writeNoException();
                reply.writeTypedList(list);
                return true;
            }
        case MOVE_TASK_TO_FRONT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int task = data.readInt();
                moveTaskToFront(task);
                reply.writeNoException();
                return true;
            }
        case MOVE_TASK_TO_BACK_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int task = data.readInt();
                moveTaskToBack(task);
                reply.writeNoException();
                return true;
            }
        case MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                boolean nonRoot = data.readInt() != 0;
                boolean res = moveActivityTaskToBack(token, nonRoot);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case MOVE_TASK_BACKWARDS_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int task = data.readInt();
                moveTaskBackwards(task);
                reply.writeNoException();
                return true;
            }
        case GET_TASK_FOR_ACTIVITY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                boolean onlyRoot = data.readInt() != 0;
                int res = token != null ? getTaskForActivity(token, onlyRoot) : -1;
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case FINISH_OTHER_INSTANCES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                ComponentName className = ComponentName.readFromParcel(data);
                finishOtherInstances(token, className);
                reply.writeNoException();
                return true;
            }
        case REPORT_THUMBNAIL_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Bitmap thumbnail = data.readInt() != 0 ? Bitmap.CREATOR.createFromParcel(data) : null;
                CharSequence description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(data);
                reportThumbnail(token, thumbnail, description);
                reply.writeNoException();
                return true;
            }
        case GET_CONTENT_PROVIDER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                String name = data.readString();
                ContentProviderHolder cph = getContentProvider(app, name);
                reply.writeNoException();
                if (cph != null) {
                    reply.writeInt(1);
                    cph.writeToParcel(reply, 0);
                } else {
                    reply.writeInt(0);
                }
                return true;
            }
        case PUBLISH_CONTENT_PROVIDERS_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                ArrayList<ContentProviderHolder> providers = data.createTypedArrayList(ContentProviderHolder.CREATOR);
                publishContentProviders(app, providers);
                reply.writeNoException();
                return true;
            }
        case REMOVE_CONTENT_PROVIDER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                String name = data.readString();
                removeContentProvider(app, name);
                reply.writeNoException();
                return true;
            }
        case START_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                Intent service = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                ComponentName cn = startService(app, service, resolvedType);
                reply.writeNoException();
                ComponentName.writeToParcel(cn, reply);
                return true;
            }
        case STOP_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                Intent service = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                int res = stopService(app, service, resolvedType);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case STOP_SERVICE_TOKEN_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ComponentName className = ComponentName.readFromParcel(data);
                IBinder token = data.readStrongBinder();
                int startId = data.readInt();
                boolean res = stopServiceToken(className, token, startId);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case SET_SERVICE_FOREGROUND_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ComponentName className = ComponentName.readFromParcel(data);
                IBinder token = data.readStrongBinder();
                boolean isForeground = data.readInt() != 0;
                setServiceForeground(className, token, isForeground);
                reply.writeNoException();
                return true;
            }
        case BIND_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                IBinder token = data.readStrongBinder();
                Intent service = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                b = data.readStrongBinder();
                int fl = data.readInt();
                IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
                int res = bindService(app, token, service, resolvedType, conn, fl);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case UNBIND_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IServiceConnection conn = IServiceConnection.Stub.asInterface(b);
                boolean res = unbindService(conn);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case PUBLISH_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Intent intent = Intent.CREATOR.createFromParcel(data);
                IBinder service = data.readStrongBinder();
                publishService(token, intent, service);
                reply.writeNoException();
                return true;
            }
        case UNBIND_FINISHED_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                Intent intent = Intent.CREATOR.createFromParcel(data);
                boolean doRebind = data.readInt() != 0;
                unbindFinished(token, intent, doRebind);
                reply.writeNoException();
                return true;
            }
        case SERVICE_DONE_EXECUTING_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                serviceDoneExecuting(token);
                reply.writeNoException();
                return true;
            }
        case START_INSTRUMENTATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ComponentName className = ComponentName.readFromParcel(data);
                String profileFile = data.readString();
                int fl = data.readInt();
                Bundle arguments = data.readBundle();
                IBinder b = data.readStrongBinder();
                IInstrumentationWatcher w = IInstrumentationWatcher.Stub.asInterface(b);
                boolean res = startInstrumentation(className, profileFile, fl, arguments, w);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case FINISH_INSTRUMENTATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                int resultCode = data.readInt();
                Bundle results = data.readBundle();
                finishInstrumentation(app, resultCode, results);
                reply.writeNoException();
                return true;
            }
        case GET_CONFIGURATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                Configuration config = getConfiguration();
                reply.writeNoException();
                config.writeToParcel(reply, 0);
                return true;
            }
        case UPDATE_CONFIGURATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                Configuration config = Configuration.CREATOR.createFromParcel(data);
                updateConfiguration(config);
                reply.writeNoException();
                return true;
            }
        case SET_REQUESTED_ORIENTATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                int requestedOrientation = data.readInt();
                setRequestedOrientation(token, requestedOrientation);
                reply.writeNoException();
                return true;
            }
        case GET_REQUESTED_ORIENTATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                int req = getRequestedOrientation(token);
                reply.writeNoException();
                reply.writeInt(req);
                return true;
            }
        case GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                ComponentName cn = getActivityClassForToken(token);
                reply.writeNoException();
                ComponentName.writeToParcel(cn, reply);
                return true;
            }
        case GET_PACKAGE_FOR_TOKEN_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                reply.writeNoException();
                reply.writeString(getPackageForToken(token));
                return true;
            }
        case GET_INTENT_SENDER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int type = data.readInt();
                String packageName = data.readString();
                IBinder token = data.readStrongBinder();
                String resultWho = data.readString();
                int requestCode = data.readInt();
                Intent requestIntent = data.readInt() != 0 ? Intent.CREATOR.createFromParcel(data) : null;
                String requestResolvedType = data.readString();
                int fl = data.readInt();
                IIntentSender res = getIntentSender(type, packageName, token, resultWho, requestCode, requestIntent, requestResolvedType, fl);
                reply.writeNoException();
                reply.writeStrongBinder(res != null ? res.asBinder() : null);
                return true;
            }
        case CANCEL_INTENT_SENDER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IIntentSender r = IIntentSender.Stub.asInterface(data.readStrongBinder());
                cancelIntentSender(r);
                reply.writeNoException();
                return true;
            }
        case GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IIntentSender r = IIntentSender.Stub.asInterface(data.readStrongBinder());
                String res = getPackageForIntentSender(r);
                reply.writeNoException();
                reply.writeString(res);
                return true;
            }
        case SET_PROCESS_LIMIT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int max = data.readInt();
                setProcessLimit(max);
                reply.writeNoException();
                return true;
            }
        case GET_PROCESS_LIMIT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int limit = getProcessLimit();
                reply.writeNoException();
                reply.writeInt(limit);
                return true;
            }
        case SET_PROCESS_FOREGROUND_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder token = data.readStrongBinder();
                int pid = data.readInt();
                boolean isForeground = data.readInt() != 0;
                setProcessForeground(token, pid, isForeground);
                reply.writeNoException();
                return true;
            }
        case CHECK_PERMISSION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String perm = data.readString();
                int pid = data.readInt();
                int uid = data.readInt();
                int res = checkPermission(perm, pid, uid);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case CHECK_URI_PERMISSION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                Uri uri = Uri.CREATOR.createFromParcel(data);
                int pid = data.readInt();
                int uid = data.readInt();
                int mode = data.readInt();
                int res = checkUriPermission(uri, pid, uid, mode);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case CLEAR_APP_DATA_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String packageName = data.readString();
                IPackageDataObserver observer = IPackageDataObserver.Stub.asInterface(data.readStrongBinder());
                boolean res = clearApplicationUserData(packageName, observer);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case GRANT_URI_PERMISSION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                String targetPkg = data.readString();
                Uri uri = Uri.CREATOR.createFromParcel(data);
                int mode = data.readInt();
                grantUriPermission(app, targetPkg, uri, mode);
                reply.writeNoException();
                return true;
            }
        case REVOKE_URI_PERMISSION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                Uri uri = Uri.CREATOR.createFromParcel(data);
                int mode = data.readInt();
                revokeUriPermission(app, uri, mode);
                reply.writeNoException();
                return true;
            }
        case SHOW_WAITING_FOR_DEBUGGER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                boolean waiting = data.readInt() != 0;
                showWaitingForDebugger(app, waiting);
                reply.writeNoException();
                return true;
            }
        case GET_MEMORY_INFO_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
                getMemoryInfo(mi);
                reply.writeNoException();
                mi.writeToParcel(reply, 0);
                return true;
            }
        case UNHANDLED_BACK_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                unhandledBack();
                reply.writeNoException();
                return true;
            }
        case OPEN_CONTENT_URI_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                Uri uri = Uri.parse(data.readString());
                ParcelFileDescriptor pfd = openContentUri(uri);
                reply.writeNoException();
                if (pfd != null) {
                    reply.writeInt(1);
                    pfd.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                } else {
                    reply.writeInt(0);
                }
                return true;
            }
        case GOING_TO_SLEEP_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                goingToSleep();
                reply.writeNoException();
                return true;
            }
        case WAKING_UP_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                wakingUp();
                reply.writeNoException();
                return true;
            }
        case SET_DEBUG_APP_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String pn = data.readString();
                boolean wfd = data.readInt() != 0;
                boolean per = data.readInt() != 0;
                setDebugApp(pn, wfd, per);
                reply.writeNoException();
                return true;
            }
        case SET_ALWAYS_FINISH_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                boolean enabled = data.readInt() != 0;
                setAlwaysFinish(enabled);
                reply.writeNoException();
                return true;
            }
        case SET_ACTIVITY_WATCHER_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IActivityWatcher watcher = IActivityWatcher.Stub.asInterface(data.readStrongBinder());
                setActivityWatcher(watcher);
                return true;
            }
        case ENTER_SAFE_MODE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                enterSafeMode();
                reply.writeNoException();
                return true;
            }
        case NOTE_WAKEUP_ALARM_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IIntentSender is = IIntentSender.Stub.asInterface(data.readStrongBinder());
                noteWakeupAlarm(is);
                reply.writeNoException();
                return true;
            }
        case KILL_PIDS_FOR_MEMORY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int[] pids = data.createIntArray();
                boolean res = killPidsForMemory(pids);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case REPORT_PSS_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder b = data.readStrongBinder();
                IApplicationThread app = ApplicationThreadNative.asInterface(b);
                int pss = data.readInt();
                reportPss(app, pss);
                reply.writeNoException();
                return true;
            }
        case START_RUNNING_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String pkg = data.readString();
                String cls = data.readString();
                String action = data.readString();
                String indata = data.readString();
                startRunning(pkg, cls, action, indata);
                reply.writeNoException();
                return true;
            }
        case SYSTEM_READY_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                systemReady();
                reply.writeNoException();
                return true;
            }
        case HANDLE_APPLICATION_ERROR_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                IBinder app = data.readStrongBinder();
                int fl = data.readInt();
                String tag = data.readString();
                String shortMsg = data.readString();
                String longMsg = data.readString();
                byte[] crashData = data.createByteArray();
                int res = handleApplicationError(app, fl, tag, shortMsg, longMsg, crashData);
                reply.writeNoException();
                reply.writeInt(res);
                return true;
            }
        case SIGNAL_PERSISTENT_PROCESSES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                int sig = data.readInt();
                signalPersistentProcesses(sig);
                reply.writeNoException();
                return true;
            }
        case RESTART_PACKAGE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String packageName = data.readString();
                restartPackage(packageName);
                reply.writeNoException();
                return true;
            }
        case GET_DEVICE_CONFIGURATION_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ConfigurationInfo config = getDeviceConfigurationInfo();
                reply.writeNoException();
                config.writeToParcel(reply, 0);
                return true;
            }
        case PROFILE_CONTROL_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String process = data.readString();
                boolean start = data.readInt() != 0;
                String path = data.readString();
                boolean res = profileControl(process, start, path);
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case SHUTDOWN_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                boolean res = shutdown(data.readInt());
                reply.writeNoException();
                reply.writeInt(res ? 1 : 0);
                return true;
            }
        case STOP_APP_SWITCHES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                stopAppSwitches();
                reply.writeNoException();
                return true;
            }
        case RESUME_APP_SWITCHES_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                resumeAppSwitches();
                reply.writeNoException();
                return true;
            }
        case PEEK_SERVICE_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                Intent service = Intent.CREATOR.createFromParcel(data);
                String resolvedType = data.readString();
                IBinder binder = peekService(service, resolvedType);
                reply.writeNoException();
                reply.writeStrongBinder(binder);
                return true;
            }
        case START_BACKUP_AGENT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
                int backupRestoreMode = data.readInt();
                boolean success = bindBackupAgent(info, backupRestoreMode);
                reply.writeNoException();
                reply.writeInt(success ? 1 : 0);
                return true;
            }
        case BACKUP_AGENT_CREATED_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                String packageName = data.readString();
                IBinder agent = data.readStrongBinder();
                backupAgentCreated(packageName, agent);
                reply.writeNoException();
                return true;
            }
        case UNBIND_BACKUP_AGENT_TRANSACTION:
            {
                data.enforceInterface(IActivityManager.descriptor);
                ApplicationInfo info = ApplicationInfo.CREATOR.createFromParcel(data);
                unbindBackupAgent(info);
                reply.writeNoException();
                return true;
            }
    }
    return super.onTransact(code, data, reply, flags);
}

Output:
                 String path = data.readString();
-                boolean res = profileControl(process, start, path);
+                ParcelFileDescriptor fd = data.readInt() != 0 ? data.readFileDescriptor() : null;
+                boolean res = profileControl(process, start, path, fd);
                 reply.writeNoException();


Input:
void doSaveFinish() throws DataException {
    if (needsSaveToDoc() == false)
        return;
    if (isBasicSaved == false) {
        isBasicSaved = true;
        this.getRdSave().saveResultIterator(new DummyCachedResult(), -1, null);
    }
    this.getRdSave().saveFinish(0);
}

Output:
         isBasicSaved = true;
-        this.getRdSave().saveResultIterator(new DummyCachedResult(), -1, null);
+        this.getRdSave().saveResultIterator(new DummyCachedResult(), -1, new int[] { 0, 1 });
     }


Input:
static Intent createOpenCalendarAtDayIntent(Context context, long goToTime) {
    Intent launchIntent = createOpenCalendarIntent();
    Uri.Builder builder = CalendarContract.CONTENT_URI.buildUpon();
    builder.appendPath("String_Node_Str");
    if (goToTime != 0) {
        launchIntent.putExtra(KEY_DETAIL_VIEW, true);
        ContentUris.appendId(builder, goToTime);
    }
    launchIntent.setData(builder.build());
    return launchIntent;
}

Output:
     Uri.Builder builder = CalendarContract.CONTENT_URI.buildUpon();
-    builder.appendPath("String_Node_Str");
+    builder.appendPath(TIME);
     if (goToTime != 0) {


Input:
public void saveAnalysis() throws DataprofilerCoreException {
    for (Domain domain : this.analysisItem.getAnalysis().getParameters().getDataFilter()) {
        domain.setName(this.analysisItem.getAnalysis().getName());
    }
    IRepositoryViewObject reposObject = null;
    Connection tdProvider = null;
    correlationAnalysisHandler.clearAnalysis();
    columnSetMultiIndicator.getAnalyzedColumns().clear();
    Analysis analysis = correlationAnalysisHandler.getAnalysis();
    analysis.getParameters().setExecutionLanguage(ExecutionLanguage.get(execLang));
    correlationAnalysisHandler.setStringDataFilter(dataFilterComp.getDataFilterString());
    List<RepositoryNode> repositoryNodeList = treeViewer.getColumnSetMultiValueList();
    if (repositoryNodeList != null && repositoryNodeList.size() != 0) {
        reposObject = repositoryNodeList.get(0).getObject();
        tdProvider = ((ConnectionItem) reposObject.getProperty().getItem()).getConnection();
        analysis.getContext().setConnection(tdProvider);
        List<TdColumn> columnLst = new ArrayList<TdColumn>();
        for (RepositoryNode repNode : repositoryNodeList) {
            columnLst.add((TdColumn) ((MetadataColumnRepositoryObject) repNode.getObject()).getTdColumn());
        }
        columnSetMultiIndicator.getAnalyzedColumns().addAll(columnLst);
        correlationAnalysisHandler.addIndicator(columnLst, columnSetMultiIndicator);
    } else {
        deleteConnectionDependency(analysisItem);
        ColumnsetFactory columnsetFactory = ColumnsetFactory.eINSTANCE;
        ColumnSetMultiValueIndicator columnSetMultiValueIndicator = null;
        if (ColumnsetPackage.eINSTANCE.getCountAvgNullIndicator() == columnSetMultiIndicator.eClass()) {
            columnSetMultiValueIndicator = columnsetFactory.createCountAvgNullIndicator();
        }
        if (ColumnsetPackage.eINSTANCE.getMinMaxDateIndicator() == columnSetMultiIndicator.eClass()) {
            columnSetMultiValueIndicator = columnsetFactory.createMinMaxDateIndicator();
        }
        if (ColumnsetPackage.eINSTANCE.getWeakCorrelationIndicator() == columnSetMultiIndicator.eClass()) {
            columnSetMultiValueIndicator = columnsetFactory.createWeakCorrelationIndicator();
        }
        fillSimpleIndicators(columnSetMultiValueIndicator);
        analysis.getResults().getIndicators().add(columnSetMultiValueIndicator);
    }
    this.saveNumberOfConnectionsPerAnalysis();
    ReturnCode saved = new ReturnCode(false);
    this.nameText.setText(analysis.getName());
    saved = ElementWriterFactory.getInstance().createAnalysisWrite().save(analysisItem, true);
    logSaved(saved);
    treeViewer.setDirty(false);
    dataFilterComp.setDirty(false);
}

Output:
     } else {
-        deleteConnectionDependency(analysisItem);
+        analysis.getContext().setConnection(null);
         ColumnsetFactory columnsetFactory = ColumnsetFactory.eINSTANCE;


Input:
public void test_clusterMapSize() throws Exception {
    CookieStore cookieStore = new BasicCookieStore();
    IMap<String, Object> map = hz.getMap("String_Node_Str");
    executeRequest("String_Node_Str", serverPort1, cookieStore);
    assertEquals(2, map.size());
}

Output:
     CookieStore cookieStore = new BasicCookieStore();
-    IMap<String, Object> map = hz.getMap("String_Node_Str");
+    IMap<String, Object> map = hz.getMap(DEFAULT_MAP_NAME);
     executeRequest("String_Node_Str", serverPort1, cookieStore);


Input:
protected Object fetchValueFromMirror(int dimAxisIndex, int sortType) throws OLAPException {
    if (this.dimTraverse.dimensionCursorPosition[dimAxisIndex] < 0 || this.dimTraverse.dimensionCursorPosition[dimAxisIndex] >= edgeDimensRelation.mirrorLength[dimAxisIndex])
        throw new OLAPException(ResourceConstants.RD_EXPR_RESULT_SET_NOT_START);
    if (sortType == IDimensionSortDefn.SORT_UNDEFINED) {
        return this.dimAxis[dimAxisIndex].getDisctinctValue().get(this.dimTraverse.dimensionCursorPosition[dimAxisIndex]);
    }
    Collection collection = null;
    try {
        collection = fetchValueCollectionInEdgeInfo(dimAxisIndex);
    } catch (IOException e) {
    }
    Vector v = this.dimAxis[dimAxisIndex].getDisctinctValue();
    v.removeAll(collection);
    Iterator iter = collection.iterator();
    if (sortType == IDimensionSortDefn.SORT_ASC) {
        for (int i = 0, startSize = v.size(); i < collection.size(); i++) {
            v.insertElementAt(iter.next(), startSize);
            startSize++;
        }
    } else {
        int index = 0;
        while (iter.hasNext()) {
            v.insertElementAt(iter.next(), index);
            index++;
        }
    }
    return v.get(this.dimTraverse.dimensionCursorPosition[dimAxisIndex]);
}

Output:
     if (sortType == IDimensionSortDefn.SORT_UNDEFINED) {
-        return this.dimAxis[dimAxisIndex].getDisctinctValue().get(this.dimTraverse.dimensionCursorPosition[dimAxisIndex]);
-    }
-    Collection collection = null;
-    try {
-        collection = fetchValueCollectionInEdgeInfo(dimAxisIndex);
-    } catch (IOException e) {
-    }
-    Vector v = this.dimAxis[dimAxisIndex].getDisctinctValue();
-    v.removeAll(collection);
-    Iterator iter = collection.iterator();
-    if (sortType == IDimensionSortDefn.SORT_ASC) {
+        Collection collection = null;
+        try {
+            collection = fetchValueCollectionInEdgeInfo(dimAxisIndex);
+        } catch (IOException e) {
+        }
+        Vector v = this.dimAxis[dimAxisIndex].getDisctinctValue();
+        v.removeAll(collection);
+        Iterator iter = collection.iterator();
         for (int i = 0, startSize = v.size(); i < collection.size(); i++) {


Input:
public Champion getChampion(final Map<String, Object> query, final PipelineContext context) {
    final Platform platform = (Platform) query.get("String_Node_Str");
    Utilities.checkNotNull(platform, "String_Node_Str");
    final Integer id = (Integer) query.get("String_Node_Str");
    final String name = (String) query.get("String_Node_Str");
    Utilities.checkAtLeastOneNotNull(id, "String_Node_Str", name, "String_Node_Str");
    final String version = query.get("String_Node_Str") == null ? getCurrentVersion(platform, context) : (String) query.get("String_Node_Str");
    final String locale = query.get("String_Node_Str") == null ? platform.getDefaultLocale() : (String) query.get("String_Node_Str");
    final ChampionData data = new ChampionData(id == null ? 0 : id.intValue(), name, platform, version, locale);
    return new Champion(data);
}

Output:
     final String locale = query.get("String_Node_Str") == null ? platform.getDefaultLocale() : (String) query.get("String_Node_Str");
-    final ChampionData data = new ChampionData(id == null ? 0 : id.intValue(), name, platform, version, locale);
+    final Set<String> includedData = query.get("String_Node_Str") == null ? ImmutableSet.of("String_Node_Str") : (Set<String>) query.get("String_Node_Str");
+    final ChampionData data = new ChampionData(id == null ? 0 : id.intValue(), name, platform, version, locale, includedData);
     return new Champion(data);


Input:
public void onStop() {
    DebugLog.writeActivity(DebugType.DT_DEBUG, "String_Node_Str");
    if (Helper.isSuspendable(this)) {
        gatorObject.sendMessageToCache(CacheMessage.PASSIVE);
        disconnectService();
    }
    super.onStop();
}

Output:
     if (Helper.isSuspendable(this)) {
-        gatorObject.sendMessageToCache(CacheMessage.PASSIVE);
+        if (gatorObject != null)
+            gatorObject.sendMessageToCache(CacheMessage.PASSIVE);
         disconnectService();


Input:
protected void _provideOutsideContent(WebExporter exporter, NamedObj object) throws IllegalActionException {
    Map<NamedObj, PtolemyEffigy> openEffigies = new HashMap<NamedObj, PtolemyEffigy>();
    Tableau myTableau = exporter.getFrame().getTableau();
    Effigy myEffigy = (Effigy) myTableau.getContainer();
    List<PtolemyEffigy> effigies = myEffigy.entityList(PtolemyEffigy.class);
    for (PtolemyEffigy effigy : effigies) {
        openEffigies.put(effigy.getModel(), effigy);
    }
    PtolemyEffigy effigy = openEffigies.get(object);
    if (effigy == null) {
        Effigy candidate = Configuration.findEffigy(object);
        if (candidate instanceof PtolemyEffigy) {
            effigy = (PtolemyEffigy) candidate;
        }
    }
    try {
        if (effigy != null) {
            _linkTo(exporter, effigy, object, exporter.getExportDirectory());
        } else {
            if (object instanceof State) {
                try {
                    TypedActor[] refinements = ((State) object).getRefinement();
                    if (refinements != null && refinements.length > 0) {
                        effigy = openEffigies.get((NamedObj) refinements[0]);
                        if (effigy != null) {
                            _linkTo(exporter, effigy, (NamedObj) refinements[0], exporter.getExportDirectory());
                        }
                    }
                } catch (IllegalActionException e) {
                }
            } else if (object instanceof Instantiable) {
                Instantiable parent = ((Instantiable) object).getParent();
                if (parent instanceof NamedObj) {
                    Effigy classEffigy = Configuration.findEffigy((NamedObj) parent);
                    if (classEffigy instanceof PtolemyEffigy) {
                        _linkTo(exporter, (PtolemyEffigy) classEffigy, (NamedObj) parent, exporter.getExportDirectory());
                    }
                }
            }
        }
    } catch (Throwable throwable) {
        throw new IllegalActionException(this, throwable, "String_Node_Str");
    }
}

Output:
         if (effigy != null) {
-            _linkTo(exporter, effigy, object, exporter.getExportDirectory());
+            _linkTo(exporter, effigy, object, object, exporter.getExportDirectory());
         } else {


Input:
static void report(Config config, String dataName) throws Exception {
    System.out.println("String_Node_Str" + dataName);
    String output = config.getString("String_Node_Str");
    String modelName = "String_Node_Str";
    File analysisFolder = new File(new File(output, "String_Node_Str"), dataName + "String_Node_Str");
    analysisFolder.mkdirs();
    FileUtils.cleanDirectory(analysisFolder);
    IMLGradientBoosting boosting = IMLGradientBoosting.deserialize(new File(output, modelName));
    MultiLabelClfDataSet dataSet = loadData(config, dataName);
    System.out.println("String_Node_Str" + Accuracy.accuracy(boosting, dataSet));
    System.out.println("String_Node_Str" + Overlap.overlap(boosting, dataSet));
    if (true) {
        File distributionFile = new File(new File(config.getString("String_Node_Str"), "String_Node_Str"), "String_Node_Str");
        Collection<FeatureDistribution> distributions = (Collection) Serialization.deserialize(distributionFile);
        int limit = config.getInt("String_Node_Str");
        List<TopFeatures> topFeaturesList = IntStream.range(0, boosting.getNumClasses()).mapToObj(k -> IMLGBInspector.topFeatures(boosting, k, limit, distributions)).collect(Collectors.toList());
        ObjectMapper mapper = new ObjectMapper();
        String file = "String_Node_Str";
        mapper.writeValue(new File(analysisFolder, file), topFeaturesList);
    }
    if (true) {
        int limit = config.getInt("String_Node_Str");
        int numDocsPerFile = config.getInt("String_Node_Str");
        int numFiles = (int) Math.ceil((double) dataSet.getNumDataPoints() / numDocsPerFile);
        double probThreshold = config.getDouble("String_Node_Str");
        for (int i = 0; i < numFiles; i++) {
            int start = i;
            int end = i + numDocsPerFile;
            List<MultiLabelPredictionAnalysis> partition = new ArrayList<>();
            for (int a = start; a < end && a < dataSet.getNumDataPoints(); a++) {
                List<Integer> classes = new ArrayList<Integer>();
                for (int k = 0; k < boosting.getNumClasses(); k++) {
                    if (boosting.predictClassProb(dataSet.getRow(a), k) >= probThreshold) {
                        classes.add(k);
                    }
                }
                partition.add(IMLGBInspector.analyzePrediction(boosting, dataSet, a, classes, limit));
            }
            ObjectMapper mapper = new ObjectMapper();
            String file = "String_Node_Str" + (i + 1) + "String_Node_Str";
            mapper.writeValue(new File(analysisFolder, file), partition);
        }
    }
    System.out.println("String_Node_Str");
}

Output:
         for (int i = 0; i < numFiles; i++) {
-            int start = i;
-            int end = i + numDocsPerFile;
+            int start = i * numDocsPerFile;
+            int end = start + numDocsPerFile;
             List<MultiLabelPredictionAnalysis> partition = new ArrayList<>();


Input:
public boolean checkInWriteType(Object[] selects) {
    for (Object obj : selects) {
        if (obj instanceof XSDElementDeclaration || obj instanceof XSDParticle || obj instanceof XSDAnnotation || obj instanceof XSDSimpleTypeDefinition) {
            if (Util.IsAImporedElement((XSDConcreteComponent) obj, page.reConfigureXSDSchema(false)))
                return false;
            continue;
        } else
            return false;
    }
    return true;
}

Output:
     for (Object obj : selects) {
-        if (obj instanceof XSDElementDeclaration || obj instanceof XSDParticle || obj instanceof XSDAnnotation || obj instanceof XSDSimpleTypeDefinition) {
+        if (obj instanceof XSDElementDeclaration || obj instanceof XSDParticle || obj instanceof XSDAnnotation) {
             if (Util.IsAImporedElement((XSDConcreteComponent) obj, page.reConfigureXSDSchema(false)))


Input:
public void readUnlock() {
    throw new UnsupportedOperationException();
}

Output:
 public void readUnlock() {
-    throw new UnsupportedOperationException();
+    throw new UnsupportedOperationException("String_Node_Str");
 }


Input:
public TypeDescription getSchema(String topic, LogFilePath logFilePath) {
    return topicToSchemaMap.getOrDefault(topic, schemaForAlltopic);
}

Output:
 public TypeDescription getSchema(String topic, LogFilePath logFilePath) {
-    return topicToSchemaMap.getOrDefault(topic, schemaForAlltopic);
+    TypeDescription topicSpecificTD = topicToSchemaMap.get(topic);
+    if (null != topicSpecificTD) {
+        return topicSpecificTD;
+    }
+    return schemaForAlltopic;
 }


Input:
public void reservationDo(int useraction, String selection) {
    dialog = ProgressDialog.show(SearchResultDetailsActivity.this, "String_Node_Str", getString(R.string.doing_res), true);
    dialog.show();
    rt = new ResTask();
    rt.execute(app, item.getReservation_info(), useraction, selection);
}

Output:
 public void reservationDo(int useraction, String selection) {
-    dialog = ProgressDialog.show(SearchResultDetailsActivity.this, "String_Node_Str", getString(R.string.doing_res), true);
-    dialog.show();
+    if (dialog == null) {
+        dialog = ProgressDialog.show(SearchResultDetailsActivity.this, "String_Node_Str", getString(R.string.doing_res), true);
+        dialog.show();
+    } else if (!dialog.isShowing()) {
+        dialog = ProgressDialog.show(SearchResultDetailsActivity.this, "String_Node_Str", getString(R.string.doing_res), true);
+        dialog.show();
+    }
     rt = new ResTask();


Input:
public void onSuccess(Boolean confirmed) {
    if (confirmed) {
        SelectedItemsList<IndexedRepresentation> selected = new SelectedItemsList<IndexedRepresentation>(Arrays.asList(repId), IndexedRepresentation.class.getName());
        BrowserService.Util.getInstance().deleteRepresentation(selected, new AsyncCallback<Void>() {

            public void onSuccess(Void result) {
                Tools.newHistory(Browse.RESOLVER, aipId);
            }
            public void onFailure(Throwable caught) {
                AsyncCallbackUtils.defaultFailureTreatment(caught);
            }
        });
    }
}

Output:
     if (confirmed) {
-        SelectedItemsList<IndexedRepresentation> selected = new SelectedItemsList<IndexedRepresentation>(Arrays.asList(repId), IndexedRepresentation.class.getName());
-        BrowserService.Util.getInstance().deleteRepresentation(selected, new AsyncCallback<Void>() {
+        SelectedItems selected = (SelectedItems) filesList.getSelected();
+        if (ClientSelectedItemsUtils.isEmpty(selected)) {
+            selected = new SelectedItemsList<IndexedRepresentation>(Arrays.asList(repId), IndexedRepresentation.class.getName());
+            BrowserService.Util.getInstance().deleteRepresentation(selected, new AsyncCallback<Void>() {


Input:
public JsonResult<LanguageBo> saveForUpdated(LanguageBo languageBo) {
    UserResource resource = (UserResource) session.getAttribute(WebConst.SESSION_RESOURCE);
    if (languageBo.getCode() == null || languageBo.getCode().isEmpty()) {
        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
    }
    if (languageService.findExistLanguageByName(languageBo.getName())) {
        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
    }
    languageService.save(languageBo);
    return get(languageBo.getCode());
}

Output:
     }
-    if (languageService.findExistLanguageByName(languageBo.getName())) {
-        return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
+    if (languageService.findExistLanguageName(languageBo.getName())) {
+        if (languageService.findExistLanguageByName(languageBo.getName()).getCode().equals(languageBo.getCode())) {
+            languageService.save(languageBo);
+        } else {
+            return JsonResult.fail(ErrorCodes.BUSINESS_EXCEPTION.getCode(), resource.getMessage("String_Node_Str"));
+        }
+    } else {
+        languageService.save(languageBo);
     }


Input:
public Response execute(Command command) throws WebDriverException, IOException {
    if (DriverCommand.NEW_SESSION.equals(command.getName())) {
        serviceOptional.ifPresent(driverService -> {
            try {
                driverService.start();
            } catch (IOException e) {
                throw new WebDriverException(e.getMessage(), e);
            }
        });
    }
    Response response;
    try {
        if (!NEW_SESSION.equals(command.getName())) {
            response = super.execute(command);
        } else {
            response = createSession(command);
        }
    } catch (Throwable t) {
        Throwable rootCause = Throwables.getRootCause(t);
        if (rootCause instanceof ConnectException && rootCause.getMessage().contains("String_Node_Str")) {
            throw serviceOptional.map(service -> {
                if (service.isRunning()) {
                    return new WebDriverException("String_Node_Str", rootCause);
                }
                return new WebDriverException("String_Node_Str", rootCause);
            }).orElseGet((Supplier<WebDriverException>) () -> new WebDriverException(rootCause.getMessage(), rootCause));
        }
        throwIfUnchecked(t);
        throw new WebDriverException(t);
    } finally {
        if (DriverCommand.QUIT.equals(command.getName())) {
            serviceOptional.ifPresent(DriverService::stop);
        }
    }
    if (DriverCommand.NEW_SESSION.equals(command.getName()) && getCommandCodec() instanceof W3CHttpCommandCodec) {
        setCommandCodec(new AppiumW3CHttpCommandCodec());
        getAdditionalCommands().forEach(this::defineCommand);
    }
    return response;
}

Output:
     try {
-        if (!NEW_SESSION.equals(command.getName())) {
-            response = super.execute(command);
-        } else {
-            response = createSession(command);
-        }
+        response = NEW_SESSION.equals(command.getName()) ? createSession(command) : super.execute(command);
     } catch (Throwable t) {


Input:
protected Request insertElement() throws Exception {
    Request request = new Request(IRequestConstants.REQUEST_TYPE_INSERT);
    Map extendsData = new HashMap();
    extendsData.put(IRequestConstants.REQUEST_KEY_INSERT_SLOT, slotHandle);
    extendsData.put(IRequestConstants.REQUEST_KEY_INSERT_TYPE, insertType);
    extendsData.put(IRequestConstants.REQUEST_KEY_INSERT_POSITION, InsertAction.BELOW);
    request.setExtendedData(extendsData);
    ProviderFactory.createProvider(slotHandle.getElementHandle()).performRequest(model, request);
    return request;
}

Output:
     request.setExtendedData(extendsData);
-    ProviderFactory.createProvider(slotHandle.getElementHandle()).performRequest(model, request);
-    return request;
+    if (ProviderFactory.createProvider(slotHandle.getElementHandle()).performRequest(model, request)) {
+        return request;
+    }
+    return null;
 }


Input:
public void run() {
    EffectManager.getInstance();
    MessageManager.getInstance();
    hud = new Hud(context, weaponManager);
    touchManager = new TouchManager(dm, surfaceView, context, hud, weaponManager);
    gameMode = new GameMode(gameActivity, dm, context, weaponManager);
    allLoaded = true;
    waveStartTime = android.os.SystemClock.uptimeMillis();
    lastMovementUpdate = waveStartTime;
    lastAiUpdateStateOne = waveStartTime;
    lastAiUpdateStateTwo = waveStartTime;
    lastAiUpdateStateThree = waveStartTime;
    lastAiUpdateStateFour = waveStartTime;
    lastCooldownUpdate = waveStartTime;
    lastGameModeUpdate = waveStartTime;
    lastCollisionUpdate = waveStartTime;
    lastArmorUpdate = waveStartTime;
    lastBoundCheck = waveStartTime;
    lastGuideArrowUpdate = waveStartTime;
    lastRadarUpdate = waveStartTime;
    while (running) {
        long currentTime = android.os.SystemClock.uptimeMillis();
        if (currentTime - lastBoundCheck >= 1500) {
            lastBoundCheck = currentTime;
            gameMode.checkBounds();
        }
        if (currentTime - lastMovementUpdate >= 10) {
            updateMovement(currentTime);
            updateBackgroundStars();
        }
        if (currentTime - waveStartTime >= 3000) {
            updateSpeedUp = 2;
        }
        if (wrapper.player != null) {
            updateAi(currentTime);
        }
        if (currentTime - lastCollisionUpdate >= 50) {
            checkCollisions(currentTime);
        }
        updateEffectPositions();
        updateWeaponCooldowns(currentTime);
        recoverWeaponArmor(currentTime);
        updateGameMode(currentTime);
        updateGuideArrows(currentTime);
        updateRadar(currentTime);
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output:
     touchManager = new TouchManager(dm, surfaceView, context, hud, weaponManager);
-    gameMode = new GameMode(gameActivity, dm, context, weaponManager);
+    gameMode = new GameMode(gameActivity, dm, context, hud, weaponManager);
     allLoaded = true;


Input:
public Commit getCommit(String id) {
    try {
        Git git = Git.open(new File(path));
        Repository repo = git.getRepository();
        Iterable<RevCommit> commits = git.log().add(repo.resolve(id)).call();
        Commit theCommit = null;
        for (RevCommit jgitCommit : commits) {
            Committer committer = new Committer(jgitCommit.getAuthorIdent().getName(), jgitCommit.getAuthorIdent().getEmailAddress());
            String msg = jgitCommit.getFullMessage().trim();
            String hash = jgitCommit.getName().toString();
            long epoch = jgitCommit.getCommitTime();
            String parent = (jgitCommit.getParentCount() > 0) ? jgitCommit.getParent(0).getName().toString() : "String_Node_Str";
            GregorianCalendar date = new GregorianCalendar();
            date.setTime(new Date(epoch * 1000L));
            theCommit = new Commit(hash, committer, date, msg, parent);
            for (DiffEntry diff : diffsForTheCommit(repo, jgitCommit)) {
                ModificationType change = Enum.valueOf(ModificationType.class, diff.getChangeType().toString());
                String oldPath, newPath;
                if (ModificationType.RENAME.equals(change)) {
                    newPath = diff.getOldPath();
                    oldPath = diff.getNewPath();
                } else {
                    oldPath = diff.getOldPath();
                    newPath = diff.getNewPath();
                }
                String diffText = "String_Node_Str";
                String sc = "String_Node_Str";
                if (diff.getChangeType() != ChangeType.DELETE) {
                    diffText = getDiffText(repo, diff);
                    sc = getSourceCode(repo, diff);
                }
                theCommit.addModification(oldPath, newPath, change, diffText, sc);
            }
            break;
        }
        return theCommit;
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str" + id + "String_Node_Str" + path, e);
    }
}

Output:
                 ModificationType change = Enum.valueOf(ModificationType.class, diff.getChangeType().toString());
-                String oldPath, newPath;
-                if (ModificationType.RENAME.equals(change)) {
-                    newPath = diff.getOldPath();
-                    oldPath = diff.getNewPath();
-                } else {
-                    oldPath = diff.getOldPath();
-                    newPath = diff.getNewPath();
-                }
+                String oldPath = diff.getOldPath();
+                String newPath = diff.getNewPath();
                 String diffText = "String_Node_Str";


Input:
public static List<String> getSecurityGroupIds(String effectiveUserId) throws Exception {
    List<String> retVal = Lists.newArrayList();
    ServiceConfiguration configuration = Topology.lookup(Compute.class);
    DescribeSecurityGroupsType describeSecurityGroupsType = MessageHelper.createMessage(DescribeSecurityGroupsType.class, effectiveUserId);
    DescribeSecurityGroupsResponseType describeSecurityGroupsResponseType = AsyncRequests.<DescribeSecurityGroupsType, DescribeSecurityGroupsResponseType>sendSync(configuration, describeSecurityGroupsType);
    if (describeSecurityGroupsResponseType != null && describeSecurityGroupsResponseType.getSecurityGroupInfo() != null) {
        for (SecurityGroupItemType securityGroupItemType : describeSecurityGroupsResponseType.getSecurityGroupInfo()) {
            retVal.add(securityGroupItemType.getGroupId());
        }
    }
    return retVal;
}

Output:
     ServiceConfiguration configuration = Topology.lookup(Compute.class);
-    DescribeSecurityGroupsType describeSecurityGroupsType = MessageHelper.createMessage(DescribeSecurityGroupsType.class, effectiveUserId);
-    DescribeSecurityGroupsResponseType describeSecurityGroupsResponseType = AsyncRequests.<DescribeSecurityGroupsType, DescribeSecurityGroupsResponseType>sendSync(configuration, describeSecurityGroupsType);
-    if (describeSecurityGroupsResponseType != null && describeSecurityGroupsResponseType.getSecurityGroupInfo() != null) {
-        for (SecurityGroupItemType securityGroupItemType : describeSecurityGroupsResponseType.getSecurityGroupInfo()) {
-            retVal.add(securityGroupItemType.getGroupId());
+    try {
+        DescribeSecurityGroupsType describeSecurityGroupsType = MessageHelper.createMessage(DescribeSecurityGroupsType.class, effectiveUserId);
+        DescribeSecurityGroupsResponseType describeSecurityGroupsResponseType = AsyncRequests.<DescribeSecurityGroupsType, DescribeSecurityGroupsResponseType>sendSync(configuration, describeSecurityGroupsType);
+        if (describeSecurityGroupsResponseType != null && describeSecurityGroupsResponseType.getSecurityGroupInfo() != null) {
+            for (SecurityGroupItemType securityGroupItemType : describeSecurityGroupsResponseType.getSecurityGroupInfo()) {
+                retVal.add(securityGroupItemType.getGroupId());
+            }
         }


Input:
public T hasAllOf(Iterable<?> vals) {
    return this.hasAllOf(vals, this.query.isValidatingTypes());
}

Output:
 public T hasAllOf(Iterable<?> vals) {
-    return this.hasAllOf(vals, this.query.isValidatingTypes());
+    Assert.parametersNotNull("String_Node_Str", vals);
+    Assert.parameterNotEmpty(vals, "String_Node_Str");
+    return addCrit(FilterOperator.ALL, vals);
 }


Input:
public String getMessage() {
    String retString = null;
    if (_message != null) {
        retString = _message;
    }
    if (linkedException != null && linkedException.getMessage() != null) {
        if (retString != null) {
            retString += retString + "String_Node_Str" + linkedException.getMessage();
        } else {
            retString = linkedException.getMessage();
        }
    }
    return retString;
}

Output:
     }
-    if (linkedException != null && linkedException.getMessage() != null) {
+    Exception localLinkedException = linkedException;
+    if (localLinkedException != null && localLinkedException.getMessage() != null) {
         if (retString != null) {


Input:
private boolean verifyInData(String[] parameters, String inFolder, String outFilePath) {
    if (parameters == null) {
        System.out.println("String_Node_Str");
        return false;
    }
    if (parameters.length < 0) {
        System.out.println("String_Node_Str");
        return false;
    } else if (parameters.length > 8) {
        System.out.println("String_Node_Str");
        return false;
    }
    if (inFolder == null || outFilePath == null) {
        System.out.println("String_Node_Str");
        return false;
    }
    if (!checkIfFolderExists(outFilePath) || !checkIfFolderExists(inFolder)) {
        System.out.println("String_Node_Str");
        return false;
    }
    return true;
}

Output:
     if (parameters == null) {
-        System.out.println("String_Node_Str");
+        ErrorLogger.log("String_Node_Str", "String_Node_Str" + "String_Node_Str");
         return false;


Input:
public void combine(Iterator<PactRecord> values, Collector out) {
    reduce(values, out);
}

Output:
 public void combine(Iterator<PactRecord> values, Collector out) {
-    reduce(values, out);
+    PactRecord rec = null;
+    double partExtendedPriceSum = 0;
+    while (values.hasNext()) {
+        rec = values.next();
+        partExtendedPriceSum += rec.getField(5, PactDouble.class).getValue();
+    }
+    this.extendedPrice.setValue(partExtendedPriceSum);
+    rec.setField(5, this.extendedPrice);
+    out.collect(rec);
 }


Input:
private GraphTargetItem memberOrCall(GraphTargetItem ret, boolean inFunction, boolean inMethod, List<VariableActionItem> variables) throws IOException, ActionParseException {
    ParsedSymbol op = lex();
    while (op.isType(SymbolType.PARENT_OPEN, SymbolType.BRACKET_OPEN, SymbolType.DOT)) {
        if (op.type == SymbolType.PARENT_OPEN) {
            List<GraphTargetItem> args = call(inFunction, inMethod, variables);
            if (ret instanceof GetMemberActionItem) {
                GetMemberActionItem mem = (GetMemberActionItem) ret;
                ret = new CallMethodActionItem(null, mem.object, mem.memberName, args);
            } else if (ret instanceof VariableActionItem) {
                VariableActionItem var = (VariableActionItem) ret;
                ret = new CallFunctionActionItem(null, pushConst(var.getVariableName()), args);
            } else {
                ret = new CallFunctionActionItem(null, ret, args);
            }
        }
        if (op.type == SymbolType.BRACKET_OPEN) {
            GraphTargetItem rhs = expression(inFunction, inMethod, false, variables);
            ret = new GetMemberActionItem(null, ret, rhs);
            expectedType(SymbolType.BRACKET_CLOSE);
        }
        if (op.type == SymbolType.DOT) {
            ParsedSymbol s = lex();
            expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.THIS, SymbolType.SUPER, SymbolType.STRING_OP);
            ret = new GetMemberActionItem(null, ret, pushConst(s.value.toString()));
        }
        op = lex();
    }
    lexer.pushback(op);
    return ret;
}

Output:
             ParsedSymbol s = lex();
-            expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.THIS, SymbolType.SUPER, SymbolType.STRING_OP);
+            expected(s, lexer.yyline(), SymbolType.IDENTIFIER, SymbolType.THIS, SymbolType.SUPER, SymbolType.STRING_OP, SymbolGroup.GLOBALFUNC);
             ret = new GetMemberActionItem(null, ret, pushConst(s.value.toString()));


Input:
public void addPart(Part part) {
    if (!parts.contains(part)) {
        List<Part> newParts = new ArrayList<Part>(parts.size() + 1);
        newParts.addAll(parts);
        newParts.add(part);
        filterProperties[1].setValue(newParts);
    }
}

Output:
         newParts.add(part);
-        filterProperties[1].setValue(newParts);
+        getProperties()[1].setValue(newParts);
     }


Input:
public void setStation(StationResult station) {
    this.mStationNameIDPair = new Pair<>(station.getStation(), station.getId());
}

Output:
 public void setStation(StationResult station) {
-    this.mStationNameIDPair = new Pair<>(station.getStation(), station.getId());
+    setStation(new Pair<>(station.getStation(), station.getId()));
 }


Input:
public int compare(ReportRequest r1, ReportRequest r2) {
    if (r1 == null && r2 == null) {
        return 0;
    }
    if (r1 == null) {
        return -1;
    }
    if (r2 == null) {
        return 1;
    }
    int ret = OpenmrsUtil.compareWithNullAsLatest(r1.getEvaluateCompleteDatetime(), r2.getEvaluateCompleteDatetime());
    if (ret == 0) {
        ret = OpenmrsUtil.compareWithNullAsLatest(r1.getEvaluateStartDatetime(), r2.getEvaluateStartDatetime());
    }
    if (ret == 0) {
        ret = r1.getPriority().compareTo(r2.getPriority());
    }
    if (ret == 0) {
        ret = OpenmrsUtil.compareWithNullAsLatest(r1.getRequestDate(), r2.getRequestDate());
    }
    if (ret == 0) {
        ret = OpenmrsUtil.compareWithNullAsGreatest(r1.getUuid(), r2.getUuid());
    }
    return ret;
}

Output:
     }
-    int ret = OpenmrsUtil.compareWithNullAsLatest(r1.getEvaluateCompleteDatetime(), r2.getEvaluateCompleteDatetime());
-    if (ret == 0) {
-        ret = OpenmrsUtil.compareWithNullAsLatest(r1.getEvaluateStartDatetime(), r2.getEvaluateStartDatetime());
-    }
+    Date d1 = ObjectUtil.nvl(r1.getEvaluateCompleteDatetime(), r1.getEvaluateStartDatetime());
+    Date d2 = ObjectUtil.nvl(r2.getEvaluateCompleteDatetime(), r2.getEvaluateStartDatetime());
+    int ret = OpenmrsUtil.compareWithNullAsLatest(d1, d2);
     if (ret == 0) {


Input:
public Set<Resource> getResources() {
    return resources;
}

Output:
 public Set<Resource> getResources() {
-    return resources;
+    if (this.resources == null)
+        this.resources = new HashSet<Resource>();
+    return this.resources;
 }


Input:
public void run(final IProgressMonitor pm) throws InvocationTargetException, InterruptedException {
    final IProgressMonitor monitor;
    if (pm == null)
        monitor = new NullProgressMonitor();
    else
        monitor = pm;
    EclipseGitProgressTransformer gitMonitor = new EclipseGitProgressTransformer(monitor);
    Repository repository = null;
    try {
        monitor.beginTask(NLS.bind(CoreText.CloneOperation_title, uri), 5000);
        CloneCommand cloneRepository = Git.cloneRepository();
        cloneRepository.setCredentialsProvider(credentialsProvider);
        if (refName != null)
            cloneRepository.setBranch(refName);
        cloneRepository.setDirectory(workdir);
        cloneRepository.setProgressMonitor(gitMonitor);
        cloneRepository.setRemote(remoteName);
        cloneRepository.setURI(uri.toString());
        cloneRepository.setTimeout(timeout);
        cloneRepository.setCloneAllBranches(allSelected);
        if (selectedBranches != null) {
            List<String> branches = new ArrayList<String>();
            for (Ref branch : selectedBranches) branches.add(branch.getName());
            cloneRepository.setBranchesToClone(branches);
        }
        Git git = cloneRepository.call();
        repository = git.getRepository();
        if (postCloneTasks != null)
            for (PostCloneTask task : postCloneTasks) task.execute(git.getRepository(), monitor);
    } catch (final Exception e) {
        try {
            if (repository != null)
                repository.close();
            FileUtils.delete(workdir, FileUtils.RECURSIVE);
        } catch (IOException ioe) {
            throw new InvocationTargetException(ioe);
        }
        if (monitor.isCanceled())
            throw new InterruptedException();
        else
            throw new InvocationTargetException(e);
    } finally {
        monitor.done();
        if (repository != null)
            repository.close();
    }
}

Output:
         repository = git.getRepository();
-        if (postCloneTasks != null)
-            for (PostCloneTask task : postCloneTasks) task.execute(git.getRepository(), monitor);
+        synchronized (this) {
+            if (postCloneTasks != null)
+                for (PostCloneTask task : postCloneTasks) task.execute(git.getRepository(), monitor);
+        }
     } catch (final Exception e) {


Input:
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float fX, float fY, float fZ) {
    if (!world.isRemote) {
        TileEntity te = world.getTileEntity(x, y, z);
        if (ConfigurationHandler.enableHandRake && te != null && te instanceof TileEntityCrop && ((TileEntityCrop) te).weed) {
            return false;
        }
        if (player.isSneaking()) {
            this.harvest(world, x, y, z);
        } else if (player.getCurrentEquippedItem() == null) {
            this.harvest(world, x, y, z);
        } else if (player.getCurrentEquippedItem().getItem() == Items.debugItem) {
            return false;
        } else if (player.getCurrentEquippedItem().getItem() == Items.crops) {
            this.setCrossCrop(world, x, y, z, player);
        } else if (player.getCurrentEquippedItem().getItem() == net.minecraft.init.Items.dye && player.getCurrentEquippedItem().getItemDamage() == 15) {
            return false;
        } else if (ModIntegration.LoadedMods.magicalCrops && ConfigurationHandler.integration_allowMagicFertiliser && player.getCurrentEquippedItem().getItem() instanceof ItemMagicalCropFertilizer) {
            return this.applyMagicalFertiliser(world, x, y, z, player);
        } else if (player.getCurrentEquippedItem().getItem() instanceof ItemDebugger) {
            return false;
        } else if (ModIntegration.LoadedMods.tconstruct && player.getCurrentEquippedItem().getItem() instanceof Scythe) {
            for (int xPos = x - 1; xPos <= x + 1; xPos++) {
                for (int zPos = z - 1; zPos <= z + 1; zPos++) {
                    if (world.getBlock(xPos, y, zPos) instanceof BlockCrop && this.harvest(world, xPos, y, zPos)) {
                        AbilityHelper.damageTool(player.getCurrentEquippedItem(), 1, player, false);
                    }
                }
            }
        } else {
            this.harvest(world, x, y, z);
            if (player.getCurrentEquippedItem().getItem() instanceof ItemSeeds) {
                this.plantSeed(world, x, y, z, player);
            }
        }
    }
    return true;
}

Output:
         TileEntity te = world.getTileEntity(x, y, z);
-        if (ConfigurationHandler.enableHandRake && te != null && te instanceof TileEntityCrop && ((TileEntityCrop) te).weed) {
-            return false;
-        }
-        if (player.isSneaking()) {
-            this.harvest(world, x, y, z);
-        } else if (player.getCurrentEquippedItem() == null) {
-            this.harvest(world, x, y, z);
-        } else if (player.getCurrentEquippedItem().getItem() == Items.debugItem) {
-            return false;
-        } else if (player.getCurrentEquippedItem().getItem() == Items.crops) {
-            this.setCrossCrop(world, x, y, z, player);
-        } else if (player.getCurrentEquippedItem().getItem() == net.minecraft.init.Items.dye && player.getCurrentEquippedItem().getItemDamage() == 15) {
-            return false;
-        } else if (ModIntegration.LoadedMods.magicalCrops && ConfigurationHandler.integration_allowMagicFertiliser && player.getCurrentEquippedItem().getItem() instanceof ItemMagicalCropFertilizer) {
-            return this.applyMagicalFertiliser(world, x, y, z, player);
-        } else if (player.getCurrentEquippedItem().getItem() instanceof ItemDebugger) {
-            return false;
-        } else if (ModIntegration.LoadedMods.tconstruct && player.getCurrentEquippedItem().getItem() instanceof Scythe) {
-            for (int xPos = x - 1; xPos <= x + 1; xPos++) {
-                for (int zPos = z - 1; zPos <= z + 1; zPos++) {
-                    if (world.getBlock(xPos, y, zPos) instanceof BlockCrop && this.harvest(world, xPos, y, zPos)) {
-                        AbilityHelper.damageTool(player.getCurrentEquippedItem(), 1, player, false);
+        if (te != null && te instanceof TileEntityCrop) {
+            TileEntityCrop crop = (TileEntityCrop) te;
+            if (ConfigurationHandler.enableHandRake && crop.weed) {
+                return false;
+            }
+            if (player.isSneaking()) {
+                this.harvest(world, x, y, z);
+            } else if (player.getCurrentEquippedItem() == null) {
+                this.harvest(world, x, y, z);
+            } else if (player.getCurrentEquippedItem().getItem() == Items.debugItem) {
+                return false;
+            } else if (player.getCurrentEquippedItem().getItem() == Items.crops) {
+                this.setCrossCrop(world, x, y, z, player);
+            } else if (player.getCurrentEquippedItem().getItem() == net.minecraft.init.Items.dye && player.getCurrentEquippedItem().getItemDamage() == 15) {
+                return false;
+            } else if (ModIntegration.LoadedMods.magicalCrops && ConfigurationHandler.integration_allowMagicFertiliser && player.getCurrentEquippedItem().getItem() == Item.itemRegistry.getObject("String_Node_Str")) {
+                return this.applyMagicalFertiliser(world, x, y, z, player);
+            } else if (player.getCurrentEquippedItem().getItem() instanceof ItemDebugger) {
+                return false;
+            } else if (ModIntegration.LoadedMods.tconstruct && player.getCurrentEquippedItem().getItem() instanceof Scythe) {
+                for (int xPos = x - 1; xPos <= x + 1; xPos++) {
+                    for (int zPos = z - 1; zPos <= z + 1; zPos++) {
+                        if (world.getBlock(xPos, y, zPos) instanceof BlockCrop && this.harvest(world, xPos, y, zPos)) {
+                            AbilityHelper.damageTool(player.getCurrentEquippedItem(), 1, player, false);
+                        }
                     }


Input:
public void render(final Comboitem item, final Object data, final int index) throws Exception {
    final Combobox cb = (Combobox) item.getParent();
    final ListModel<?> model = cb.getModel();
    final int size = model.getSize();
    final Template tm = resolveTemplate(cb, item, data, index, size, "String_Node_Str");
    if (tm == null) {
        item.setLabel(Objects.toString(data));
        item.setValue(data);
    } else {
        final ForEachStatus iterStatus = new AbstractForEachStatus() {
            private static final long serialVersionUID = 1L;
            public int getIndex() {
                return index;
            }
            public Object getCurrent() {
                return data;
            }
            public Integer getEnd() {
                return size;
            }
        };
        final String var = (String) tm.getParameters().get(EACH_ATTR);
        final String varnm = var == null ? EACH_VAR : var;
        final String itervar = (String) tm.getParameters().get(STATUS_ATTR);
        final String itervarnm = itervar == null ? (var == null ? EACH_STATUS_VAR : varnm + STATUS_POST_VAR) : itervar;
        Object oldVar = cb.getAttribute(varnm);
        Object oldIter = cb.getAttribute(itervarnm);
        cb.setAttribute(varnm, data);
        cb.setAttribute(itervarnm, iterStatus);
        final Component[] items = filterOutShadows(cb, tm.create(cb, item, null, null));
        cb.setAttribute(varnm, oldVar);
        cb.setAttribute(itervarnm, oldIter);
        if (items.length != 1)
            throw new UiException("String_Node_Str" + items.length);
        final Comboitem nci = (Comboitem) items[0];
        nci.setAttribute(BinderCtrl.VAR, varnm);
        if (model instanceof ListSubModel) {
            nci.setAttribute(varnm, data);
        } else {
            recordRenderedIndex(cb, items.length);
            nci.setAttribute(AbstractRenderer.IS_TEMPLATE_MODEL_ENABLED_ATTR, true);
            nci.setAttribute(AbstractRenderer.CURRENT_INDEX_RESOLVER_ATTR, new IndirectBinding() {
                public Binder getBinder() {
                    return BinderUtil.getBinder(nci, true);
                }
                public void setValue(BindELContext ctx, Object value) {
                    int idx = BindComboitemRenderer.this.getRenderedIndex(cb, nci.getIndex());
                    ListModel<?> listmodel = cb.getModel();
                    if (idx >= 0 && idx < listmodel.getSize()) {
                        if (listmodel instanceof ListModelArray) {
                            ((ListModelArray<Object>) listmodel).set(idx, value);
                        } else if (listmodel instanceof ListModelList<?>) {
                            ((ListModelList<Object>) listmodel).set(idx, value);
                        }
                    } else {
                    }
                }
                public Component getComponent() {
                    return nci;
                }
                public Object getValue(BindELContext ctx) {
                    return model.getElementAt(BindComboitemRenderer.this.getRenderedIndex(cb, nci.getIndex()));
                }
            });
            addItemReference(cb, nci, index, varnm);
        }
        nci.setAttribute(itervarnm, iterStatus);
        nci.setAttribute(TemplateResolver.TEMPLATE_OBJECT, item.removeAttribute(TemplateResolver.TEMPLATE_OBJECT));
        addTemplateTracking(cb, nci, data, index, size);
        if (nci.getValue() == null)
            nci.setValue(data);
        item.setAttribute(Attributes.MODEL_RENDERAS, nci);
        item.detach();
        Events.sendEvent(new Event(BinderCtrl.ON_BIND_INIT, nci));
    }
}

Output:
         final Component[] items = filterOutShadows(cb, tm.create(cb, item, null, null));
-        cb.setAttribute(varnm, oldVar);
-        cb.setAttribute(itervarnm, oldIter);
+        if (oldVar == null) {
+            cb.removeAttribute(varnm);
+        } else {
+            cb.setAttribute(varnm, oldVar);
+        }
+        if (oldIter == null) {
+            cb.removeAttribute(itervarnm);
+        } else {
+            cb.setAttribute(itervarnm, oldIter);
+        }
         if (items.length != 1)


Input:
public void run() {
    MapService mapService = (MapService) getService();
    RecordStore recordStore = mapService.getRecordStore(getPartitionId(), name);
    Record record = recordStore.getRecord(dataKey);
    if (record != null) {
        result = new SimpleEntryView(record.getKey(), mapService.toData(record.getValue()), record.getStatistics(), record.getVersion());
    }
}

Output:
     if (record != null) {
-        result = new SimpleEntryView(record.getKey(), mapService.toData(record.getValue()), record.getStatistics(), record.getVersion());
+        result = new SimpleEntryView(record.getKey(), mapService.toData(record.getValue()), record.getStatistics(), record.getCost(), record.getVersion());
     }


Input:
public String toString() {
    return "String_Node_Str" + getName();
}

Output:
 public String toString() {
-    return "String_Node_Str" + getName();
+    return "String_Node_Str" + hashCode() + "String_Node_Str" + getName() + "String_Node_Str" + mBitmapResource;
 }


Input:
public void afterReceive(Message receivedMessage) {
    log.fine("String_Node_Str" + receivedMessage);
    TreeOperation operation = (TreeOperation) receivedMessage.getOperation();
    DomOperation domOperation = domOperationFactory.createDomOperation(operation);
    if (domOperation != null) {
        TreeOperation[] selectionEndPoints = saveSelection();
        domOperation.execute((Document) nativeNode.getOwnerDocument());
        restoreSelection(selectionEndPoints, operation);
    } else {
        updateDOM();
    }
}

Output:
     TreeOperation operation = (TreeOperation) receivedMessage.getOperation();
-    DomOperation domOperation = domOperationFactory.createDomOperation(operation);
+    DomOperation domOperation = domOperationFactory.createDomOperation(operation, true);
     if (domOperation != null) {


Input:
protected IValue resolveFieldAccess(IContext context) {
    IDataMember field = ICall.resolveField(context, this.instance, this.name);
    if (field != null) {
        if (field.isEnumConstant()) {
            EnumValue enumValue = new EnumValue(this.position);
            enumValue.name = this.name;
            enumValue.type = field.getType();
            return enumValue;
        }
        this.field = field;
        return this;
    }
    IMethod method = ICall.resolveMethod(context, this.instance, this.name, EmptyArguments.INSTANCE);
    if (method != null) {
        return this.toMethodCall(method);
    }
    if (this.instance == null) {
        IClass iclass = IContext.resolveClass(context, this.name);
        if (iclass != null) {
            return new ClassAccess(this.position, iclass.getType());
        }
    }
    return null;
}

Output:
     if (method != null) {
-        return this.toMethodCall(method);
+        AbstractCall mc = this.toMethodCall(method);
+        mc.checkArguments(markers, context);
+        return mc;
     }


Input:
void checkmark_orange() {
    resetBkg();
    checkmarkOrange.setSelected(true);
    icon = "String_Node_Str";
}

Output:
     checkmarkOrange.setSelected(true);
-    icon = "String_Node_Str";
+    icon = NotificationItem.CHECKMARK_ORANGE;
 }


Input:
private void setMultipleComponentParameters(IMultipleComponentManager multipleComponentManager, Map<IMultipleComponentItem, AbstractNode> itemsMap, INode graphicalNode) {
    List<IMultipleComponentItem> itemList = multipleComponentManager.getItemList();
    boolean targetFound;
    INode targetNode = null;
    for (int i = 0; i < itemList.size(); i++) {
        targetNode = itemsMap.get(itemList.get(i));
        if (itemList.get(i).getOutputConnections().size() > 0)
            targetNode.setVirtualLinkTo(EConnectionType.getTypeFromName(itemList.get(i).getOutputConnections().get(0).getConnectionType()));
        targetFound = false;
        if (targetNode != null) {
            for (int j = 0; j < targetNode.getElementParameters().size() && !targetFound; j++) {
                if (targetNode.getElementParameters().get(j).getName().equals(EParameterName.TSTATCATCHER_STATS.getName())) {
                    IElementParameter param = targetNode.getElementParameters().get(j);
                    boolean statsFound = false;
                    for (int k = 0; k < graphicalNode.getElementParameters().size() && !statsFound; k++) {
                        IElementParameter currentParam = graphicalNode.getElementParameters().get(k);
                        if (currentParam.getName().equals(EParameterName.TSTATCATCHER_STATS.getName())) {
                            param.setValue(currentParam.getValue());
                            statsFound = true;
                        }
                    }
                    targetFound = true;
                }
            }
        } else {
            return;
        }
    }
    for (IMultipleComponentParameter param : multipleComponentManager.getParamList()) {
        INode sourceNode = null;
        boolean sourceFound = false;
        targetFound = false;
        for (int i = 0; i < itemList.size() && !targetFound; i++) {
            if (itemList.get(i).getName().equals(param.getTargetComponent())) {
                targetNode = itemsMap.get(itemList.get(i));
                targetFound = true;
            }
        }
        if (param.getSourceComponent() != null) {
            if (param.getSourceComponent().equals("String_Node_Str")) {
                sourceNode = graphicalNode;
            } else {
                for (int i = 0; i < itemList.size() && !sourceFound; i++) {
                    if (itemList.get(i).getName().equals(param.getSourceComponent())) {
                        sourceNode = itemsMap.get(itemList.get(i));
                        sourceFound = true;
                    }
                }
            }
            if ((sourceNode != null) && (targetNode != null)) {
                sourceFound = false;
                targetFound = false;
                IElementParameter paramSource = null, paramTarget = null;
                for (int i = 0; i < sourceNode.getElementParameters().size() && !sourceFound; i++) {
                    if (sourceNode.getElementParameters().get(i).getName().equals(param.getSourceValue())) {
                        paramSource = sourceNode.getElementParameters().get(i);
                        sourceFound = true;
                    }
                }
                for (int i = 0; i < targetNode.getElementParameters().size() && !targetFound; i++) {
                    if (targetNode.getElementParameters().get(i).getName().equals(param.getTargetValue())) {
                        paramTarget = targetNode.getElementParameters().get(i);
                        targetFound = true;
                    }
                }
                if ((paramSource != null) && (paramTarget != null)) {
                    paramTarget.setDefaultClosedListValue(paramSource.getDefaultClosedListValue());
                    paramTarget.setListItemsDisplayCodeName(paramSource.getListItemsDisplayCodeName());
                    paramTarget.setListItemsValue(paramSource.getListItemsValue());
                    if (multipleComponentManager.isSetConnector() && param.getSourceComponent().equals("String_Node_Str") && param.getSourceValue().equals("String_Node_Str") && param.getTargetValue().equals("String_Node_Str")) {
                        paramTarget.setValue(paramSource.getValue() + multipleComponentManager.getConnector());
                    } else {
                        paramTarget.setValue(paramSource.getValue());
                    }
                }
                if ((paramSource == null) && (paramTarget != null)) {
                    if (param.getSourceValue().endsWith("String_Node_Str")) {
                        paramTarget.setValue(sourceNode.getElementParameter(param.getSourceValue()).getValue());
                    }
                }
            }
        } else {
            if (param.getSourceValue() != null && targetFound) {
                targetFound = false;
                IElementParameter paramTarget = null;
                for (int i = 0; i < targetNode.getElementParameters().size() && !targetFound; i++) {
                    if (targetNode.getElementParameters().get(i).getName().equals(param.getTargetValue())) {
                        paramTarget = targetNode.getElementParameters().get(i);
                        targetFound = true;
                    }
                }
                if (paramTarget != null) {
                    paramTarget.setValue(param.getSourceValue());
                }
            }
        }
    }
}

Output:
         targetNode = itemsMap.get(itemList.get(i));
-        if (itemList.get(i).getOutputConnections().size() > 0)
+        if (itemList.get(i).getOutputConnections().size() > 0) {
             targetNode.setVirtualLinkTo(EConnectionType.getTypeFromName(itemList.get(i).getOutputConnections().get(0).getConnectionType()));


Input:
void init(ChannelPipeline pipeline) throws Exception {
    pipeline.addLast("String_Node_Str", createSslHandler(sslContext, needsClientAuth));
    pipeline.addLast("String_Node_Str", new HttpResponseEncoder());
    pipeline.addLast("String_Node_Str", new HttpRequestDecoder());
    pipeline.addLast("String_Node_Str", new HttpObjectAggregator(65536));
    pipeline.addLast("String_Node_Str", new WebSocketServerProtocolHandler("String_Node_Str", MQTT_SUBPROTOCOL_CSV_LIST));
    pipeline.addLast("String_Node_Str", new WebSocketFrameToByteBufDecoder());
    pipeline.addLast("String_Node_Str", new ByteBufToWebSocketFrameEncoder());
    pipeline.addFirst("String_Node_Str", new IdleStateHandler(nettyChannelTimeoutSeconds, 0, 0));
    pipeline.addAfter("String_Node_Str", "String_Node_Str", timeoutHandler);
    pipeline.addFirst("String_Node_Str", new BytesMetricsHandler(m_bytesMetricsCollector));
    pipeline.addLast("String_Node_Str", new MqttDecoder());
    pipeline.addLast("String_Node_Str", MqttEncoder.INSTANCE);
    pipeline.addLast("String_Node_Str", new MessageMetricsHandler(m_metricsCollector));
    pipeline.addLast("String_Node_Str", new MQTTMessageLogger());
    pipeline.addLast("String_Node_Str", handler);
}

Output:
     pipeline.addFirst("String_Node_Str", new BytesMetricsHandler(m_bytesMetricsCollector));
-    pipeline.addLast("String_Node_Str", new MqttDecoder());
+    pipeline.addLast("String_Node_Str", new MqttDecoder(maxBytesInMessage));
     pipeline.addLast("String_Node_Str", MqttEncoder.INSTANCE);