Input:
public void befoteTest() {
    PowerMockito.mockStatic(CallContext.class);
    PowerMockito.when(CallContext.current()).thenReturn(Mockito.mock(CallContext.class));
    Mockito.when(networkAclDaoMock.findById(networkAclListId)).thenReturn(networkACLVOMock);
    Mockito.when(createNetworkAclCmdMock.getNetworkId()).thenReturn(1L);
    Mockito.when(createNetworkAclCmdMock.getProtocol()).thenReturn("String_Node_Str");
    Mockito.when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingMockId);
    Mockito.when(networkMock.getVpcId()).thenReturn(networkMockVpcMockId);
    Mockito.when(moveNetworkAclItemCmdMock.getUuidRuleBeingMoved()).thenReturn(uuidAclRuleBeingMoved);
    Mockito.when(aclRuleBeingMovedMock.getUuid()).thenReturn(uuidAclRuleBeingMoved);
    Mockito.when(aclRuleBeingMovedMock.getAclId()).thenReturn(networkAclMockId);
    Mockito.when(previousAclRuleMock.getUuid()).thenReturn(previousAclRuleUuid);
    Mockito.when(nextAclRuleMock.getUuid()).thenReturn(nextAclRuleUuid);
    Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);
}

Output:
     PowerMockito.mockStatic(CallContext.class);
-    PowerMockito.when(CallContext.current()).thenReturn(Mockito.mock(CallContext.class));
+    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);
+    Mockito.doReturn(Mockito.mock(User.class)).when(callContextMock).getCallingUser();
+    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();
     Mockito.when(networkAclDaoMock.findById(networkAclListId)).thenReturn(networkACLVOMock);


Input:
public static String getApplicationDirectory() {
    return System.getProperty("String_Node_Str", "String_Node_Str") + "String_Node_Str";
}

Output:
 public static String getApplicationDirectory() {
-    return System.getProperty("String_Node_Str", "String_Node_Str") + "String_Node_Str";
+    StringBuilder appDir = new StringBuilder().append(System.getProperty("String_Node_Str", "String_Node_Str")).append(File.separator).append("String_Node_Str").append(File.separator);
+    return appDir.toString();
 }


Input:
public static String convertNonPrintableCharacers(String message) {
    StringBuilder buff = new StringBuilder(message.length());
    for (int i = 0; i < message.length(); i++) {
        char currentChar = message.charAt(i);
        if (currentChar < 32 || currentChar > 126) {
            buff.append("String_Node_Str" + (int) currentChar + "String_Node_Str");
        } else if (currentChar == '<') {
            buff.append("String_Node_Str");
        } else if (currentChar == '>') {
            buff.append("String_Node_Str");
        } else if (currentChar == '&') {
            buff.append("String_Node_Str");
        } else {
            buff.append(currentChar);
        }
    }
    return buff.toString();
}

Output:
         char currentChar = message.charAt(i);
-        if (currentChar < 32 || currentChar > 126) {
+        if ((currentChar < 32 || currentChar > 126) && currentChar != '\n' && currentChar != '\r' && currentChar != '\t') {
             buff.append("String_Node_Str" + (int) currentChar + "String_Node_Str");


Input:
private long[] _decode(String hash, String alphabet) {
    final ArrayList<Long> ret = new ArrayList<Long>();
    int i = 0;
    final String regexp = "String_Node_Str" + this.guards + "String_Node_Str";
    String hashBreakdown = hash.replaceAll(regexp, "String_Node_Str");
    String[] hashArray = hashBreakdown.split("String_Node_Str");
    if (hashArray.length == 3 || hashArray.length == 2) {
        i = 1;
    }
    if (hashArray.length > 0) {
        hashBreakdown = hashArray[i];
        if (!hashBreakdown.isEmpty()) {
            final char lottery = hashBreakdown.charAt(0);
            hashBreakdown = hashBreakdown.substring(1);
            hashBreakdown = hashBreakdown.replaceAll("String_Node_Str" + this.seps + "String_Node_Str", "String_Node_Str");
            hashArray = hashBreakdown.split("String_Node_Str");
            String subHash, buffer;
            for (final String aHashArray : hashArray) {
                subHash = aHashArray;
                buffer = lottery + this.salt + alphabet;
                alphabet = Hashids.consistentShuffle(alphabet, buffer.substring(0, alphabet.length()));
                ret.add(Hashids.unhash(subHash, alphabet));
            }
        }
    }
    long[] arr = new long[ret.size()];
    for (int k = 0; k < arr.length; k++) {
        arr[k] = ret.get(k);
    }
    if (!this._encode(arr).equals(hash)) {
        arr = new long[0];
    }
    return arr;
}

Output:
     }
-    if (!this._encode(arr).equals(hash)) {
+    if (!this.encode(arr).equals(hash)) {
         arr = new long[0];


Input:
protected void delegateWrite(byte[] b, int pos, int len) throws IOException {
    if (delegate == null) {
        if (pointer + len > memoryDelegate.length) {
            createRandomAccessFile();
        } else {
            System.arraycopy(b, pos, memoryDelegate, pointer, len);
            if (pointer + len > length) {
                length = pointer + len;
            }
            pointer += len;
            return;
        }
    }
    delegate.write(b, pos, len);
}

Output:
     if (delegate == null) {
-        if (pointer + len > memoryDelegate.length) {
+        if (pointer + len > memoryDelegate.length && !pureMemory) {
             createRandomAccessFile();


Input:
private void doInvoke(String methodName, InstructionHandle stmt, Context context, Map<CallString, Map<Location, ValueMapping>> input, Interpreter<CallString, Map<Location, ValueMapping>> interpreter, Map<InstructionHandle, ContextMap<CallString, Map<Location, ValueMapping>>> state, Map<CallString, Map<Location, ValueMapping>> result) {
    DFAAppInfo p = interpreter.getProgram();
    MethodInfo mi = p.getMethod(methodName);
    MethodGen method = mi.getMethodGen();
    methodName = method.getClassName() + "String_Node_Str" + method.getName() + method.getSignature();
    if (method.isNative()) {
        handleNative(method, context, input, result);
    } else {
        int varPtr = context.stackPtr - MethodHelper.getArgSize(method);
        Context c = new Context(context);
        c.stackPtr = method.getMaxLocals();
        c.constPool = method.getConstantPool();
        if (method.isSynchronized()) {
            c.syncLevel = context.syncLevel + 1;
        }
        c.method = methodName;
        c.callString = c.callString.push(p.getMethod(context.method), stmt.getPosition(), callStringLength);
        Map<Location, ValueMapping> in = input.get(context.callString);
        Map<Location, ValueMapping> out = new HashMap<Location, ValueMapping>();
        for (Iterator<Location> k = in.keySet().iterator(); k.hasNext(); ) {
            Location l = k.next();
            if (l.stackLoc < 0) {
                out.put(l, in.get(l));
            }
            if (l.stackLoc >= varPtr) {
                out.put(new Location(l.stackLoc - varPtr), new ValueMapping(in.get(l), false));
            }
        }
        ContextMap<CallString, Map<Location, ValueMapping>> tmpresult = new ContextMap<CallString, Map<Location, ValueMapping>>(c, new HashMap<CallString, Map<Location, ValueMapping>>());
        tmpresult.put(c.callString, out);
        InstructionHandle entry = mi.getCode().getInstructionList().getStart();
        state.put(entry, join(state.get(entry), tmpresult));
        Map<InstructionHandle, ContextMap<CallString, Map<Location, ValueMapping>>> r = interpreter.interpret(c, entry, state, false);
        InstructionHandle exit = mi.getCode().getInstructionList().getEnd();
        if (r.get(exit) != null) {
            Map<Location, ValueMapping> returned = r.get(exit).get(c.callString);
            if (returned != null) {
                for (Iterator<Location> i = returned.keySet().iterator(); i.hasNext(); ) {
                    Location l = i.next();
                    if (l.stackLoc < 0) {
                        ValueMapping m = new ValueMapping(returned.get(l), true);
                        m.join(result.get(context.callString).get(l));
                        result.get(context.callString).put(l, m);
                    }
                    if (l.stackLoc >= 0) {
                        ValueMapping m = new ValueMapping(returned.get(l), false);
                        Location loc = new Location(l.stackLoc + varPtr);
                        m.join(result.get(context.callString).get(loc));
                        result.get(context.callString).put(loc, m);
                    }
                }
            }
        }
        for (Iterator<Location> i = in.keySet().iterator(); i.hasNext(); ) {
            Location l = i.next();
            if (l.stackLoc >= 0 && l.stackLoc < context.stackPtr - MethodHelper.getArgSize(method)) {
                result.get(context.callString).put(l, new ValueMapping(in.get(l), true));
            }
        }
    }
}

Output:
     DFAAppInfo p = interpreter.getProgram();
-    MethodInfo mi = p.getMethod(methodName);
-    MethodGen method = mi.getMethodGen();
-    methodName = method.getClassName() + "String_Node_Str" + method.getName() + method.getSignature();
+    MethodInfo method = p.getMethod(methodName);
+    methodName = method.getSignature().toString();
     if (method.isNative()) {


Input:
public void testToggleDrillStateTuple(FoodMartTestCase test) {
    Axis axis = test.executeAxis2("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str");
    String expected = "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str";
    test.assertEquals(expected, test.toString(axis.positions));
}

Output:
 public void testToggleDrillStateTuple(FoodMartTestCase test) {
-    Axis axis = test.executeAxis2("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str");
-    String expected = "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str";
-    test.assertEquals(expected, test.toString(axis.positions));
+    test.assertAxisReturns("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str", "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str");
 }


Input:
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming, boolean dontWait) {
    if (mPausingActivity != null) {
        Slog.wtf(TAG, "String_Node_Str" + mPausingActivity);
        completePauseLocked(false);
    }
    ActivityRecord prev = mResumedActivity;
    if (prev == null) {
        if (!resuming) {
            Slog.wtf(TAG, "String_Node_Str");
            mStackSupervisor.resumeTopActivitiesLocked();
        }
        return false;
    }
    if (mActivityContainer.mParentActivity == null) {
        mStackSupervisor.pauseChildStacks(prev, userLeaving, uiSleeping, resuming, dontWait);
    }
    if (DEBUG_STATES)
        Slog.v(TAG, "String_Node_Str" + prev);
    else if (DEBUG_PAUSE)
        Slog.v(TAG, "String_Node_Str" + prev);
    mResumedActivity = null;
    mPausingActivity = prev;
    mLastPausedActivity = prev;
    mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0 || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
    prev.state = ActivityState.PAUSING;
    prev.task.touchActiveTime();
    clearLaunchTime(prev);
    final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
    if (mService.mHasRecents && (next == null || next.noDisplay || next.task != prev.task)) {
        prev.updateThumbnail(screenshotActivities(prev), null);
    }
    stopFullyDrawnTraceIfNeeded();
    mService.updateCpuStats();
    if (prev.app != null && prev.app.thread != null) {
        if (DEBUG_PAUSE)
            Slog.v(TAG, "String_Node_Str" + prev);
        try {
            EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY, prev.userId, System.identityHashCode(prev), prev.shortComponentName);
            mService.updateUsageStats(prev, false);
            prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing, userLeaving, prev.configChangeFlags, dontWait);
        } catch (Exception e) {
            Slog.w(TAG, "String_Node_Str", e);
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }
    } else {
        mPausingActivity = null;
        mLastPausedActivity = null;
        mLastNoHistoryActivity = null;
    }
    if (!mService.isSleepingOrShuttingDown()) {
        mStackSupervisor.acquireLaunchWakelock();
    }
    if (mPausingActivity != null) {
        if (!uiSleeping) {
            prev.pauseKeyDispatchingLocked();
        } else {
            if (DEBUG_PAUSE)
                Slog.v(TAG, "String_Node_Str");
        }
        if (dontWait) {
            completePauseLocked(false);
            return false;
        } else {
            Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
            msg.obj = prev;
            prev.pauseTime = SystemClock.uptimeMillis();
            mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);
            if (DEBUG_PAUSE)
                Slog.v(TAG, "String_Node_Str");
            return true;
        }
    } else {
        if (DEBUG_PAUSE)
            Slog.v(TAG, "String_Node_Str");
        if (!resuming) {
            mStackSupervisor.getFocusedStack().resumeTopActivityLocked(null);
        }
        return false;
    }
}

Output:
     final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
-    if (mService.mHasRecents && (next == null || next.noDisplay || next.task != prev.task)) {
+    if (mService.mHasRecents && (next == null || next.noDisplay || next.task != prev.task || uiSleeping)) {
         prev.updateThumbnail(screenshotActivities(prev), null);


Input:
public final byte[] buildPacket() {
    Map<BleUuid, byte[]> map = new HashMap<>(m_serviceUuids.size() + m_serviceData.size());
    if (m_serviceUuids.size() > 0) {
        for (BleUuid u : m_serviceUuids) {
            map.put(u, null);
        }
    }
    if (m_serviceData.size() > 0) {
        for (UUID u : m_serviceData.keySet()) {
            map.put(new BleUuid(u, BleUuid.UuidSize.SHORT), m_serviceData.get(u));
        }
    }
    if (m_manufactuerId != null) {
        ManufacturerData data = new ManufacturerData();
        data.m_id = m_manufactuerId;
        if (m_manufacturerData != null) {
            data.m_data = m_manufacturerData;
        }
        m_manufacturerDataList.add(data);
    }
    byte flags = m_advFlags.value != null ? m_advFlags.value.byteValue() : 0;
    byte tx = m_txPower.value != null ? m_txPower.value.byteValue() : 0;
    return Utils_ScanRecord.newScanRecord(flags, map, m_completeUuidList, m_localName, m_shortName, tx, m_manufacturerDataList);
}

Output:
     }
-    if (m_manufactuerId != null) {
-        ManufacturerData data = new ManufacturerData();
-        data.m_id = m_manufactuerId;
-        if (m_manufacturerData != null) {
-            data.m_data = m_manufacturerData;
-        }
-        m_manufacturerDataList.add(data);
+    if (m_tempManData != null) {
+        m_manufacturerDataList.add(m_tempManData);
     }


Input:
private void selectCell(int aRow, int aCol) {
    grid.getSelectionModel().select(aRow, false);
}

Output:
 private void selectCell(int aRow, int aCol) {
-    grid.getSelectionModel().select(aRow, false);
+    if (grid.getSelectionModel() instanceof PlatypusCellSelectionModel<?>) {
+        PlatypusCellSelectionModel<Row> cellsSelection = (PlatypusCellSelectionModel<Row>) grid.getSelectionModel();
+        cellsSelection.selectCell(aRow, aCol, true);
+    } else {
+        grid.getSelectionModel().select(aRow, false);
+    }
 }


Input:
public void demoRetrofitCalls() {
    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(this.toString()).replace(R.id.activity_main, new RetrofitFragment(), this.toString()).commit();
}

Output:
 public void demoRetrofitCalls() {
-    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(this.toString()).replace(R.id.activity_main, new RetrofitFragment(), this.toString()).commit();
+    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(RetrofitFragment.class.toString()).replace(android.R.id.content, new RetrofitFragment(), RetrofitFragment.class.toString()).commit();
 }


Input:
public void onData(RealtimeData realtimeData) {
    realtimeList.addItem(realtimeData);
    tmpDataUpdated++;
    if (tmpDataUpdated > 5) {
        realtimeList.notifyDataSetChanged();
        tmpDataUpdated = 0;
    }
}

Output:
     realtimeList.addItem(realtimeData);
-    tmpDataUpdated++;
-    if (tmpDataUpdated > 5) {
+    realtimeList.itemsAddedWithoutNotify++;
+    if (realtimeList.itemsAddedWithoutNotify > 5) {
+        realtimeList.itemsAddedWithoutNotify = 0;
         realtimeList.notifyDataSetChanged();


Input:
public String getLabel() {
    String displayLabel = label;
    if (indicatorEnum != null) {
        displayLabel = this.indicatorEnum.getLabel();
    }
    return displayLabel;
}

Output:
     String displayLabel = label;
-    if (indicatorEnum != null) {
+    if (StringUtil.isEmpty(displayLabel) && indicatorEnum != null) {
         displayLabel = this.indicatorEnum.getLabel();


Input:
public static int indexOfGroovyLikeExtension(String fileName) {
    int fileNameLength = fileName.length();
    char[][] groovyLikeExtensions = getGroovyLikeExtensions();
    extensions: for (int i = 0, length = groovyLikeExtensions.length; i < length; i++) {
        char[] extension = groovyLikeExtensions[i];
        int extensionLength = extension.length;
        int extensionStart = fileNameLength - extensionLength;
        int dotIndex = extensionStart - 1;
        if (dotIndex < 0)
            continue;
        if (fileName.charAt(dotIndex) != '.')
            continue;
        for (int j = 0; j < extensionLength; j++) {
            if (fileName.charAt(extensionStart + j) != extension[j])
                continue extensions;
        }
        return dotIndex;
    }
    return -1;
}

Output:
 public static int indexOfGroovyLikeExtension(String fileName) {
-    int fileNameLength = fileName.length();
-    char[][] groovyLikeExtensions = getGroovyLikeExtensions();
-    extensions: for (int i = 0, length = groovyLikeExtensions.length; i < length; i++) {
-        char[] extension = groovyLikeExtensions[i];
-        int extensionLength = extension.length;
-        int extensionStart = fileNameLength - extensionLength;
-        int dotIndex = extensionStart - 1;
-        if (dotIndex < 0)
-            continue;
-        if (fileName.charAt(dotIndex) != '.')
-            continue;
-        for (int j = 0; j < extensionLength; j++) {
-            if (fileName.charAt(extensionStart + j) != extension[j])
-                continue extensions;
+    if (fileName != null) {
+        int fileNameLength = fileName.length();
+        if (fileNameLength > 0) {
+            for (char[] extension : getGroovyLikeExtensions()) {
+                int offset = (fileNameLength - extension.length);
+                if (offset < 1 || fileName.charAt(offset - 1) != '.')
+                    continue;
+                if (Arrays.equals(extension, fileName.substring(offset).toCharArray()))
+                    return (offset - 1);
+            }
         }


Input:
public void update(Observable o, Object arg) {
    if (arg != null) {
        if (arg instanceof AnswerSide) {
            switch((AnswerSide) arg) {
                case LEFT:
                    selectSingleScorePanel(true);
                    break;
                case RIGHT:
                    selectSingleScorePanel(false);
                    break;
            }
        } else if (arg instanceof GameState) {
            if (arg == GameState.FINISHED || arg == GameState.RUNNING)
                removeSelection();
        } else if (arg instanceof NamesChangedEvent) {
            setNames(((NamesChangedEvent) arg).getLeftName(), ((NamesChangedEvent) arg).getRightName());
        }
    } else {
        switch(ScoreManagerSingleton.getInstance().getAnswerSide()) {
            case LEFT:
                leftScorePanel.setScore(ScoreManagerSingleton.getInstance().getLeftScore());
                break;
            case RIGHT:
                rightScorePanel.setScore(ScoreManagerSingleton.getInstance().getRightScore());
                break;
        }
    }
}

Output:
     } else {
-        switch(ScoreManagerSingleton.getInstance().getAnswerSide()) {
-            case LEFT:
-                leftScorePanel.setScore(ScoreManagerSingleton.getInstance().getLeftScore());
-                break;
-            case RIGHT:
-                rightScorePanel.setScore(ScoreManagerSingleton.getInstance().getRightScore());
-                break;
-        }
+        leftScorePanel.setScore(ScoreManagerSingleton.getInstance().getLeftScore());
+        rightScorePanel.setScore(ScoreManagerSingleton.getInstance().getRightScore());
     }


Input:
private void grantPermissionsLPw(PackageParser.Package pkg, boolean replace) {
    final PackageSetting ps = (PackageSetting) pkg.mExtras;
    if (ps == null) {
        return;
    }
    final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps;
    HashSet<String> origPermissions = gp.grantedPermissions;
    boolean changedPermission = false;
    if (replace) {
        ps.permissionsFixed = false;
        if (gp == ps) {
            origPermissions = new HashSet<String>(gp.grantedPermissions);
            gp.grantedPermissions.clear();
            gp.gids = mGlobalGids;
        }
    }
    if (gp.gids == null) {
        gp.gids = mGlobalGids;
    }
    final int N = pkg.requestedPermissions.size();
    for (int i = 0; i < N; i++) {
        final String name = pkg.requestedPermissions.get(i);
        final boolean required = pkg.requestedPermissionsRequired.get(i);
        final BasePermission bp = mSettings.mPermissions.get(name);
        if (DEBUG_INSTALL) {
            if (gp != ps) {
                Log.i(TAG, "String_Node_Str" + pkg.packageName + "String_Node_Str" + name + "String_Node_Str" + bp);
            }
        }
        if (bp == null || bp.packageSetting == null) {
            Slog.w(TAG, "String_Node_Str" + name + "String_Node_Str" + pkg.packageName);
            continue;
        }
        final String perm = bp.name;
        boolean allowed;
        boolean allowedSig = false;
        if ((bp.protectionLevel & PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
            ArraySet<String> pkgs = mAppOpPermissionPackages.get(bp.name);
            if (pkgs == null) {
                pkgs = new ArraySet<>();
                mAppOpPermissionPackages.put(bp.name, pkgs);
            }
            pkgs.add(pkg.packageName);
        }
        final int level = bp.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
        if (level == PermissionInfo.PROTECTION_NORMAL || level == PermissionInfo.PROTECTION_DANGEROUS) {
            allowed = (required || origPermissions.contains(perm) || (isSystemApp(ps) && !isUpdatedSystemApp(ps)));
        } else if (bp.packageSetting == null) {
            allowed = false;
        } else if (level == PermissionInfo.PROTECTION_SIGNATURE) {
            allowed = grantSignaturePermission(perm, pkg, bp, origPermissions);
            if (allowed) {
                allowedSig = true;
            }
        } else {
            allowed = false;
        }
        if (DEBUG_INSTALL) {
            if (gp != ps) {
                Log.i(TAG, "String_Node_Str" + pkg.packageName + "String_Node_Str" + perm);
            }
        }
        if (allowed) {
            if (!isSystemApp(ps) && ps.permissionsFixed) {
                if (!allowedSig && !gp.grantedPermissions.contains(perm)) {
                    allowed = isNewPlatformPermissionForPackage(perm, pkg);
                }
            }
            if (allowed) {
                if (!gp.grantedPermissions.contains(perm)) {
                    changedPermission = true;
                    gp.grantedPermissions.add(perm);
                    gp.gids = appendInts(gp.gids, bp.gids);
                } else if (!ps.haveGids) {
                    gp.gids = appendInts(gp.gids, bp.gids);
                }
            } else {
                Slog.w(TAG, "String_Node_Str" + perm + "String_Node_Str" + pkg.packageName + "String_Node_Str");
            }
        } else {
            if (gp.grantedPermissions.remove(perm)) {
                changedPermission = true;
                gp.gids = removeInts(gp.gids, bp.gids);
                Slog.i(TAG, "String_Node_Str" + perm + "String_Node_Str" + pkg.packageName + "String_Node_Str" + bp.protectionLevel + "String_Node_Str" + Integer.toHexString(pkg.applicationInfo.flags) + "String_Node_Str");
            } else if ((bp.protectionLevel & PermissionInfo.PROTECTION_FLAG_APPOP) == 0) {
                Slog.w(TAG, "String_Node_Str" + perm + "String_Node_Str" + pkg.packageName + "String_Node_Str" + bp.protectionLevel + "String_Node_Str" + Integer.toHexString(pkg.applicationInfo.flags) + "String_Node_Str");
            }
        }
    }
    if ((changedPermission || replace) && !ps.permissionsFixed && !isSystemApp(ps) || isUpdatedSystemApp(ps)) {
        ps.permissionsFixed = true;
    }
    ps.haveGids = true;
}

Output:
         if (bp == null || bp.packageSetting == null) {
-            Slog.w(TAG, "String_Node_Str" + name + "String_Node_Str" + pkg.packageName);
+            if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
+                Slog.w(TAG, "String_Node_Str" + name + "String_Node_Str" + pkg.packageName);
+            }
             continue;


Input:
private void bindTexture(TileEntityPresent present) {
    int idx = present.getType() + (present.isConnected() ? 0 : 16);
    ResourceLocation rl = textureCache.get(idx);
    if (rl == null) {
        String res = ChiselBlocks.present.getModelTexture(present.getType());
        res += present.isConnected() ? "String_Node_Str" : "String_Node_Str";
        rl = new ResourceLocation("String_Node_Str", res);
        textureCache.put(idx, rl);
    }
    bindTexture(rl);
}

Output:
 private void bindTexture(TileEntityPresent present) {
-    int idx = present.getType() + (present.isConnected() ? 0 : 16);
+    int idx = present.getWorldObj().getBlockMetadata(present.xCoord, present.yCoord, present.zCoord) + (present.isConnected() ? 0 : 16);
     ResourceLocation rl = textureCache.get(idx);


Input:
private void populateGridBag() {
    gc.gridx = 0;
    gc.gridy = 0;
    gc.weightx = 1.0;
    gc.weighty = 1.0;
    gc.gridwidth = 1;
    gc.fill = GridBagConstraints.BOTH;
    this.getContentPane().add(playersPane, gc);
    gc.gridx = 0;
    gc.gridy = 1;
    gc.fill = 1;
    gc.weightx = 0.5;
    gc.weighty = 0.5;
    gc.gridwidth = 1;
    gc.ipady = 50;
    this.getContentPane().add(gameListPane, gc);
    gc.gridx = 0;
    gc.gridy = 2;
    gc.weightx = 0.0;
    gc.weighty = 0.0;
    gc.gridwidth = 1;
    gc.ipady = 0;
    gc.fill = GridBagConstraints.HORIZONTAL;
    this.getContentPane().add(optionsPane, gc);
    gc.gridx = 0;
    gc.gridy = 3;
    gc.weightx = 0.0;
    gc.weighty = 0.0;
    gc.gridwidth = 1;
    gc.ipady = 0;
    gc.fill = GridBagConstraints.HORIZONTAL;
    this.getContentPane().add(buttonPane, gc);
}

Output:
     gc.gridy = 0;
-    gc.weightx = 1.0;
-    gc.weighty = 1.0;
+    gc.weightx = 0;
+    gc.weighty = 0;
     gc.gridwidth = 1;


Input:
private double[][] _byteArrayToDoubleArray(byte[] byteArray, int bytesPerSample, int channels) {
    int lengthInSamples = byteArray.length / (bytesPerSample * channels);
    double[][] doubleArray = new double[channels][lengthInSamples];
    double maxSampleReciprocal;
    if (bytesPerSample == 2) {
        maxSampleReciprocal = 3.0517578125e-5;
    } else if (bytesPerSample == 1) {
        maxSampleReciprocal = 7.8125e-3;
    } else if (bytesPerSample == 3) {
        maxSampleReciprocal = 1.1920928955e07;
    } else if (bytesPerSample == 4) {
        maxSampleReciprocal = 4.655661287308e-10;
    } else {
        maxSampleReciprocal = 0;
    }
    byte[] b = new byte[bytesPerSample];
    for (int currSamp = 0; currSamp < lengthInSamples; currSamp++) {
        for (int currChannel = 0; currChannel < channels; currChannel++) {
            for (int i = 0; i < bytesPerSample; i += 1) {
                b[i] = byteArray[currSamp * bytesPerSample * channels + bytesPerSample * currChannel + i];
            }
            int result = (b[0] >> 7);
            for (int i = 0; i < bytesPerSample; i += 1) result = (result << 8) + (b[i] & 0xff);
            doubleArray[currChannel][currSamp] = ((double) result * maxSampleReciprocal);
        }
    }
    return doubleArray;
}

Output:
     int lengthInSamples = byteArray.length / (bytesPerSample * channels);
-    double[][] doubleArray = new double[channels][lengthInSamples];
+    if ((channels != _doubleArray.length) || (lengthInSamples != _doubleArray[0].length)) {
+        _doubleArray = new double[channels][lengthInSamples];
+    }
     double maxSampleReciprocal;


Input:
private void setHashCode() {
    int result = Arrays.hashCode(this.regionName);
    result ^= this.regionId;
    result ^= Arrays.hashCode(this.startKey);
    result ^= Arrays.hashCode(this.endKey);
    result ^= Boolean.valueOf(this.offLine).hashCode();
    result ^= Arrays.hashCode(this.tableName.getName());
    result ^= this.replicaId;
    this.hashCode = result;
}

Output:
     int result = Arrays.hashCode(this.regionName);
-    result ^= this.regionId;
+    result = (int) (result ^ this.regionId);
     result ^= Arrays.hashCode(this.startKey);


Input:
public SyncopeUser update(final SyncopeUser user, final UserMod userMod, final Set<Long> mandatoryRoles, final Set<String> mandatoryResources) throws WorkflowException, PropagationException {
    doExecuteAction(user, "String_Node_Str", Collections.singletonMap(USER_MOD, (Object) userMod));
    setStatus(user.getWorkflowId(), user);
    SyncopeUser updated = userDAO.save(user);
    PropagationByResource propByRes = (PropagationByResource) runtimeService.getVariable(user.getWorkflowId(), PROP_BY_RESOURCE);
    Set<String> mandatoryResourceNames = userService.getMandatoryResourceNames(user, mandatoryRoles, mandatoryResources);
    if (!mandatoryResourceNames.isEmpty()) {
        LOG.debug("String_Node_Str", mandatoryResourceNames);
    }
    propagationManager.update(updated, userMod.getPassword(), propByRes, mandatoryResourceNames);
    return updated;
}

Output:
     }
-    propagationManager.update(updated, userMod.getPassword(), propByRes, mandatoryResourceNames);
+    propagationManager.update(updated, userMod.getPassword(), null, propByRes, mandatoryResourceNames);
     return updated;


Input:
public Map<String, GuacamoleConfiguration> getAuthorizedConfigurations(Credentials credentials) throws GuacamoleException {
    logger.debug("String_Node_Str", credentials.getUsername());
    GuacamoleConfiguration config = new GuacamoleConfiguration();
    config.setProtocol("String_Node_Str");
    config.setParameter("String_Node_Str", "String_Node_Str");
    config.setParameter("String_Node_Str", "String_Node_Str");
    quickConnections.put("String_Node_Str", config);
    if (userContext == null)
        userContext = new QuickConnectUserContext(this, credentials.getUsername(), quickConnections);
    return quickConnections;
}

Output:
     if (userContext == null)
-        userContext = new QuickConnectUserContext(this, credentials.getUsername(), quickConnections);
-    return quickConnections;
+        userContext = new QuickConnectUserContext(this, credentials.getUsername());
+    return Collections.<String, GuacamoleConfiguration>emptyMap();
 }


Input:
public final ListenableFuture<State> stop() {
    lock.lock();
    try {
        switch(snapshot.state) {
            case NEW:
                snapshot = new StateSnapshot(State.TERMINATED);
                terminated(State.NEW);
                break;
            case STARTING:
                snapshot = new StateSnapshot(State.STARTING, true, null);
                stopping(State.STARTING);
                break;
            case RUNNING:
                snapshot = new StateSnapshot(State.STOPPING);
                stopping(State.RUNNING);
                doStop();
                break;
            case STOPPING:
            case TERMINATED:
            case FAILED:
                break;
            default:
                throw new AssertionError("String_Node_Str" + snapshot.state);
        }
    } catch (Throwable shutdownFailure) {
        notifyFailed(shutdownFailure);
    } finally {
        lock.unlock();
        executeListeners();
    }
    return shutdown;
}

Output:
     try {
-        switch(snapshot.state) {
+        State previous = state();
+        switch(previous) {
             case NEW:


Input:
private void sendP2PMessage(Object message, final ResponseListener<Object> listener) {
    JSONObject _payload = new JSONObject();
    try {
        _payload.put("String_Node_Str", "String_Node_Str");
        _payload.put("String_Node_Str", getFullAppId());
        _payload.put("String_Node_Str", message);
    } catch (JSONException ex) {
    }
    final JSONObject payload = _payload;
    if (isConnected()) {
        socket.sendMessage(payload, null);
        if (listener != null)
            listener.onSuccess(null);
    } else {
        ResponseListener<Object> joinListener = new ResponseListener<Object>() {
            public void onError(ServiceCommandError error) {
                if (listener != null)
                    listener.onError(error);
            }
            public void onSuccess(Object object) {
                socket.sendMessage(payload, null);
                if (listener != null)
                    listener.onSuccess(null);
            }
        };
        join(joinListener);
    }
}

Output:
         };
-        join(joinListener);
+        connect(connectListener);
     }


Input:
public boolean execute(Plugin plugin, CommandSender sender, String[] args) {
    String menuName = args[0];
    SMSMenu menu = SMSMenu.getMenu(menuName);
    if (args.length < 3 && menu.getDefaultCommand().isEmpty()) {
        throw new SMSException(getUsage()[0]);
    }
    menu.ensureAllowedToModify(sender);
    int pos = hasOption("String_Node_Str") ? getIntOption("String_Node_Str") : -1;
    String label = MiscUtil.parseColourSpec(sender, args[1]);
    String cmd = args.length >= 3 ? args[2] : "String_Node_Str";
    String msg = hasOption("String_Node_Str") ? getStringOption("String_Node_Str") : "String_Node_Str";
    String iconMat = hasOption("String_Node_Str") ? getStringOption("String_Node_Str") : plugin.getConfig().getString("String_Node_Str", "String_Node_Str");
    String[] lore = hasOption("String_Node_Str") ? getStringOption("String_Node_Str").split("String_Node_Str") : new String[0];
    if (sender instanceof Player && !new CommandParser().verifyCreationPerms((Player) sender, cmd)) {
        throw new SMSException("String_Node_Str");
    }
    SMSMenuItem newItem = new SMSMenuItem(menu, label, cmd, msg, iconMat, lore);
    if (pos < 0) {
        menu.addItem(newItem);
        MiscUtil.statusMessage(sender, "String_Node_Str" + label + "String_Node_Str" + menuName);
    } else {
        menu.insertItem(pos, newItem);
        int actualPos = menu.indexOfItem(label);
        MiscUtil.statusMessage(sender, "String_Node_Str" + label + "String_Node_Str" + menuName + "String_Node_Str" + actualPos);
    }
    menu.notifyObservers(SMSMenuAction.REPAINT);
    return true;
}

Output:
     String menuName = args[0];
-    SMSMenu menu = SMSMenu.getMenu(menuName);
+    SMSMenu menu = getMenu(sender, menuName);
     if (args.length < 3 && menu.getDefaultCommand().isEmpty()) {


Input:
private void saveUpdate(String msg) {
    if (GPS_longitude == 0 && GPS_latitude == 0) {
        GPS_longitude = Network_longitude;
        GPS_latitude = Network_latitude;
    }
    if (GPS_longitude == 0 && GPS_latitude == 0) {
        Location lastKnownGPSLocation = gpsLocationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        Location lastKnownNetworkLocation = networkLocationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
        Location lastBestKnownLocation;
        if (lastKnownGPSLocation.getTime() > lastKnownNetworkLocation.getTime()) {
            lastBestKnownLocation = lastKnownGPSLocation;
        } else {
            lastBestKnownLocation = lastKnownNetworkLocation;
        }
        GPS_latitude = (int) (lastBestKnownLocation.getLatitude() * 1E6);
        GPS_longitude = (int) (lastBestKnownLocation.getLongitude() * 1E6);
    }
    HappyBottle b = new HappyBottle(myID, GPS_latitude, GPS_longitude, emotion, msg, System.currentTimeMillis());
    dataHelper = new HappyData(this);
    dataHelper.addBottle(b);
}

Output:
         Location lastBestKnownLocation;
-        if (lastKnownGPSLocation.getTime() > lastKnownNetworkLocation.getTime()) {
-            lastBestKnownLocation = lastKnownGPSLocation;
-        } else {
-            lastBestKnownLocation = lastKnownNetworkLocation;
+        try {
+            if (lastKnownGPSLocation.getTime() > lastKnownNetworkLocation.getTime()) {
+                lastBestKnownLocation = lastKnownGPSLocation;
+            } else {
+                lastBestKnownLocation = lastKnownNetworkLocation;
+            }
+            GPS_latitude = (int) (lastBestKnownLocation.getLatitude() * 1E6);
+            GPS_longitude = (int) (lastBestKnownLocation.getLongitude() * 1E6);
+        } catch (Exception e) {
         }


Input:
public void testClassName() {
    Category category = Category.getInstance("String_Node_Str");
    Layout layout = PatternLayout.createLayout("String_Node_Str", null);
    ListAppender appender = new ListAppender("String_Node_Str", null, layout, false, false);
    appender.start();
    category.setAdditivity(false);
    category.getLogger().addAppender(appender);
    category.error("String_Node_Str");
    List<String> msgs = appender.getMessages();
    assertTrue("String_Node_Str" + msgs.size(), msgs.size() == 1);
    String msg = msgs.get(0);
    appender.clear();
    String expected = "String_Node_Str";
    assertTrue("String_Node_Str", msg.endsWith(expected));
}

Output:
     Category category = Category.getInstance("String_Node_Str");
-    Layout layout = PatternLayout.createLayout("String_Node_Str", null);
+    Layout layout = PatternLayout.createLayout("String_Node_Str", null, null, null);
     ListAppender appender = new ListAppender("String_Node_Str", null, layout, false, false);


Input:
protected ItemStackHandler createInput() {
    return new StackHandler(91);
}

Output:
 protected ItemStackHandler createInput() {
-    return new StackHandler(91);
+    return new StackHandler(91) {
+        public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
+            if (!isStackEqualToLock(stack) && EMCHelper.doesItemHaveEmc(stack))
+                return super.insertItem(slot, stack, simulate);
+            else
+                return stack;
+        }
+    };
 }


Input:
public void testMaxVertexLabel() throws Exception {
    for (long maxVertexLabel = 1; maxVertexLabel <= 10; maxVertexLabel++) {
        GraphTransaction<GraphHeadPojo, VertexPojo, EdgePojo> graph = new PredictableTransaction<>(1, true, getConfig()).map(maxVertexLabel);
        assertEquals((maxVertexLabel % 10 + 1) * 9 + 1, graph.getVertices().size());
        assertEquals((maxVertexLabel % 10 + 1) * 14, graph.getEdges().size());
        graph = new PredictableTransaction<>(1, false, getConfig()).map(maxVertexLabel);
        assertEquals((maxVertexLabel % 10 + 1) * 8 + 1, graph.getVertices().size());
        assertEquals((maxVertexLabel % 10 + 1) * 10, graph.getEdges().size());
    }
}

Output:
 public void testMaxVertexLabel() throws Exception {
-    for (long maxVertexLabel = 1; maxVertexLabel <= 10; maxVertexLabel++) {
+    for (long maxVertexLabel = 0; maxVertexLabel < 10; maxVertexLabel++) {
         GraphTransaction<GraphHeadPojo, VertexPojo, EdgePojo> graph = new PredictableTransaction<>(1, true, getConfig()).map(maxVertexLabel);


Input:
public void render(GL2 gl) {
    float yOffset = 0.0f;
    float elementHeight = y / numberOfElements;
    float step = 0;
    for (int i = 0; i < numberOfTextures; i++) {
        step = elementHeight * numberSamples.get(numberOfTextures - i - 1);
        textures.get(numberOfTextures - i - 1).enable();
        textures.get(numberOfTextures - i - 1).bind();
        gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_DECAL);
        gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_WRAP_S, GL2.GL_CLAMP);
        gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_WRAP_T, GL2.GL_CLAMP);
        gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
        gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST);
        TextureCoords texCoords = textures.get(numberOfTextures - i - 1).getImageTexCoords();
        float x1, x2 = 0;
        if (orientation) {
            x1 = 0;
            x2 = x;
        } else {
            x1 = x;
            x2 = 0;
        }
        gl.glBegin(GL2.GL_QUADS);
        gl.glColor4f(1f, 1f, 1f, 1f);
        gl.glTexCoord2d(texCoords.left(), texCoords.top());
        gl.glVertex3f(x1, yOffset, 0);
        gl.glTexCoord2d(texCoords.left(), texCoords.bottom());
        gl.glVertex3f(x1, yOffset + step, 0);
        gl.glTexCoord2d(texCoords.right(), texCoords.bottom());
        gl.glVertex3f(x2, yOffset + step, 0);
        gl.glTexCoord2d(texCoords.right(), texCoords.top());
        gl.glVertex3f(x2, yOffset, 0);
        gl.glEnd();
        yOffset += step;
        textures.get(numberOfTextures - i - 1).disable();
    }
}

Output:
         textures.get(numberOfTextures - i - 1).bind();
-        gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_DECAL);
+        gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE);
         gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_WRAP_S, GL2.GL_CLAMP);


Input:
public boolean createCluster(ClusterBlueprint blueprint, ClusterReportQueue reportQueue) throws SoftwareManagementPluginException {
    boolean success = false;
    AmClusterDef clusterDef = null;
    try {
        logger.info("String_Node_Str");
        logger.info(ApiUtils.objectToJson(blueprint));
        logger.info("String_Node_Str" + blueprint.getName() + "String_Node_Str");
        clusterDef = new AmClusterDef(blueprint, privateKey);
        provisionCluster(clusterDef, reportQueue);
        success = true;
        Map<String, NodeReport> nodeReports = clusterDef.getCurrentReport().getNodeReports();
        for (String nodeReportKey : nodeReports.keySet()) {
            nodeReports.get(nodeReportKey).setUseClusterMsg(true);
        }
        clusterDef.getCurrentReport().setAction("String_Node_Str");
        clusterDef.getCurrentReport().setProgress(ProgressSplit.PROVISION_SUCCESS.getProgress());
        clusterDef.getCurrentReport().setSuccess(success);
    } catch (Exception e) {
        clusterDef.getCurrentReport().setSuccess(success);
        String errorMessage = errorMessage("String_Node_Str" + blueprint.getName(), e);
        logger.error(errorMessage);
        throw SoftwareManagementPluginException.CREATE_CLUSTER_EXCEPTION(e, Constants.AMBARI_PLUGIN_NAME, blueprint.getName());
    } finally {
        clusterDef.getCurrentReport().setFinished(true);
        if (success) {
            clusterDef.getCurrentReport().setClusterAndNodesServiceStatus(ServiceStatus.STARTED);
        }
        reportStatus(clusterDef.getCurrentReport(), reportQueue);
    }
    return success;
}

Output:
         logger.info("String_Node_Str" + blueprint.getName() + "String_Node_Str");
-        clusterDef = new AmClusterDef(blueprint, privateKey);
+        String ambariServerVersion = getVersion();
+        clusterDef = new AmClusterDef(blueprint, privateKey, ambariServerVersion);
         provisionCluster(clusterDef, reportQueue);


Input:
public IArrayNode add(int index, IJsonNode element) {
    if (element == null) {
        throw new NullPointerException();
    }
    if (element.isMissing()) {
        this.remove(index);
    }
    if (index < 0 || index > this.size()) {
        throw new IndexOutOfBoundsException();
    }
    if (index < this.schema.getTailSize()) {
        for (int i = this.schema.getTailSize() - 1; i >= index; i--) {
            if (!this.record.isNull(i)) {
                if (i == this.schema.getTailSize() - 1) {
                    this.getOtherField().add(0, SopremoUtil.unwrap(this.record.getField(i, JsonNodeWrapper.class)));
                } else {
                    this.record.setField(i + 1, this.record.getField(i, JsonNodeWrapper.class));
                }
            }
        }
        this.record.setField(index, SopremoUtil.wrap(element));
    }
    return this;
}

Output:
     }
-    if (index < this.schema.getTailSize()) {
-        for (int i = this.schema.getTailSize() - 1; i >= index; i--) {
-            if (!this.record.isNull(i)) {
-                if (i == this.schema.getTailSize() - 1) {
-                    this.getOtherField().add(0, SopremoUtil.unwrap(this.record.getField(i, JsonNodeWrapper.class)));
-                } else {
-                    this.record.setField(i + 1, this.record.getField(i, JsonNodeWrapper.class));
+    int recordPosition = this.schema.getTailSize() - size() + index;
+    if (recordPosition < 0) {
+        this.getOtherField().add(index, element);
+    } else {
+        IJsonNode oldNode = SopremoUtil.unwrap(this.record.getField(recordPosition + 1, JsonNodeWrapper.class));
+        IJsonNode tmpNode;
+        this.record.setField(recordPosition + 1, SopremoUtil.wrap(element));
+        for (int i = recordPosition + 1; i > 0; i--) {
+            if (this.record.isNull(i)) {
+                this.record.setField(i, SopremoUtil.wrap(oldNode));
+                return this;
+            } else {
+                tmpNode = SopremoUtil.unwrap(this.record.getField(i, JsonNodeWrapper.class));
+                if (oldNode != null) {
+                    this.record.setField(i, SopremoUtil.wrap(oldNode));
                 }


Input:
protected void setUp() throws Exception {
    super.setUp();
    final Properties props = new Properties();
    final URI uri = URI.create("String_Node_Str");
    Namespace namespace = discoveryLocator.getServicesNamespace();
    IServiceTypeID serviceTypeID = ServiceIDFactory.getDefault().createServiceTypeID(namespace, new String[] { "String_Node_Str" }, new String[] { DOMAIN }, new String[] { "String_Node_Str" }, "String_Node_Str");
    assertNotNull(serviceTypeID);
    final ServiceProperties serviceProperties = new ServiceProperties(props);
    serviceProperties.setPropertyString("String_Node_Str", "String_Node_Str");
    serviceProperties.setPropertyString("String_Node_Str", "String_Node_Str");
    serviceInfo = new ServiceInfo(uri, "String_Node_Str", serviceTypeID, 10, 0, serviceProperties);
    assertNotNull(serviceInfo);
}

Output:
     final Properties props = new Properties();
-    final URI uri = URI.create("String_Node_Str");
+    final URI uri = URI.create(SCHEME + "String_Node_Str" + DOMAIN_A_RECORD + "String_Node_Str" + PORT + PATH);
     Namespace namespace = discoveryLocator.getServicesNamespace();


Input:
private static Document load(File file) throws Exception {
    final long fileLength = file.length();
    System.err.print("String_Node_Str");
    SAXReader saxReader = new SAXReader();
    Document document = saxReader.read(new FileReader(file) {
        public int read(char[] chars) throws IOException {
            int n = super.read(chars);
            for (int i = 0; i < n; i++) {
                chars[i] = replaceIfIllegal(chars[i]);
            }
            return n;
        }
        public int read(char[] chars, int start, int length) throws IOException {
            int n = super.read(chars, start, length);
            for (int i = 0; i < n; i++) {
                chars[i] = replaceIfIllegal(chars[i]);
            }
            readProgress(fileLength, curr += n, length);
            return n;
        }
        private char replaceIfIllegal(char c) {
            if (c < 0x20 && !(c == 0x09 || c == 0x0a || c == 0x0d)) {
                errCount++;
                return (char) 0x20;
            }
            return c;
        }
        private void readProgress(long length, long current, int blockSize) {
            long percentage = current * 100 / length;
            if (percentage % 5 != 0 && ((current - blockSize) * 100 / length) % 5 == 0) {
                System.err.print("String_Node_Str");
            } else if (percentage % 20 == 0 && ((current - blockSize) * 100 / length) % 20 != 0) {
                System.err.print(NumberFormat.getIntegerInstance().format(percentage) + "String_Node_Str");
            }
        }
    });
    System.err.println();
    if (errCount > 0) {
        System.err.println("String_Node_Str" + errCount + "String_Node_Str");
        System.err.println("String_Node_Str");
        System.err.println("String_Node_Str");
    }
    return document;
}

Output:
         }
-    });
+    };
+    Document document = saxReader.read(reader);
     System.err.println();


Input:
private double getMean() {
    double[] values = getValues();
    double result = 1.0d;
    for (int i = 0; i < values.length; i++) {
        result *= Math.pow(values[i], 1.0d / (double) values.length);
    }
    return result;
}

Output:
     for (int i = 0; i < values.length; i++) {
-        result *= Math.pow(values[i], 1.0d / (double) values.length);
+        result *= Math.pow(values[i] + 1.0d, 1.0d / (double) values.length);
     }


Input:
public Double getMean() {
    Long c = getCount();
    if (c.compareTo(0L) == 0) {
        throw new RuntimeException("String_Node_Str");
    }
    Double sum = Double.valueOf(getSumStr());
    if (sum == null) {
        throw new RuntimeException("String_Node_Str");
    }
    return sum / c;
}

Output:
     }
-    Double sum = Double.valueOf(getSumStr());
+    Double sum = null;
+    try {
+        sum = Double.valueOf(getSumStr());
+    } catch (Exception e) {
+        sum = Double.valueOf(0);
+    }
     if (sum == null) {


Input:
public Deque<Interval> mergeInterval(Interval[] intervals) {
    Deque<Interval> stack = new LinkedList<Interval>();
    stack.offerFirst(intervals[0]);
    for (int i = 1; i < intervals.length; i++) {
        Interval curr = stack.peekFirst();
        if (curr.end <= intervals[i].start) {
            stack.offerFirst(intervals[i]);
        } else if (curr.end > intervals[i].start) {
            Interval newInterval = mergeOverlap(curr, intervals[i]);
            if (newInterval != null) {
                stack.offerFirst(newInterval);
            }
        }
    }
    return stack;
}

Output:
         Interval curr = stack.peekFirst();
-        if (curr.end <= intervals[i].start) {
+        if (curr.end < intervals[i].start) {
             stack.offerFirst(intervals[i]);


Input:
public static ECPoint doublePointBc(EllipticCurve curve, ECPoint ecPoint) {
    if (ecPoint.equals(ECPoint.POINT_INFINITY)) {
        return ecPoint;
    }
    org.bouncycastle.math.ec.ECCurve curveBc;
    org.bouncycastle.math.ec.ECPoint pointBc, pointBcTwice;
    curveBc = EC5Util.convertCurve(curve);
    pointBc = EC5Util.convertPoint(curveBc, ecPoint, false);
    pointBcTwice = pointBc.twice();
    ECFieldElement ecfX = pointBcTwice.normalize().getXCoord();
    ECFieldElement ecfY = pointBcTwice.normalize().getYCoord();
    BigInteger x = ecfX.toBigInteger();
    BigInteger y = ecfY.toBigInteger();
    ECPoint ecPointTwice = new ECPoint(x, y);
    return ecPointTwice;
}

Output:
     org.bouncycastle.math.ec.ECCurve curveBc;
-    org.bouncycastle.math.ec.ECPoint pointBc, pointBcTwice;
+    org.bouncycastle.math.ec.ECPoint ecPointPbc, ecPointRbc;
     curveBc = EC5Util.convertCurve(curve);


Input:
public String generateComponentCodeWithRows(String nodeName, IAloneProcessNodeConfigurer nodeConfigurer) {
    StringBuffer componentsCode = new StringBuffer();
    if (process == null) {
        throw new NullPointerException();
    } else {
        INode nodeToConfigure = extractNodeFromProcess(nodeName);
        if (nodeToConfigure != null) {
            if (nodeConfigurer != null) {
                nodeConfigurer.configure(nodeToConfigure);
            }
            Vector headerArgument = new Vector(2);
            headerArgument.add(process);
            headerArgument.add(VersionUtils.getVersion());
            headerArgument.add("String_Node_Str");
            this.checkingSyntax = true;
            try {
                componentsCode.append(generateTypedComponentCode(EInternalTemplate.HEADER, headerArgument));
                componentsCode.append(generateTypedComponentCode(EInternalTemplate.HEADER_ADDITIONAL, headerArgument));
                for (NodesSubTree subTree : processTree.getSubTrees()) {
                    INode subTreeNode = subTree.getNode(nodeName);
                    componentsCode.append(generateTypedComponentCode(EInternalTemplate.SUBPROCESS_HEADER, subTree));
                    StringBuffer finallyPart = new StringBuffer();
                    if (subTreeNode != null) {
                        if (!subTree.isMergeSubTree()) {
                            componentsCode.append(generateComponentsCode(subTree, subTree.getRootNode(), ECodePart.BEGIN, null));
                            componentsCode.append(generateComponentsCode(subTree, subTree.getRootNode(), ECodePart.MAIN, null));
                            componentsCode.append(generateTypedComponentCode(EInternalTemplate.PART_ENDMAIN, subTree.getRootNode()));
                            componentsCode.append(generateComponentsCode(subTree, subTree.getRootNode(), ECodePart.END, null));
                            finallyPart.append(generateComponentsCode(subTree, subTree.getRootNode(), ECodePart.FINALLY, null));
                        } else {
                            componentsCode.append(generateComponentsCode(subTree, subTree.getMergeNode(), ECodePart.BEGIN, null));
                            List<INode> sortedMergeBranchStarts = subTree.getSortedMergeBranchStarts();
                            for (INode startNode : sortedMergeBranchStarts) {
                                componentsCode.append(generateComponentsCode(subTree, startNode, ECodePart.BEGIN, null));
                                componentsCode.append(generateComponentsCode(subTree, startNode, ECodePart.MAIN, null));
                                componentsCode.append(generateComponentsCode(subTree, startNode, ECodePart.END, null));
                                finallyPart.append(generateComponentsCode(subTree, startNode, ECodePart.FINALLY, null));
                            }
                            componentsCode.append(generateTypedComponentCode(EInternalTemplate.PART_ENDMAIN, subTree.getRootNode()));
                            componentsCode.append(generateComponentsCode(subTree, subTree.getMergeNode(), ECodePart.END, null));
                            finallyPart.append(generateComponentsCode(subTree, subTree.getMergeNode(), ECodePart.FINALLY, null));
                        }
                    }
                    Vector subprocess_footerArgument = new Vector(2);
                    subprocess_footerArgument.add(subTree);
                    subprocess_footerArgument.add(finallyPart.toString());
                    componentsCode.append(generateTypedComponentCode(EInternalTemplate.SUBPROCESS_FOOTER, subprocess_footerArgument));
                }
                Vector footerArgument = new Vector(2);
                footerArgument.add(process);
                footerArgument.add(processTree.getRootNodes());
                componentsCode.append(generateTypedComponentCode(EInternalTemplate.FOOTER, footerArgument));
                componentsCode.append(generateTypedComponentCode(EInternalTemplate.PROCESSINFO, componentsCode.length()));
            } catch (CodeGeneratorException ce) {
                ExceptionHandler.process(ce);
                componentsCode = new StringBuffer();
            }
        } else {
            throw new TypeNotPresentException(Messages.getString("String_Node_Str"), null);
        }
    }
    return componentsCode.toString();
}

Output:
                         } else {
-                            componentsCode.append(generateComponentsCode(subTree, subTree.getMergeNode(), ECodePart.BEGIN, null));
+                            for (INode mergeNode : subTree.getMergeNodes()) {
+                                componentsCode.append(generateComponentsCode(subTree, mergeNode, ECodePart.BEGIN, null));
+                            }
                             List<INode> sortedMergeBranchStarts = subTree.getSortedMergeBranchStarts();


Input:
public View inflateAnnotation(View v, Annotation annotation) {
    ViewHolder vh = (ViewHolder) v.getTag(R.id.listItem);
    if (false) {
        vh.favorited.setVisibility(View.VISIBLE);
    } else {
        vh.favorited.setVisibility(View.GONE);
    }
    if (vh.title != null) {
        vh.title.setText(annotation.getTitle());
    }
    if (vh.author != null) {
        vh.author.setText(annotation.getAuthor());
    }
    if (vh.line != null) {
        vh.line.setText(provider.getProgramLine(annotation.getLid()).getName());
    }
    if (annotation.getStartTime() != null && annotation.getEndTime() != null) {
        vh.time.setText(formatDate(annotation.getStartTime()) + "String_Node_Str" + todayFormat.format(annotation.getEndTime()));
        if (annotation.getLid() > 0) {
            vh.line.setText(vh.line.getText() + "String_Node_Str");
        }
    } else {
        vh.title.setText("String_Node_Str");
    }
    if (annotation.getLocation() != null) {
        vh.place.setText(annotation.getLocation());
        if (annotation.getLid() > 0) {
            vh.line.setText(vh.line.getText() + "String_Node_Str");
        }
    } else {
        vh.place.setText("String_Node_Str");
    }
    if (vh.programType != null) {
        vh.programType.setImageResource(annotation.getProgramIcon());
    }
    return v;
}

Output:
     ViewHolder vh = (ViewHolder) v.getTag(R.id.listItem);
-    if (false) {
+    if (provider.getFavorited().contains(Integer.valueOf(annotation.getPid()))) {
         vh.favorited.setVisibility(View.VISIBLE);


Input:
public JsonElement serialize(List<PortConfig> src, Type typeOfSrc, JsonSerializationContext context) {
    if (src.size() == 0) {
        s_logger.info("String_Node_Str");
        return new JsonNull();
    }
    Gson json = s_gBuilder.create();
    s_logger.debug("String_Node_Str");
    return json.toJsonTree(src, listType);
}

Output:
     s_logger.debug("String_Node_Str");
-    return json.toJsonTree(src, listType);
+    JsonArray array = new JsonArray();
+    for (PortConfig pc : src) {
+        array.add(json.toJsonTree(pc));
+    }
+    return array;
 }


Input:
public void renameFolder(ERepositoryObjectType type, IPath path, String label) throws PersistenceException {
    this.repositoryFactoryFromProvider.renameFolder(type, path, label);
    if (type == ERepositoryObjectType.PROCESS) {
        fireRepositoryPropertyChange(ERepositoryActionName.FOLDER_RENAME.getName(), path, label);
    }
    if (type == ERepositoryObjectType.JOBLET) {
        fireRepositoryPropertyChange(ERepositoryActionName.JOBLET_FOLDER_RENAME.getName(), path, label);
    }
    this.repositoryFactoryFromProvider.updateItemsPath(type, path.removeLastSegments(1).append(label));
}

Output:
 public void renameFolder(ERepositoryObjectType type, IPath path, String label) throws PersistenceException {
-    this.repositoryFactoryFromProvider.renameFolder(type, path, label);
+    if (this.repositoryFactoryFromProvider.isLocalConnectionProvider()) {
+        this.repositoryFactoryFromProvider.renameFolderForLocal(type, path, label);
+    } else {
+        this.repositoryFactoryFromProvider.renameFolder(type, path, label);
+    }
     if (type == ERepositoryObjectType.PROCESS) {


Input:
public static void main(String[] args) {
    TypedProperties connectionParams = PropertiesLoader.getProperties(IndicatorEvaluator.class, "String_Node_Str");
    String driverClassName = connectionParams.getProperty("String_Node_Str");
    String dbUrl = connectionParams.getProperty("String_Node_Str");
    try {
        Connection connection = ConnectionUtils.createConnection(dbUrl, driverClassName, connectionParams);
        TdDataProvider dataProvider = new TestAnalysisCreation().getDataManager();
        String catalog = "String_Node_Str";
        ConnectionEvaluator evaluator = new ConnectionEvaluator();
        evaluator.setConnection(connection);
        ConnectionIndicator connectionIndicator = SchemaFactory.eINSTANCE.createConnectionIndicator();
        evaluator.storeIndicator(dataProvider, connectionIndicator);
        String sql = createSql(catalog);
        ReturnCode rc = evaluator.evaluateIndicators(sql, false);
        if (!rc.isOk()) {
            System.err.println("String_Node_Str" + rc.getMessage());
        }
        File file = new File("String_Node_Str" + IndicatorsPackage.eNAME);
        EMFUtil util = new EMFUtil();
        if (!util.addPoolToResourceSet(file.toURI().toString(), connectionIndicator)) {
            System.err.println(util.getLastErrorMessage());
        }
        File dp = new File("String_Node_Str");
        FolderProvider fProv = new FolderProvider();
        fProv.setFolder(dp);
        DqRepositoryViewService.saveDataProviderAndStructure(dataProvider, fProv);
        util.save();
        ConnectionUtils.closeConnection(connection);
    } catch (SQLException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

Output:
         File file = new File("String_Node_Str" + IndicatorsPackage.eNAME);
-        EMFUtil util = new EMFUtil();
+        EMFUtil util = EMFUtil.getInstance();
         if (!util.addPoolToResourceSet(file.toURI().toString(), connectionIndicator)) {


Input:
public void generateAllPdfMail() {
    LOG.debug("String_Node_Str");
    List<Mail> mailList = Mail.filter("String_Node_Str").fetch();
    LOG.debug("String_Node_Str", mailList.size());
    for (Mail mail : mailList) {
        try {
            this.generatePdfMail(mail);
        } catch (AxelorException e) {
            TraceBackService.trace(e);
            LOG.error("String_Node_Str", mail.getName());
        }
    }
}

Output:
     LOG.debug("String_Node_Str");
-    List<Mail> mailList = Mail.filter("String_Node_Str").fetch();
+    List<? extends Mail> mailList = Mail.filter("String_Node_Str").fetch();
     LOG.debug("String_Node_Str", mailList.size());


Input:
public static void main(String[] args) throws SmbException, IOException {
    LogManager.getLogManager().readConfiguration();
    LocalParser musicController = new LocalParser();
    musicController.parse("String_Node_Str");
    musicController.close();
}

Output:
     LocalParser musicController = new LocalParser();
-    musicController.parse("String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
+    musicController.parse("String_Node_Str", "String_Node_Str");
     musicController.close();


Input:
public Optional<Duration> getTime() {
    return time;
}

Output:
 public Optional<Duration> getTime() {
-    return time;
+    return Optional.ofNullable(time);
 }


Input:
private String finalNewline(String content, String lineEnding) {
    if (!content.endsWith("String_Node_Str") && content.endsWith("String_Node_Str")) {
        LOG.log(Level.INFO, "String_Node_Str");
        return content + lineEnding;
    } else {
        LOG.log(Level.INFO, "String_Node_Str");
        return content;
    }
}

Output:
 private String finalNewline(String content, String lineEnding) {
-    if (!content.endsWith("String_Node_Str") && content.endsWith("String_Node_Str")) {
+    if (!content.endsWith("String_Node_Str") && !content.endsWith("String_Node_Str")) {
         LOG.log(Level.INFO, "String_Node_Str");


Input:
protected void tryBackup(EmbeddedGraphDatabase neo, String location, int relCount) throws IOException {
    System.out.println("String_Node_Str");
    Backup backupComp = new Neo4jBackup(neo, location);
    backupComp.doBackup();
    EmbeddedGraphDatabase bNeo = Util.startNeoInstance(location);
    Transaction bTx = bNeo.beginTx();
    try {
        List<Relationship> rels = new ArrayList<Relationship>();
        for (Relationship rel : bNeo.getReferenceNode().getRelationships()) {
            rels.add(rel);
        }
        assertEquals(relCount, rels.size());
        bTx.success();
    } finally {
        bTx.finish();
    }
    Util.stopNeo(bNeo);
}

Output:
     System.out.println("String_Node_Str");
-    Backup backupComp = new Neo4jBackup(neo, location);
+    Backup backupComp = new Neo4jBackup(graphDb, location);
     backupComp.doBackup();


Input:
public void modelException(ProxyModelInfrastructure proxyModelInfrastructure, String message, Throwable exception) {
    PtolemyServer.LOGGER.log(Level.INFO, "String_Node_Str" + proxyModelInfrastructure.getTicket().getTicketID() + "String_Node_Str", exception);
    try {
        proxyModelInfrastructure.getTokenPublisher().sendToken(new RemoteEventToken(message, exception), null);
    } catch (Throwable e) {
        PtolemyServer.LOGGER.log(Level.SEVERE, "String_Node_Str" + proxyModelInfrastructure.getTicket().getTicketID(), exception);
    } finally {
        try {
            PtolemyServer.getInstance().close(proxyModelInfrastructure.getTicket());
        } catch (Throwable e) {
            PtolemyServer.LOGGER.log(Level.SEVERE, "String_Node_Str" + proxyModelInfrastructure.getTicket().getTicketID(), exception);
        }
    }
}

Output:
 public void modelException(ProxyModelInfrastructure proxyModelInfrastructure, String message, Throwable exception) {
-    PtolemyServer.LOGGER.log(Level.INFO, "String_Node_Str" + proxyModelInfrastructure.getTicket().getTicketID() + "String_Node_Str", exception);
+    PtolemyServer.LOGGER.log(Level.SEVERE, "String_Node_Str" + proxyModelInfrastructure.getTicket().getTicketID() + "String_Node_Str", exception);
     try {


Input:
public IAMPolicy addIAMPermissionToIAMPolicy(long iamPolicyId, String entityType, PermissionScope scope, Long scopeId, String action, Permission perm, Boolean recursive) {
    Class<?> cmdClass = _apiServer.getCmdClass(action);
    AccessType accessType = null;
    if (BaseListCmd.class.isAssignableFrom(cmdClass)) {
        accessType = AccessType.UseEntry;
    }
    return _iamSrv.addIAMPermissionToIAMPolicy(iamPolicyId, entityType, scope.toString(), scopeId, action, accessType.toString(), perm, recursive);
}

Output:
     }
-    return _iamSrv.addIAMPermissionToIAMPolicy(iamPolicyId, entityType, scope.toString(), scopeId, action, accessType.toString(), perm, recursive);
+    String accessTypeStr = (accessType != null) ? accessType.toString() : null;
+    return _iamSrv.addIAMPermissionToIAMPolicy(iamPolicyId, entityType, scope.toString(), scopeId, action, accessTypeStr, perm, recursive);
 }


Input:
public IDocumentObject createDocumentObject(String documentObjectName) throws IOException {
    ObjectStructure objectStructure = new ObjectStructure();
    objectStructure.name = documentObjectName;
    objectStructure.firstBlock = findFreeBlock();
    objectStructure.length = 0;
    writeObjectStructure(objectStructure);
    this.documentObjectMap.put(objectStructure.name, objectStructure);
    return new DocumentObject(new BufferedRandomDataAccessObject(new BlockRandomAccessObject(dataFile, documentObjectName, objectStructure.firstBlock, objectStructure.length, this), 1024));
}

Output:
     this.documentObjectMap.put(objectStructure.name, objectStructure);
-    return new DocumentObject(new BufferedRandomDataAccessObject(new BlockRandomAccessObject(dataFile, documentObjectName, objectStructure.firstBlock, objectStructure.length, this), 1024));
+    return new DocumentObject(new BufferedRandomDataAccessObject(new BlockRandomAccessObject(dataAccessFile, documentObjectName, objectStructure.firstBlock, objectStructure.length, this), 1024));
 }


Input:
public Representation getDraftTreeSubtreeForNodes(GraphDatabaseService graphDb, long[] nodeIds, long[] ottIds) throws MultipleHitsException, TaxonNotFoundException {
    if (nodeIds.length < 1 && ottIds.length < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    ArrayList<Node> tips = new ArrayList<Node>();
    GraphExplorer ge = new GraphExplorer(graphDb);
    if (nodeIds != null && nodeIds.length > 0) {
        for (long nodeId : nodeIds) {
            Node n = graphDb.getNodeById(nodeId);
            if (n != null) {
                tips.add(n);
            }
        }
    }
    if (ottIds != null && ottIds.length > 0) {
        for (long ottId : ottIds) {
            Node n = ge.findGraphTaxNodeByUID(String.valueOf(ottId));
            if (n != null) {
                tips.add(n);
            }
        }
    }
    if (tips.size() < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    } else {
        HashMap<String, Object> vals = new HashMap<String, Object>();
        vals.put("String_Node_Str", tips);
        vals.put("String_Node_Str", ge.extractDraftSubtreeForTipNodes(tips).getNewick(true) + "String_Node_Str");
        return OTRepresentationConverter.convert(vals);
    }
}

Output:
 public Representation getDraftTreeSubtreeForNodes(GraphDatabaseService graphDb, long[] nodeIds, long[] ottIds) throws MultipleHitsException, TaxonNotFoundException {
-    if (nodeIds.length < 1 && ottIds.length < 1) {
+    if ((nodeIds == null || nodeIds.length < 1) && (ottIds == null || ottIds.length < 1)) {
         throw new IllegalArgumentException("String_Node_Str");


Input:
public Object[] eval(T program, Parameters params) throws MalformedProgramException {
    int noParamSets = params.getNoParameterSets();
    int noParams = params.getNoParameters();
    String expression = generator.getSource(program);
    Object[] results = new Object[noParamSets];
    for (int i = 0; i < noParamSets; i++) {
        parser.undeclareAllVariables();
        Object[] paramSet = params.getParameterSet(i);
        for (int j = 0; j < noParams; j++) {
            parser.declareVariable(new Variable(params.getIdentifier(j), paramSet[j]));
        }
        final Node programTree = parser.parse(expression);
        results[i] = programTree.evaluate();
    }
    return results;
}

Output:
     for (int i = 0; i < noParamSets; i++) {
-        parser.undeclareAllVariables();
+        for (int j = 0; j < noParams; j++) {
+            parser.undeclare(declaredVariables[j]);
+        }
         Object[] paramSet = params.getParameterSet(i);


Input:
public void run() {
    if (entries != fTreeViewer.getInput()) {
        fTreeViewer.setInput(entries);
    } else {
        fTreeViewer.refresh();
    }
    for (TreeColumn column : fTreeViewer.getTree().getColumns()) {
        column.pack();
    }
}

Output:
 public void run() {
-    if (entries != fTreeViewer.getInput()) {
-        fTreeViewer.setInput(entries);
+    if (rootEntry != fTreeViewer.getInput()) {
+        fTreeViewer.setInput(rootEntry);
     } else {


Input:
private Node getVarNode(Var var) {
    Node node = varNodes.get(var);
    if (node == null) {
        node = new Node(var);
        varNodes.put(var, node);
    }
    return node;
}

Output:
     if (node == null) {
-        node = new Node(var);
+        node = new Node(var, nextNodeID++);
         varNodes.put(var, node);


Input:
protected void drawZeroLine(Canvas c) {
    int clipRestoreCount = c.save();
    mZeroLineClippingRect.set(mViewPortHandler.getContentRect());
    mZeroLineClippingRect.inset(0.f, -mYAxis.getZeroLineWidth() / 2.f);
    c.clipRect(mLimitLineClippingRect);
    MPPointD pos = mTrans.getPixelForValues(0f, 0f);
    mZeroLinePaint.setColor(mYAxis.getZeroLineColor());
    mZeroLinePaint.setStrokeWidth(mYAxis.getZeroLineWidth());
    Path zeroLinePath = mDrawZeroLinePath;
    zeroLinePath.reset();
    zeroLinePath.moveTo(mViewPortHandler.contentLeft(), (float) pos.y - 1);
    zeroLinePath.lineTo(mViewPortHandler.contentRight(), (float) pos.y - 1);
    c.drawPath(zeroLinePath, mZeroLinePaint);
    c.restoreToCount(clipRestoreCount);
}

Output:
     mZeroLineClippingRect.inset(0.f, -mYAxis.getZeroLineWidth() / 2.f);
-    c.clipRect(mLimitLineClippingRect);
+    c.clipRect(mZeroLineClippingRect);
     MPPointD pos = mTrans.getPixelForValues(0f, 0f);


Input:
private void init() {
    count = 0;
    paint = new Paint();
    paint1 = new Paint();
    paint.setColor(Color.BLACK);
    paint.setStrokeWidth(10);
    paint.setAntiAlias(true);
    paint.setStrokeCap(Paint.Cap.ROUND);
    paint.setStrokeJoin(Paint.Join.ROUND);
    paint.setStyle(Paint.Style.STROKE);
    paint.setShadowLayer(0, 0, 0, Color.BLACK);
    paint1.setColor(Color.BLACK);
    paint1.setStrokeWidth(8);
    paint1.setAntiAlias(true);
    paint1.setStrokeCap(Paint.Cap.ROUND);
    paint1.setStyle(Paint.Style.FILL_AND_STROKE);
    path = new Path();
}

Output:
     paint1.setStrokeCap(Paint.Cap.ROUND);
-    paint1.setStyle(Paint.Style.FILL_AND_STROKE);
+    paint1.setStyle(Paint.Style.FILL);
     path = new Path();


Input:
public boolean equals(Object o) {
    return o instanceof Element && ((Element) o).setName().equals(setName()) && ((Element) o).uniqueId() == uniqueId();
}

Output:
 public boolean equals(Object o) {
-    return o instanceof Element && ((Element) o).setName().equals(setName()) && ((Element) o).uniqueId() == uniqueId();
+    return o instanceof Element && ((Element) o).setName().equals(setName()) && ((Element) o).uniqueId() == uniqueId() && ((Element) o).type() == type();
 }


Input:
private Tag createTags(Tag tag) {
    String ns = tag.getNamespace();
    if (HTML_NAMESPACE.equals(ns)) {
        active = true;
        TagAttributes modifiedAttributes = tag.getAttributes();
        if ("String_Node_Str".equals(tag.getLocalName())) {
            TagAttribute tagAttribute = modifiedAttributes.get(PASS_THROUGH_NAMESPACE, "String_Node_Str");
            if ("String_Node_Str".equals(tagAttribute.getValue())) {
                return convertElementToInputText(tag, modifiedAttributes);
            }
            if ("String_Node_Str".equals(tagAttribute.getValue())) {
                return convertDivElementToPanelGroup(tag, modifiedAttributes, true);
            }
        }
        Tag newTag = relaxedDecorator.decorate(tag);
        if (newTag != null && newTag != tag) {
            return newTag;
        }
        if ("String_Node_Str".equals(tag.getLocalName())) {
            return convertToInputText(tag, modifiedAttributes);
        }
        if ("String_Node_Str".equals(tag.getLocalName())) {
            return convertDivTagToPanelGroup(tag, modifiedAttributes, true);
        }
        if ("String_Node_Str".equals(tag.getLocalName())) {
            return convertDivTagToPanelGroup(tag, modifiedAttributes, false);
        }
        if ("String_Node_Str".equals(tag.getLocalName())) {
            return convertTofSelectItemText(tag, modifiedAttributes);
        }
        tag = convertBootsFacesTag(tag);
    }
    return tag;
}

Output:
             if ("String_Node_Str".equals(tagAttribute.getValue())) {
-                return convertElementToInputText(tag, modifiedAttributes);
+                return convertElementToInputTag(tag, modifiedAttributes);
+            }
+            if ("String_Node_Str".equals(tagAttribute.getValue())) {
+                return convertElementToSelectOneMenuTag(tag, modifiedAttributes);
             }


Input:
public T unmarshal(Object object) throws Exception {
    if (object == null) {
        return null;
    }
    PersistenceWeavedRest persistenceWeavedRest = null;
    Link link = null;
    if (object instanceof PersistenceWeavedRest) {
        persistenceWeavedRest = (PersistenceWeavedRest) object;
        link = persistenceWeavedRest._persistence_getHref();
    } else if (object instanceof Link) {
        link = (Link) object;
    } else {
        return null;
    }
    if ((null == link) || ((link != null) && (link.getHref() == null))) {
        if (persistenceWeavedRest != null) {
            ClassDescriptor descriptor = context.getJAXBDescriptorForClass(persistenceWeavedRest.getClass());
            if (persistenceWeavedRest instanceof FetchGroupTracker && JpaHelper.getDatabaseSession(context.getEmf()).doesObjectExist(persistenceWeavedRest)) {
                if (context.doesExist(null, persistenceWeavedRest)) {
                    FetchGroup fetchGroup = new FetchGroup();
                    for (DatabaseMapping mapping : descriptor.getMappings()) {
                        if (!(mapping instanceof XMLInverseReferenceMapping)) {
                            fetchGroup.addAttribute(mapping.getAttributeName());
                        }
                    }
                    (new FetchGroupManager()).setObjectFetchGroup(persistenceWeavedRest, fetchGroup, null);
                }
            }
            return (T) persistenceWeavedRest;
        }
    }
    if ((link != null) && (link.getHref() != null)) {
        String uri = link.getHref().replace("String_Node_Str", "String_Node_Str");
        String entityType = uri.substring(uri.indexOf("String_Node_Str"), uri.lastIndexOf('/'));
        entityType = entityType.substring(entityType.lastIndexOf("String_Node_Str") + 1);
        String entityId = uri.substring(uri.lastIndexOf("String_Node_Str") + 1);
        ClassDescriptor descriptor = context.getDescriptor(entityType);
        Object id = IdHelper.buildId(context, descriptor.getAlias(), entityId);
        T foundEntity = (T) getObjectById(entityType, id);
        return foundEntity;
    }
    return null;
}

Output:
     PersistenceWeavedRest persistenceWeavedRest = null;
-    Link link = null;
+    Link link;
     if (object instanceof PersistenceWeavedRest) {


Input:
public Collection getReportParameters() {
    if (parameterTask != null) {
        return parameterTask.getParameters().getContents();
    }
    return null;
}

Output:
     if (parameterTask != null) {
-        return parameterTask.getParameters().getContents();
+        return parameterTask.getParameterDefns(false);
     }


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.ZONE_CHANGE) {
        UUID sourceId = getSourceId();
        if (game.getPermanent(sourceId) == null) {
            if (game.getLastKnownInformation(sourceId, Constants.Zone.BATTLEFIELD) == null) {
                return false;
            }
        }
        ZoneChangeEvent zEvent = (ZoneChangeEvent) event;
        Permanent permanent = zEvent.getTarget();
        if (permanent != null && permanent.getCardType().contains(Constants.CardType.CREATURE) && zEvent.isDiesEvent() && permanent.getControllerId().equals(this.getControllerId())) {
            return true;
        }
    }
    return false;
}

Output:
         Permanent permanent = zEvent.getTarget();
-        if (permanent != null && permanent.getCardType().contains(Constants.CardType.CREATURE) && zEvent.isDiesEvent() && permanent.getControllerId().equals(this.getControllerId())) {
+        if (permanent != null && permanent.getCardType().contains(Constants.CardType.CREATURE) && zEvent.isDiesEvent() && permanent.getControllerId().equals(this.getControllerId()) && filter != null && filter.match(permanent)) {
             return true;


Input:
public boolean nextEntry(EntryCallback entryCallback, int chronicleId) {
    while (true) {
        long position = nextPosition();
        if (position == NOT_FOUND) {
            this.position = NOT_FOUND;
            return false;
        }
        this.position = position;
        int tierIndexMinusOne = (int) (position >>> segmentIndexShift);
        try (CompiledReplicatedMapIterationContext<K, KI, MKI, V, VI, MVI, R> context = iterationContext()) {
            if (iterationMainSegmentsAreaOrTierBulk < 0) {
                context.initSegmentIndex(tierIndexMinusOne);
            } else {
                long tierBaseAddr = tierIndexToBaseAddr(tierIndexMinusOne + 1);
                long tierCountersAreaAddr = tierBaseAddr + segmentHashLookupOuterSize;
                context.initSegmentIndex(TierCountersArea.segmentIndex(tierCountersAreaAddr));
                int tier = TierCountersArea.tier(tierCountersAreaAddr);
                long tierIndex = actualSegments + (iterationMainSegmentsAreaOrTierBulk << log2NumberOfTiersInBulk) + tierIndexMinusOne + 1;
                context.initSegmentTier(tier, tierIndex, tierBaseAddr);
            }
            context.updateLock().lock();
            if (changesForUpdatesGet(position)) {
                entryCallback.onBeforeEntry();
                final long segmentPos = position & posMask;
                context.readExistingEntry(segmentPos);
                if (entryCallback.shouldBeIgnored(context, chronicleId)) {
                    changesForUpdatesClear(position);
                    continue;
                }
                context.segmentBytes().limit(context.valueOffset() + context.valueSize());
                context.segmentBytes().position(context.keySizeOffset());
                boolean success = entryCallback.onEntry(context.segmentBytes(), chronicleId, bootStrapTimeStamp());
                entryCallback.onAfterEntry();
                if (success)
                    changesForUpdatesClear(position);
                return success;
            }
        }
    }
}

Output:
         this.position = position;
-        int tierIndexMinusOne = (int) (position >>> segmentIndexShift);
+        int segmentIndexOrTierIndexOffsetWithinBulk = (int) (position >>> segmentIndexShift);
         try (CompiledReplicatedMapIterationContext<K, KI, MKI, V, VI, MVI, R> context = iterationContext()) {


Input:
public static String getMmsOrg(Project project) throws IOException, URISyntaxException, ServerException {
    URIBuilder uriBuilder = getServiceProjectsUri(project);
    JsonParser responseParser = sendMMSRequest(project, buildRequest(HttpRequestType.GET, uriBuilder));
    ObjectNode response = JacksonUtils.parseJsonObject(responseParser);
    JsonNode arrayNode;
    if (((arrayNode = response.get("String_Node_Str")) != null) && arrayNode.isArray()) {
        JsonNode value;
        for (JsonNode projectNode : arrayNode) {
            if (((value = projectNode.get(MDKConstants.ID_KEY)) != null) && value.isTextual() && value.asText().equals(Converters.getIProjectToIdConverter().apply(project.getPrimaryProject())) && ((value = projectNode.get(MDKConstants.ORG_ID_KEY)) != null) && value.isTextual() && !value.asText().isEmpty()) {
                return value.asText();
            }
        }
    }
    return null;
}

Output:
     URIBuilder uriBuilder = getServiceProjectsUri(project);
-    JsonParser responseParser = sendMMSRequest(project, buildRequest(HttpRequestType.GET, uriBuilder));
-    ObjectNode response = JacksonUtils.parseJsonObject(responseParser);
-    JsonNode arrayNode;
-    if (((arrayNode = response.get("String_Node_Str")) != null) && arrayNode.isArray()) {
-        JsonNode value;
-        for (JsonNode projectNode : arrayNode) {
-            if (((value = projectNode.get(MDKConstants.ID_KEY)) != null) && value.isTextual() && value.asText().equals(Converters.getIProjectToIdConverter().apply(project.getPrimaryProject())) && ((value = projectNode.get(MDKConstants.ORG_ID_KEY)) != null) && value.isTextual() && !value.asText().isEmpty()) {
-                return value.asText();
+    File responseFile = sendMMSRequest(project, buildRequest(HttpRequestType.GET, uriBuilder));
+    try (JsonParser responseParser = JacksonUtils.getJsonFactory().createParser(responseFile)) {
+        ObjectNode response = JacksonUtils.parseJsonObject(responseParser);
+        JsonNode arrayNode;
+        if (((arrayNode = response.get("String_Node_Str")) != null) && arrayNode.isArray()) {
+            JsonNode value;
+            for (JsonNode projectNode : arrayNode) {
+                if (((value = projectNode.get(MDKConstants.ID_KEY)) != null) && value.isTextual() && value.asText().equals(Converters.getIProjectToIdConverter().apply(project.getPrimaryProject())) && ((value = projectNode.get(MDKConstants.ORG_ID_KEY)) != null) && value.isTextual() && !value.asText().isEmpty()) {
+                    return value.asText();
+                }
             }


Input:
public float getLAbelWidth() {
    return viewFrustum.getWidth() / 2;
}

Output:
 public float getLAbelWidth() {
-    return viewFrustum.getWidth() / 2;
+    return getRenderWidth() / 2;
 }


Input:
private FieldMetadata createFieldMetadata(XSDElementDeclaration element, ComplexTypeMetadata containingType) {
    String fieldName = element.getName();
    int minOccurs = ((XSDParticle) element.getContainer()).getMinOccurs();
    int maxOccurs = ((XSDParticle) element.getContainer()).getMaxOccurs();
    if (maxOccurs > 0 && minOccurs > maxOccurs) {
        throw new IllegalArgumentException("String_Node_Str" + element.getQName() + "String_Node_Str" + containingType + "String_Node_Str");
    }
    boolean isMany = maxOccurs == -1 || maxOccurs > 1;
    XmlSchemaAnnotationProcessorState state = new XmlSchemaAnnotationProcessorState();
    try {
        XSDAnnotation annotation = element.getAnnotation();
        for (XmlSchemaAnnotationProcessor processor : XML_ANNOTATIONS_PROCESSORS) {
            processor.process(this, containingType, annotation, state);
        }
    } catch (Exception e) {
        throw new RuntimeException("String_Node_Str" + fieldName + "String_Node_Str" + containingType.getName() + "String_Node_Str", e);
    }
    boolean isMandatory = minOccurs > 0;
    boolean isContained = false;
    boolean isReference = state.isReference();
    boolean fkIntegrity = state.isFkIntegrity();
    boolean fkIntegrityOverride = state.isFkIntegrityOverride();
    FieldMetadata foreignKeyInfo = state.getForeignKeyInfo();
    TypeMetadata fieldType = state.getFieldType();
    FieldMetadata referencedField = state.getReferencedField();
    TypeMetadata referencedType = state.getReferencedType();
    List<String> hideUsers = state.getHide();
    List<String> allowWriteUsers = state.getAllowWrite();
    if (foreignKeyInfo != null && fieldType == null) {
        throw new IllegalArgumentException("String_Node_Str" + fieldName + "String_Node_Str" + containingType.getName() + "String_Node_Str");
    }
    XSDTypeDefinition schemaType = element.getType();
    if (schemaType instanceof XSDSimpleTypeDefinition) {
        XSDSimpleTypeDefinition simpleSchemaType = (XSDSimpleTypeDefinition) schemaType;
        XSDSimpleTypeDefinition content = simpleSchemaType.getBaseTypeDefinition();
        if (schemaType.getQName() != null) {
            fieldType = new SoftTypeRef(this, schemaType.getTargetNamespace(), schemaType.getName(), false);
            fieldType.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
            fieldType.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
            fieldType.setData(XSD_DOM_ELEMENT, element.getElement());
        }
        if (isReference) {
            ReferenceFieldMetadata referenceField = new ReferenceFieldMetadata(containingType, false, isMany, isMandatory, fieldName, (ComplexTypeMetadata) referencedType, referencedField, foreignKeyInfo, fkIntegrity, fkIntegrityOverride, fieldType, allowWriteUsers, hideUsers);
            referenceField.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
            referenceField.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
            referenceField.setData(XSD_DOM_ELEMENT, element.getElement());
            return referenceField;
        }
        if (content != null) {
            if (fieldType == null) {
                fieldType = new SoftTypeRef(this, content.getTargetNamespace(), content.getName(), false);
            }
            if (content.getFacets().size() > 0) {
                boolean isEnumeration = false;
                for (int i = 0; i < content.getFacets().size(); i++) {
                    XSDConstrainingFacet item = content.getFacets().get(i);
                    if (item instanceof XSDEnumerationFacet) {
                        isEnumeration = true;
                    }
                }
                if (isEnumeration) {
                    EnumerationFieldMetadata enumField = new EnumerationFieldMetadata(containingType, false, isMany, isMandatory, fieldName, fieldType, allowWriteUsers, hideUsers);
                    enumField.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
                    enumField.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
                    enumField.setData(XSD_DOM_ELEMENT, element.getElement());
                    return enumField;
                } else {
                    FieldMetadata field = new SimpleTypeFieldMetadata(containingType, false, isMany, isMandatory, fieldName, fieldType, allowWriteUsers, hideUsers);
                    field.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
                    field.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
                    field.setData(XSD_DOM_ELEMENT, element.getElement());
                    return field;
                }
            } else {
                FieldMetadata field = new SimpleTypeFieldMetadata(containingType, false, isMany, isMandatory, fieldName, fieldType, allowWriteUsers, hideUsers);
                field.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
                field.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
                field.setData(XSD_DOM_ELEMENT, element.getElement());
                return field;
            }
        }
    }
    if (fieldType == null) {
        String qName = element.getType() == null ? null : element.getType().getQName();
        if (qName != null) {
            TypeMetadata metadata = getType(element.getType().getTargetNamespace(), element.getType().getName());
            if (metadata != null) {
                referencedType = new ContainedComplexTypeRef(currentTypeStack.peek(), targetNamespace, element.getName(), new SoftTypeRef(this, targetNamespace, schemaType.getName(), false));
                isContained = true;
            } else {
                if (schemaType == null) {
                    throw new IllegalArgumentException("String_Node_Str" + fieldName + "String_Node_Str" + containingType.getName() + "String_Node_Str");
                }
                if (schemaType instanceof XSDComplexTypeDefinition) {
                    referencedType = new ContainedComplexTypeRef(currentTypeStack.peek(), targetNamespace, element.getName(), new SoftTypeRef(this, targetNamespace, schemaType.getName(), false));
                    isContained = true;
                } else if (schemaType instanceof XSDSimpleTypeDefinition) {
                    fieldType = new SoftTypeRef(this, schemaType.getTargetNamespace(), schemaType.getName(), false);
                    XmlSchemaWalker.walk(schemaType, this);
                } else {
                    throw new NotImplementedException("String_Node_Str" + schemaType.getClass() + "String_Node_Str");
                }
            }
        } else {
            isContained = true;
            XSDElementDeclaration refName = element.getResolvedElementDeclaration();
            if (schemaType != null) {
                referencedType = new ContainedComplexTypeMetadata(currentTypeStack.peek(), targetNamespace, ANONYMOUS_PREFIX + String.valueOf(anonymousCounter++));
                fieldType = referencedType;
                isContained = true;
                currentTypeStack.push((ComplexTypeMetadata) referencedType);
                XmlSchemaWalker.walk(schemaType, this);
                currentTypeStack.pop();
            } else if (refName != null) {
                SoftTypeRef reference = new SoftTypeRef(this, refName.getTargetNamespace(), refName.getName(), true);
                referencedType = new ContainedComplexTypeRef(currentTypeStack.peek(), targetNamespace, element.getName(), reference);
                fieldType = referencedType;
            } else {
                throw new NotImplementedException();
            }
        }
    }
    if (isContained) {
        ContainedTypeFieldMetadata containedField = new ContainedTypeFieldMetadata(containingType, isMany, isMandatory, fieldName, (ContainedComplexTypeMetadata) referencedType, allowWriteUsers, hideUsers);
        containedField.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
        containedField.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
        containedField.setData(XSD_DOM_ELEMENT, element.getElement());
        return containedField;
    } else {
        FieldMetadata field = new SimpleTypeFieldMetadata(containingType, false, isMany, isMandatory, fieldName, fieldType, allowWriteUsers, hideUsers);
        field.setData(XSD_LINE_NUMBER, XSDParser.getStartLine(element.getElement()));
        field.setData(XSD_COLUMN_NUMBER, XSDParser.getStartColumn(element.getElement()));
        field.setData(XSD_DOM_ELEMENT, element.getElement());
        return field;
    }
}

Output:
             if (fieldType == null) {
-                fieldType = new SoftTypeRef(this, content.getTargetNamespace(), content.getName(), false);
+                fieldType = new SimpleTypeMetadata(content.getTargetNamespace(), content.getName());
+                EList<XSDConstrainingFacet> facets = simpleSchemaType.getFacetContents();
+                for (XSDConstrainingFacet currentFacet : facets) {
+                    if (currentFacet instanceof XSDMaxLengthFacet) {
+                        fieldType.setData(MetadataRepository.DATA_MAX_LENGTH, String.valueOf(((XSDMaxLengthFacet) currentFacet).getValue()));
+                    } else if (LOGGER.isDebugEnabled()) {
+                        LOGGER.debug("String_Node_Str" + fieldName + "String_Node_Str" + currentFacet);
+                    }
+                }
             }


Input:
private void initialize(DataEngineImpl dataEngine, Map appContext) throws DataException {
    int savedCacheOption = getDataSetCacheManager().suspendCache();
    try {
        ResultIterator left = (ResultIterator) this.leftQueryResults.getResultIterator();
        ResultIterator right = (ResultIterator) this.rightQueryResults.getResultIterator();
        getDataSetCacheManager().setCacheOption(savedCacheOption);
        getDataSetCacheManager().setCacheMode(DataSetCacheUtil.getCacheMode(appContext));
        this.left = left;
        this.right = right;
        this.joinType = dataSet.getJoinType();
        this.matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
    } catch (BirtException e) {
        throw DataException.wrap(e);
    }
}

Output:
     int savedCacheOption = getDataSetCacheManager().suspendCache();
-    try {
-        ResultIterator left = (ResultIterator) this.leftQueryResults.getResultIterator();
-        ResultIterator right = (ResultIterator) this.rightQueryResults.getResultIterator();
-        getDataSetCacheManager().setCacheOption(savedCacheOption);
-        getDataSetCacheManager().setCacheMode(DataSetCacheUtil.getCacheMode(appContext));
-        this.left = left;
-        this.right = right;
-        this.joinType = dataSet.getJoinType();
-        this.matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
-    } catch (BirtException e) {
-        throw DataException.wrap(e);
-    }
+    getDataSetCacheManager().setCacheOption(savedCacheOption);
+    getDataSetCacheManager().setCacheMode(DataSetCacheUtil.getCacheMode(appContext));
+    this.joinType = dataSet.getJoinType();
+    this.matcher = new JoinConditionMatcher(left.getOdiResult(), right.getOdiResult(), left.getScope(), right.getScope(), dataSet.getJoinConditions());
 }