Input:
public final String create() {
    SourceWriter sourceWriter = getSourceWriter(logger, context);
    if (sourceWriter != null) {
        writeClassBody(sourceWriter);
        sourceWriter.commit(logger);
    }
    return getQaulifiedName();
}

Output:
     }
-    return getQaulifiedName();
+    return getQualifiedName();
 }


Input:
protected void createHideGroupComposite(Composite chartComposite) {
    GridData gridData;
    Composite toolComp = toolkit.createComposite(chartComposite, SWT.NONE);
    gridData = new GridData(GridData.FILL_HORIZONTAL);
    toolComp.setLayoutData(gridData);
    GridLayout gridLayout = new GridLayout(3, false);
    toolComp.setLayout(gridLayout);
    Label lessText = new Label(toolComp, SWT.NONE);
    lessText.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    final Spinner lessSpin = new Spinner(toolComp, SWT.BORDER);
    lessSpin.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            if (matchRuleChartComp != null) {
                int oldValue = matchRuleChartComp.getTimes();
                String text = lessSpin.getText().trim();
                int times = StringUtils.isEmpty(text) ? 0 : Integer.parseInt(text);
                matchRuleChartComp.setTimes(times);
                matchRuleChartComp.refresh();
                listeners.firePropertyChange(MatchAnalysisConstant.NEED_REFRESH_DATA_SAMPLE_TABLE, oldValue, times);
                matchRows.clear();
            }
        }
    });
    lessSpin.setSelection(2);
    Label lessText2 = new Label(toolComp, SWT.NONE);
    lessText2.setText(DefaultMessagesImpl.getString("String_Node_Str"));
}

Output:
     });
-    lessSpin.setSelection(2);
+    lessSpin.setSelection(PluginConstant.HIDDEN_GROUP_LESS_THAN_DEFAULT);
     Label lessText2 = new Label(toolComp, SWT.NONE);


Input:
private String processSmilies(String message, String contentType) {
    String startPlainTextTag;
    String endPlainTextTag;
    if (contentType.equals(HTML_CONTENT_TYPE)) {
        startPlainTextTag = "String_Node_Str";
        endPlainTextTag = "String_Node_Str";
    } else {
        startPlainTextTag = "String_Node_Str";
        endPlainTextTag = "String_Node_Str";
    }
    ArrayList smiliesList = ImageLoader.getDefaultSmiliesPack();
    String regexp = "String_Node_Str";
    for (int i = 0; i < smiliesList.size(); i++) {
        Smiley smiley = (Smiley) smiliesList.get(i);
        String[] smileyStrings = smiley.getSmileyStrings();
        for (int j = 0; j < smileyStrings.length; j++) {
            regexp += GuiUtils.replaceSpecialRegExpChars(smileyStrings[j]) + "String_Node_Str";
        }
    }
    regexp = regexp.substring(0, regexp.length() - 1);
    Pattern p = Pattern.compile(regexp);
    Matcher m = p.matcher(message);
    StringBuffer msgBuffer = new StringBuffer();
    boolean matchSuccessfull = false;
    while (m.find()) {
        if (!matchSuccessfull)
            matchSuccessfull = true;
        String matchGroup = m.group().trim();
        String replacement = endPlainTextTag + "String_Node_Str" + ImageLoader.getSmiley(matchGroup).getImagePath() + "String_Node_Str" + matchGroup + "String_Node_Str" + startPlainTextTag;
        m.appendReplacement(msgBuffer, GuiUtils.replaceSpecialRegExpChars(replacement));
    }
    m.appendTail(msgBuffer);
    return msgBuffer.toString();
}

Output:
     String endPlainTextTag;
-    if (contentType.equals(HTML_CONTENT_TYPE)) {
+    if (contentType != null && contentType.equals(HTML_CONTENT_TYPE)) {
         startPlainTextTag = "String_Node_Str";


Input:
public void removeRMConstraintListValue(String listName, String valueName) {
    Map<String, List<String>> members = null;
    try {
        readLock.lock();
        members = caveatConfig.get(listName);
        if (members == null) {
        } else {
            try {
                readLock.unlock();
                writeLock.lock();
                members = caveatConfig.get(listName);
                if (members == null) {
                } else {
                    Map<String, List<String>> pivot = PivotUtil.getPivot(members);
                    List<String> existingAuthorities = pivot.get(valueName);
                    if (existingAuthorities != null) {
                        for (String authority : existingAuthorities) {
                            List<String> vals = members.get(authority);
                            vals.remove(valueName);
                        }
                        caveatConfig.put(listName, members);
                    }
                }
                updateOrCreateCaveatConfig(convertToJSONString(caveatConfig));
            } finally {
                readLock.lock();
                writeLock.unlock();
            }
        }
    } finally {
        readLock.unlock();
    }
}

Output:
         members = caveatConfig.get(listName);
-        if (members == null) {
-        } else {
+        if (members != null) {
             try {


Input:
public INDArray subArray(int[] offsets, int[] shape, int[] stride) {
    int n = shape.length;
    if (shape.length < 1)
        return create(Nd4j.createBuffer(shape));
    if (offsets.length != n)
        throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(offsets));
    if (stride.length != n)
        throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(stride));
    if (Shape.contentEquals(shape, Shape.shapeOf(shapeInformation.asNioInt()))) {
        if (ArrayUtil.isZero(offsets)) {
            return this;
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
    int[] dotProductOffsets = offsets;
    int[] dotProductStride = stride;
    int offset = Shape.offset(shapeInfo()) + NDArrayIndex.offset(dotProductStride, dotProductOffsets);
    if (offset >= data().length())
        offset = ArrayUtil.sum(offsets);
    return create(data, Arrays.copyOf(shape, shape.length), stride, offset, ordering());
}

Output:
         throw new IllegalArgumentException("String_Node_Str" + Arrays.toString(stride));
-    if (Shape.contentEquals(shape, Shape.shapeOf(shapeInformation.asNioInt()))) {
+    if (Shape.contentEquals(shape, Shape.shapeOf(shapeInformation))) {
         if (ArrayUtil.isZero(offsets)) {


Input:
public Object[] getChildren(Object o) {
    if (o instanceof IContainer) {
        IResource[] members = null;
        try {
            members = ((IContainer) o).members();
        } catch (CoreException e) {
            return new Object[0];
        }
        ArrayList results = new ArrayList();
        for (int i = 0; i < members.length; i++) {
            if ((members[i].getType() & resourceType) > 0) {
                results.add(members[i]);
            }
        }
        return results.toArray();
    }
    if (o instanceof ArrayList) {
        return ((ArrayList) o).toArray();
    }
    return new Object[0];
}

Output:
         ArrayList results = new ArrayList();
-        for (int i = 0; i < members.length; i++) {
-            if ((members[i].getType() & resourceType) > 0) {
-                results.add(members[i]);
+        for (IResource member : members) {
+            if ((member.getType() & resourceType) > 0) {
+                results.add(member);
             }


Input:
public static ClassInfo getClassInfoWithUnimplementedTestMethods(IFile testTarget, IFile testCase) throws Exception {
    PreferenceLoader pref = new PreferenceLoader();
    ClassInfo classInfo = new ClassInfo();
    List<MethodInfo> unimplementedMethodNames = new ArrayList<MethodInfo>();
    if (pref.isTestMethodGenEnabled) {
        ClassInfo expectedClassInfo = getTestClassInfoFromTargetClass(testTarget);
        List<MethodInfo> expectedMethods = expectedClassInfo.methods;
        ClassInfo actualClassInfo = getMethodNamesAlreadyExists(testCase);
        List<MethodInfo> actualMethods = actualClassInfo.methods;
        for (MethodInfo expected : expectedMethods) {
            boolean exist = false;
            for (MethodInfo actual : actualMethods) {
                String escapedExp = expected.testMethodName.replace(StrConst.testMethodPrefix4Version3, StrConst.empty).replaceAll("String_Node_Str", "String_Node_Str");
                if (actual.testMethodName.matches("String_Node_Str" + escapedExp + "String_Node_Str")) {
                    exist = true;
                    break;
                }
            }
            if (!exist)
                unimplementedMethodNames.add(expected);
        }
        if (pref.isTestMethodGenNotBlankEnabled) {
            List<String> notImportedList = new ArrayList<String>();
            List<String> expImportedList = expectedClassInfo.importList;
            List<String> actImportedList = actualClassInfo.importList;
            for (String expImported : expImportedList) {
                boolean found = false;
                for (String actImported : actImportedList) {
                    if (expImported.equals(actImported)) {
                        found = true;
                        break;
                    }
                }
                if (!found)
                    notImportedList.add(expImported);
                else
                    notImportedList.add("String_Node_Str" + expImported);
            }
            classInfo.importList = notImportedList;
            if (pref.isTestMethodGenEnabledSupportJMock2) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
            if (pref.isTestMethodGenEnabledSupportEasyMock) {
                classInfo.importList.add("String_Node_Str");
                classInfo.importList.add("String_Node_Str");
            }
        }
    }
    classInfo.methods = unimplementedMethodNames;
    return classInfo;
}

Output:
             for (MethodInfo actual : actualMethods) {
-                String escapedExp = expected.testMethodName.replace(StrConst.testMethodPrefix4Version3, StrConst.empty).replaceAll("String_Node_Str", "String_Node_Str");
+                String escapedExp = expected.testMethodName.replace(StrConst.testMethodPrefix4Version3, StrConst.empty).replaceAll("String_Node_Str", "String_Node_Str").replaceAll("String_Node_Str", StrConst.empty);
                 if (actual.testMethodName.matches("String_Node_Str" + escapedExp + "String_Node_Str")) {


Input:
public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
    sSelectRoute.setEnabled(true);
    PopulateStopsTask task = new PopulateStopsTask();
    task.execute();
}

Output:
 public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
-    sSelectRoute.setEnabled(true);
+    sSelectStop.setEnabled(true);
     PopulateStopsTask task = new PopulateStopsTask();


Input:
private void outputCSSStyles(Report reportDesign, ReportDesignHandle designHandle) {
    if (report == null) {
        logger.log(Level.WARNING, "String_Node_Str");
    } else {
        if (!enableInlineStyle) {
            writer.openTag(HTMLTags.TAG_STYLE);
            writer.attribute(HTMLTags.ATTR_TYPE, "String_Node_Str");
            String styleNamePrefix;
            if (null != htmlIDNamespace) {
                styleNamePrefix = "String_Node_Str" + htmlIDNamespace;
            } else {
                styleNamePrefix = "String_Node_Str";
            }
            String defaultStyleName = reportDesign.getRootStyleName();
            Map styles = reportDesign.getStyles();
            Iterator iter = styles.entrySet().iterator();
            while (iter.hasNext()) {
                Map.Entry entry = (Map.Entry) iter.next();
                String styleName = (String) entry.getKey();
                if (styleName != null) {
                    IStyle style = (IStyle) entry.getValue();
                    StringBuffer styleBuffer = new StringBuffer();
                    if (styleName.equals(defaultStyleName)) {
                        htmlEmitter.buildDefaultStyle(styleBuffer, style);
                    } else {
                        htmlEmitter.buildStyle(styleBuffer, style);
                    }
                    if (styleBuffer.length() > 0) {
                        writer.style(styleNamePrefix + styleName, styleBuffer.toString());
                        outputtedStyles.add(styleName);
                    }
                }
            }
            writer.closeTag(HTMLTags.TAG_STYLE);
        }
    }
    hasCsslinks = false;
    if (designHandle != null) {
        List externalCsses = designHandle.getAllExternalIncludedCsses();
        if (null != externalCsses) {
            Iterator iter = externalCsses.iterator();
            while (iter.hasNext()) {
                IncludedCssStyleSheetHandle cssStyleSheetHandle = (IncludedCssStyleSheetHandle) iter.next();
                String href = cssStyleSheetHandle.getExternalCssURI();
                if (href != null) {
                    hasCsslinks = true;
                    writer.openTag(HTMLTags.TAG_LINK);
                    writer.attribute(HTMLTags.ATTR_REL, "String_Node_Str");
                    writer.attribute(HTMLTags.ATTR_TYPE, "String_Node_Str");
                    writer.attribute(HTMLTags.ATTR_HREF, href);
                    writer.closeTag(HTMLTags.TAG_LINK);
                }
            }
        }
    }
}

Output:
         if (!enableInlineStyle) {
-            writer.openTag(HTMLTags.TAG_STYLE);
-            writer.attribute(HTMLTags.ATTR_TYPE, "String_Node_Str");
+            openStyleSheet();
             String styleNamePrefix;


Input:
public void testGetSubCpOptionForMencoder_UTF() throws Exception {
    File file_utf8 = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub1 = new DLNAMediaSubtitle();
    sub1.setExternalFile(file_utf8);
    assertThat(getSubCpOptionForMencoder(sub1)).isNull();
    File file_utf8_2 = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub2 = new DLNAMediaSubtitle();
    sub2.setExternalFile(file_utf8_2);
    assertThat(getSubCpOptionForMencoder(sub2)).isNull();
    File file_utf16_le = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub3 = new DLNAMediaSubtitle();
    sub3.setExternalFile(file_utf16_le);
    assertThat(getSubCpOptionForMencoder(sub3)).isNull();
    File file_utf16_be = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub4 = new DLNAMediaSubtitle();
    sub4.setExternalFile(file_utf16_be);
    assertThat(getSubCpOptionForMencoder(sub4)).isNull();
    File file_utf32_le = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub5 = new DLNAMediaSubtitle();
    sub5.setExternalFile(file_utf32_le);
    assertThat(getSubCpOptionForMencoder(sub5)).isNull();
    File file_utf32_be = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub6 = new DLNAMediaSubtitle();
    sub6.setExternalFile(file_utf32_be);
    assertThat(getSubCpOptionForMencoder(sub6)).isNull();
    File file_utf8_3 = FileUtils.toFile(CLASS.getResource("String_Node_Str"));
    DLNAMediaSubtitle sub7 = new DLNAMediaSubtitle();
    sub7.setExternalFile(file_utf8_3);
    assertThat(getSubCpOptionForMencoder(sub7)).isNull();
}

Output:
     DLNAMediaSubtitle sub1 = new DLNAMediaSubtitle();
-    sub1.setExternalFile(file_utf8);
+    sub1.setExternalFile(file_utf8, null);
     assertThat(getSubCpOptionForMencoder(sub1)).isNull();


Input:
public void callback(Pointer notUsed, final Gtk.GdkEventButton event) {
    if (event.type == 4) {
        libgtk.gtk_menu_popup(menu, null, null, Gtk.gtk_status_icon_position_menu, trayIcon, 0, event.time);
    }
}

Output:
     if (event.type == 4) {
-        libgtk.gtk_menu_popup(menu, null, null, Gtk.gtk_status_icon_position_menu, trayIcon, 0, event.time);
+        gtk.gtk_menu_popup(menu, null, null, Gtk.gtk_status_icon_position_menu, trayIcon, 0, event.time);
     }


Input:
private void setAccountSwitcherVisible(boolean accountSwitcherVisible) {
    if (accountSwitcherVisible == this.accountSwitcherVisible)
        return;
    this.accountSwitcherVisible = accountSwitcherVisible;
    drawer.setAccountsVisible(accountSwitcherVisible);
    accountExpand.setActivated(accountSwitcherVisible);
    if (!accountSwitcherVisible) {
        fixNavigationSelection();
    }
}

Output:
     drawer.setAccountsVisible(accountSwitcherVisible);
-    accountExpand.setActivated(accountSwitcherVisible);
+    if (Build.VERSION.SDK_INT >= 11)
+        accountExpand.setActivated(accountSwitcherVisible);
     if (!accountSwitcherVisible) {


Input:
public static boolean isUndead(Entity entity) {
    if (entity == null)
        return false;
    if (entity.getType() == EntityType.ZOMBIE || entity.getType() == EntityType.BLAZE || entity.getType() == EntityType.GIANT || entity.getType() == EntityType.IRON_GOLEM || entity.getType() == EntityType.MAGMA_CUBE || entity.getType() == EntityType.PIG_ZOMBIE || entity.getType() == EntityType.SKELETON || entity.getType() == EntityType.SLIME || entity.getType() == EntityType.SNOWMAN || entity.getType() == EntityType.ZOMBIE) {
        return true;
    }
    return false;
}

Output:
 public static boolean isUndead(Entity entity) {
-    if (entity == null)
-        return false;
-    if (entity.getType() == EntityType.ZOMBIE || entity.getType() == EntityType.BLAZE || entity.getType() == EntityType.GIANT || entity.getType() == EntityType.IRON_GOLEM || entity.getType() == EntityType.MAGMA_CUBE || entity.getType() == EntityType.PIG_ZOMBIE || entity.getType() == EntityType.SKELETON || entity.getType() == EntityType.SLIME || entity.getType() == EntityType.SNOWMAN || entity.getType() == EntityType.ZOMBIE) {
-        return true;
-    }
-    return false;
+    return entity != null && (entity.getType() == EntityType.ZOMBIE || entity.getType() == EntityType.BLAZE || entity.getType() == EntityType.GIANT || entity.getType() == EntityType.IRON_GOLEM || entity.getType() == EntityType.MAGMA_CUBE || entity.getType() == EntityType.PIG_ZOMBIE || entity.getType() == EntityType.SKELETON || entity.getType() == EntityType.SLIME || entity.getType() == EntityType.SNOWMAN || entity.getType() == EntityType.ZOMBIE);
 }


Input:
public AjBuildConfig genBuildConfig(String[] args, IMessageHandler handler) {
    AjBuildConfig buildConfig = new AjBuildConfig();
    try {
        super.filenames = new String[] { "String_Node_Str" };
        List fileList = new ArrayList();
        AjcConfigParser parser = new AjcConfigParser(buildConfig, handler);
        parser.parseCommandLine(args);
        boolean incrementalMode = buildConfig.isIncrementalMode() || buildConfig.isIncrementalFileMode();
        List files = parser.getFiles();
        if (!LangUtil.isEmpty(files)) {
            if (incrementalMode) {
                MessageUtil.error(handler, "String_Node_Str");
            } else {
                fileList.addAll(files);
            }
        }
        List javaArgList = new ArrayList();
        javaArgList.add("String_Node_Str");
        javaArgList.add("String_Node_Str");
        javaArgList.add(System.getProperty("String_Node_Str"));
        javaArgList.add("String_Node_Str");
        javaArgList.add(System.getProperty("String_Node_Str"));
        javaArgList.addAll(parser.getUnparsedArgs());
        super.configure((String[]) javaArgList.toArray(new String[javaArgList.size()]));
        if (buildConfig.getSourceRoots() != null) {
            for (Iterator i = buildConfig.getSourceRoots().iterator(); i.hasNext(); ) {
                fileList.addAll(collectSourceRootFiles((File) i.next()));
            }
        }
        buildConfig.setFiles(fileList);
        if (destinationPath != null) {
            buildConfig.setOutputDir(new File(destinationPath));
        }
        buildConfig.setClasspath(getClasspath(parser));
        if (incrementalMode && (0 == buildConfig.getSourceRoots().size())) {
            MessageUtil.error(handler, "String_Node_Str");
        }
        setDebugOptions();
        buildConfig.setJavaOptions(options);
    } catch (InvalidInputException iie) {
        MessageUtil.error(handler, iie.getMessage());
    }
    return buildConfig;
}

Output:
         }
-        buildConfig.setClasspath(getClasspath(parser));
+        if (setClasspath) {
+            buildConfig.setClasspath(getClasspath(parser));
+        }
         if (incrementalMode && (0 == buildConfig.getSourceRoots().size())) {


Input:
public void run() {
    String path = dialog.open();
    if (path == null) {
        return;
    }
    Serializer serializer = null;
    final File chartFile = new File(path);
    try {
        serializer = SerializerImpl.instance();
        if (chartFile.exists()) {
            chart = serializer.read(new FileInputStream(chartFile));
            chartView.getChartViewer().setBuffer(null);
            chartView.setChart(chart);
        }
    } catch (Exception e) {
        WizardBase.displayException(e);
    }
}

Output:
     }
-    Serializer serializer = null;
-    final File chartFile = new File(path);
+    File chartFile = new File(path);
     try {


Input:
public void onCommandFailure(final Throwable caught) {
    N10N.error(I18N.CONSTANTS.adminProjectModelUpdateBox(), I18N.MESSAGES.adminStandardCreationFailure(I18N.CONSTANTS.adminProjectModelStandard() + "String_Node_Str" + name + "String_Node_Str"));
    callback.onFailure(caught);
}

Output:
 public void onCommandFailure(final Throwable caught) {
-    N10N.error(I18N.CONSTANTS.adminProjectModelUpdateBox(), I18N.MESSAGES.adminStandardCreationFailure(I18N.CONSTANTS.adminProjectModelStandard() + "String_Node_Str" + name + "String_Node_Str"));
+    N10N.error(I18N.CONSTANTS.adminProjectModelUpdateBox(), I18N.MESSAGES.adminStandardCreationFailure(I18N.CONSTANTS.adminProjectModelStandard() + "String_Node_Str" + name + "String_Node_Str" + caught.getMessage()));
     callback.onFailure(caught);


Input:
private void initializeFormatPreferences() {
    setEncodingPreference(SdpConstants.H263, 1000);
    setEncodingPreference(SdpConstants.JPEG, 950);
    setEncodingPreference(SdpConstants.H261, 800);
    setEncodingPreference(SdpConstants.GSM, 500);
    setEncodingPreference(SdpConstants.PCMU, 450);
    setEncodingPreference(SdpConstants.DVI4_8000, 400);
    setEncodingPreference(SdpConstants.DVI4_16000, 350);
    setEncodingPreference(SdpConstants.PCMA, 300);
    setEncodingPreference(SdpConstants.G723, 250);
    setEncodingPreference(SdpConstants.G728, 200);
    ConfigurationService confService = MediaActivator.getConfigurationService();
    List sdpPreferences = confService.getPropertyNamesByPrefix(PROP_SDP_PREFERENCE, false);
    Iterator sdpPreferencesIter = sdpPreferences.iterator();
    while (sdpPreferencesIter.hasNext()) {
        String pName = (String) sdpPreferencesIter.next();
        String prefStr = confService.getString(pName);
        String fmtName = pName.substring(pName.lastIndexOf('.'));
        int preference = -1;
        int fmt = -1;
        try {
            preference = Integer.parseInt(prefStr);
            fmt = Integer.parseInt(fmtName);
        } catch (NumberFormatException exc) {
            logger.warn("String_Node_Str" + fmtName + "String_Node_Str" + prefStr + "String_Node_Str", exc);
            continue;
        }
        setEncodingPreference(fmt, preference);
        sortEncodingsArray(this.supportedAudioEncodings);
        sortEncodingsArray(this.supportedVideoEncodings);
    }
}

Output:
     setEncodingPreference(SdpConstants.H261, 800);
-    setEncodingPreference(SdpConstants.GSM, 500);
-    setEncodingPreference(SdpConstants.PCMU, 450);
-    setEncodingPreference(SdpConstants.DVI4_8000, 400);
-    setEncodingPreference(SdpConstants.DVI4_16000, 350);
-    setEncodingPreference(SdpConstants.PCMA, 300);
-    setEncodingPreference(SdpConstants.G723, 250);
-    setEncodingPreference(SdpConstants.G728, 200);
+    setEncodingPreference(97, 500);
+    setEncodingPreference(SdpConstants.GSM, 450);
+    setEncodingPreference(SdpConstants.PCMU, 400);
+    setEncodingPreference(110, 350);
+    setEncodingPreference(SdpConstants.DVI4_8000, 300);
+    setEncodingPreference(SdpConstants.DVI4_16000, 250);
+    setEncodingPreference(SdpConstants.PCMA, 200);
+    setEncodingPreference(SdpConstants.G723, 150);
+    setEncodingPreference(SdpConstants.G728, 100);
     ConfigurationService confService = MediaActivator.getConfigurationService();


Input:
public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags, int userId) {
    final int callingUid = Binder.getCallingUid();
    userId = handleIncomingUser(Binder.getCallingPid(), callingUid, userId, false, ALLOW_FULL_ONLY, "String_Node_Str", null);
    final boolean includeProfiles = (flags & ActivityManager.RECENT_INCLUDE_PROFILES) != 0;
    final boolean withExcluded = (flags & ActivityManager.RECENT_WITH_EXCLUDED) != 0;
    synchronized (this) {
        final boolean allowed = checkCallingPermission(android.Manifest.permission.GET_TASKS) == PackageManager.PERMISSION_GRANTED;
        if (!allowed) {
            Slog.w(TAG, "String_Node_Str" + callingUid + "String_Node_Str");
        }
        final boolean detailed = checkCallingPermission(android.Manifest.permission.GET_DETAILED_TASKS) == PackageManager.PERMISSION_GRANTED;
        IPackageManager pm = AppGlobals.getPackageManager();
        final int N = mRecentTasks.size();
        ArrayList<ActivityManager.RecentTaskInfo> res = new ArrayList<ActivityManager.RecentTaskInfo>(maxNum < N ? maxNum : N);
        final Set<Integer> includedUsers;
        if (includeProfiles) {
            includedUsers = getProfileIdsLocked(userId);
        } else {
            includedUsers = new HashSet<Integer>();
        }
        includedUsers.add(Integer.valueOf(userId));
        for (int i = 0; i < N; ) {
            TaskRecord task = mRecentTasks.remove(i);
            if (mTmpRecents.contains(task)) {
                continue;
            }
            int affiliatedTaskId = task.mAffiliatedTaskId;
            while (true) {
                TaskRecord next = task.mNextAffiliate;
                if (next == null) {
                    break;
                }
                if (next.mAffiliatedTaskId != affiliatedTaskId) {
                    Slog.e(TAG, "String_Node_Str" + next.mAffiliatedTaskId + "String_Node_Str" + affiliatedTaskId);
                    task.setNextAffiliate(null);
                    if (next.mPrevAffiliate == task) {
                        next.setPrevAffiliate(null);
                    }
                    break;
                }
                if (next.mPrevAffiliate != task) {
                    Slog.e(TAG, "String_Node_Str" + next.mPrevAffiliate + "String_Node_Str" + task);
                    next.setPrevAffiliate(null);
                    break;
                }
                if (!mRecentTasks.contains(next)) {
                    Slog.e(TAG, "String_Node_Str" + next + "String_Node_Str");
                    task.setNextAffiliate(null);
                    if (next.mPrevAffiliate == task) {
                        next.setPrevAffiliate(null);
                    }
                    break;
                }
                task = next;
            }
            do {
                mRecentTasks.remove(task);
                mRecentTasks.add(i++, task);
                mTmpRecents.add(task);
            } while ((task = task.mPrevAffiliate) != null);
        }
        mTmpRecents.clear();
        for (int i = 0; i < N && maxNum > 0; i++) {
            TaskRecord tr = mRecentTasks.get(i);
            if (!includedUsers.contains(Integer.valueOf(tr.userId))) {
                if (DEBUG_RECENTS)
                    Slog.d(TAG, "String_Node_Str" + tr);
                continue;
            }
            if (i == 0 || withExcluded || (tr.intent == null) || ((tr.intent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0)) {
                if (!allowed) {
                    if (!tr.isHomeTask() && tr.creatorUid != callingUid) {
                        if (DEBUG_RECENTS)
                            Slog.d(TAG, "String_Node_Str" + tr);
                        continue;
                    }
                }
                if (tr.autoRemoveRecents && tr.getTopActivity() == null) {
                    if (DEBUG_RECENTS)
                        Slog.d(TAG, "String_Node_Str" + tr);
                    continue;
                }
                ActivityManager.RecentTaskInfo rti = createRecentTaskInfoFromTaskRecord(tr);
                if (!detailed) {
                    rti.baseIntent.replaceExtras((Bundle) null);
                }
                if ((flags & ActivityManager.RECENT_IGNORE_UNAVAILABLE) != 0) {
                    try {
                        if (rti.origActivity != null) {
                            if (pm.getActivityInfo(rti.origActivity, 0, userId) == null) {
                                if (DEBUG_RECENTS)
                                    Slog.d(TAG, "String_Node_Str" + tr);
                                continue;
                            }
                        } else if (rti.baseIntent != null) {
                            if (pm.queryIntentActivities(rti.baseIntent, null, 0, userId) == null) {
                                if (DEBUG_RECENTS)
                                    Slog.d(TAG, "String_Node_Str" + tr);
                                continue;
                            }
                        }
                    } catch (RemoteException e) {
                    }
                }
                res.add(rti);
                maxNum--;
            }
        }
        return res;
    }
}

Output:
                 if (!allowed) {
-                    if (!tr.isHomeTask() && tr.creatorUid != callingUid) {
+                    if (!tr.isHomeTask() && tr.effectiveUid != callingUid) {
                         if (DEBUG_RECENTS)


Input:
private String buildQuery(String tenantId, String name, Map<String, String> dimensions, DateTime startTime, DateTime endTime, List<String> statistics, int period, String offset, int limit, Boolean mergeMetricsFlag) throws Exception {
    String q;
    if (Boolean.TRUE.equals(mergeMetricsFlag)) {
        q = String.format("String_Node_Str" + "String_Node_Str", funcPart(statistics), this.influxV9Utils.namePart(name, true), this.influxV9Utils.tenantIdPart(tenantId), this.influxV9Utils.regionPart(this.region), this.influxV9Utils.startTimePart(startTime), this.influxV9Utils.dimPart(dimensions), this.influxV9Utils.endTimePart(endTime), this.influxV9Utils.timeOffsetPart(offset), this.influxV9Utils.periodPart(period), this.influxV9Utils.limitPart(limit));
    } else {
        if (!this.influxV9MetricDefinitionRepo.isAtMostOneSeries(tenantId, name, dimensions)) {
            throw new IllegalArgumentException(this.influxV9Utils.getMultipleMetricsErrorMsg());
        }
        q = String.format("String_Node_Str" + "String_Node_Str", funcPart(statistics), this.influxV9Utils.namePart(name, true), this.influxV9Utils.tenantIdPart(tenantId), this.influxV9Utils.regionPart(this.region), this.influxV9Utils.startTimePart(startTime), this.influxV9Utils.dimPart(dimensions), this.influxV9Utils.endTimePart(endTime), this.influxV9Utils.timeOffsetPart(offset), this.influxV9Utils.periodPartWithGroupBy(period), this.influxV9Utils.limitPart(limit));
    }
    logger.debug("String_Node_Str", q);
    return q;
}

Output:
     if (Boolean.TRUE.equals(mergeMetricsFlag)) {
-        q = String.format("String_Node_Str" + "String_Node_Str", funcPart(statistics), this.influxV9Utils.namePart(name, true), this.influxV9Utils.tenantIdPart(tenantId), this.influxV9Utils.regionPart(this.region), this.influxV9Utils.startTimePart(startTime), this.influxV9Utils.dimPart(dimensions), this.influxV9Utils.endTimePart(endTime), this.influxV9Utils.timeOffsetPart(offset), this.influxV9Utils.periodPart(period), this.influxV9Utils.limitPart(limit));
+        q = String.format("String_Node_Str" + "String_Node_Str", funcPart(statistics), this.influxV9Utils.namePart(name, true), this.influxV9Utils.privateTenantIdPart(tenantId), this.influxV9Utils.privateRegionPart(this.region), this.influxV9Utils.startTimePart(startTime), this.influxV9Utils.dimPart(dimensions), this.influxV9Utils.endTimePart(endTime), this.influxV9Utils.timeOffsetPart(offset), this.influxV9Utils.periodPart(period), this.influxV9Utils.limitPart(limit));
     } else {


Input:
private boolean addImportIfRequired(Schema sourceSchema, Schema importSchema, String importNamespace) {
    if (importSchema != sourceSchema) {
        String schemaName = null;
        if (importSchema != null) {
            schemaName = importSchema.getName();
        } else if (importNamespace != null) {
            NamespaceInfo nInfo = getNamespaceInfoForNamespace(importNamespace);
            schemaName = nInfo.getLocation();
        }
        if (schemaName != null && !importExists(sourceSchema, schemaName)) {
            Import schemaImport = new Import();
            schemaImport.setSchemaLocation(schemaName);
            schemaImport.setNamespace(importNamespace);
            sourceSchema.getImports().add(schemaImport);
            if (schemaImport.getNamespace() != null) {
                String prefix = sourceSchema.getNamespaceResolver().resolveNamespaceURI(importNamespace);
                if (prefix == null && !importNamespace.equals("String_Node_Str")) {
                    sourceSchema.getNamespaceResolver().put(sourceSchema.getNamespaceResolver().generatePrefix(), importNamespace);
                }
            }
            return true;
        }
    }
    return false;
}

Output:
             schemaImport.setSchemaLocation(schemaName);
-            schemaImport.setNamespace(importNamespace);
+            if (importNamespace != null && !importNamespace.equals("String_Node_Str")) {
+                schemaImport.setNamespace(importNamespace);
+            }
             sourceSchema.getImports().add(schemaImport);


Input:
void renderHorizontalAxisByType(ComputationContext context, double dXEnd, double dZEnd, double dZ, double dStaggeredLabelOffset) throws ChartException {
    final int iDirection = sc.getDirection() == IConstants.BACKWARD ? -1 : 1;
    IAxisTypeComputation computation = createAxisTypeComputation(context);
    computation.initialize();
    final double dOffset = computation instanceof TextAxisTypeComputation && bTickBetweenCategories ? iDirection * sc.getUnitSize() / 2 : 0;
    final int length = computation instanceof TextAxisTypeComputation ? da.size() - 1 : da.size();
    double y = (iLabelLocation == IConstants.ABOVE) ? (bRendering3D ? context.dTick1 + 1 : context.dTick1 - 1) : (bRendering3D ? context.dTick2 - 1 : context.dTick2 + 1);
    int xLast = Integer.MIN_VALUE;
    Location loMinorStart = LocationImpl.create(0, 0);
    Location loMinorEnd = LocationImpl.create(0, 0);
    for (int i = 0; i < length; i++) {
        computation.handlePreEachTick(i);
        int x = (int) da.getCoordinate(i);
        boolean bSkipTickLine = (x == xLast);
        if (!bSkipTickLine) {
            xLast = x;
        }
        if (bRendering3D) {
            context.x3d = (int) da3D.getCoordinate(i);
            context.z3d = (int) da3D.getCoordinate(i);
        }
        if ((iWhatToDraw & IConstants.AXIS) == IConstants.AXIS) {
            double dYMinorTick1 = ((iMinorTickStyle & IConstants.TICK_ABOVE) == IConstants.TICK_ABOVE) ? (bRendering3D ? context.dY + pwa.getTickSize() : context.dY - pwa.getTickSize()) : context.dY;
            double dYMinorTick2 = ((iMinorTickStyle & IConstants.TICK_BELOW) == IConstants.TICK_BELOW) ? (bRendering3D ? context.dY - pwa.getTickSize() : context.dY + pwa.getTickSize()) : context.dY;
            if (dYMinorTick1 != -dYMinorTick2) {
                if (i != da.size() - 1) {
                    if (bRenderBase3DAxis) {
                    } else if (bRenderAncillary3DAxis) {
                    } else {
                        if (!bSkipTickLine) {
                            LineRenderEvent lreMinor = null;
                            int minorStep = (int) (1d / da.getStep());
                            if (minorStep < 1) {
                                minorStep = 1;
                            }
                            for (int k = 0; k < daMinor.length - 1; k += minorStep) {
                                if (computation instanceof LinearAxisTypeComputation) {
                                    if ((iDirection == 1 && x + daMinor[k] >= da.getCoordinate(i + 1)) || (iDirection == -1 && x - daMinor[k] <= da.getCoordinate(i + 1))) {
                                        continue;
                                    }
                                }
                                lreMinor = ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), LineRenderEvent.class);
                                lreMinor.setLineAttributes(liaMinorTick);
                                loMinorStart.set(x + iDirection * daMinor[k], dYMinorTick1);
                                lreMinor.setStart(loMinorStart);
                                loMinorEnd.set(x + iDirection * daMinor[k], dYMinorTick2);
                                lreMinor.setEnd(loMinorEnd);
                                ipr.drawLine(lreMinor);
                            }
                        }
                    }
                }
            }
            if (computation instanceof TextAxisTypeComputation && !bTickBetweenCategories && i == 0) {
                continue;
            }
            if (!bSkipTickLine && context.dTick1 != context.dTick2) {
                if (bRenderBase3DAxis) {
                } else if (bRenderAncillary3DAxis) {
                } else {
                    lre.setLineAttributes(liaMajorTick);
                    lre.getStart().set(x, context.dTick1);
                    lre.getEnd().set(x, context.dTick2);
                    ipr.drawLine(lre);
                }
                if (iv != null && iDimension == IConstants.TWO_5_D && iv.getType() == IConstants.VALUE) {
                    lre.getStart().set(x, context.dY);
                    lre.getEnd().set(x + dSeriesThickness, context.dY - dSeriesThickness);
                    ipr.drawLine(lre);
                }
            }
        }
        if (bRenderAxisLabels && sc.isTickLabelVisible(i)) {
            ScriptHandler.callFunction(sh, ScriptHandler.BEFORE_DRAW_AXIS_LABEL, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.BEFORE_DRAW_AXIS_LABEL, la);
            double sy = y;
            if (bAxisLabelStaggered && sc.isTickLabelStaggered(i)) {
                if (iLabelLocation == IConstants.ABOVE) {
                    sy -= dStaggeredLabelOffset;
                } else {
                    sy += dStaggeredLabelOffset;
                }
            }
            if (ax.getLabel().isVisible() && la.isVisible()) {
                if (bRendering3D) {
                    if (axisType == IConstants.BASE_AXIS) {
                        lo3d.set(context.x3d + dOffset, sy - pwa.getVerticalSpacingInPixels(), dZEnd + pwa.getVerticalSpacingInPixels());
                    } else {
                        lo3d.set(dXEnd + pwa.getVerticalSpacingInPixels(), sy - pwa.getVerticalSpacingInPixels(), context.z3d + dOffset);
                    }
                    t3dre.setLocation3D(lo3d);
                    t3dre.setAction(TextRenderEvent.RENDER_TEXT_AT_LOCATION);
                    if (this.renderer.rtc.isRightToLeftText()) {
                        t3dre.setRtlCaption();
                    }
                    dc.addLabel(t3dre);
                } else {
                    lo.set(x + dOffset, sy);
                    tre.setAction(TextRenderEvent.RENDER_TEXT_AT_LOCATION);
                    if (bLabelWithinAxes) {
                        if (i == 0) {
                            tre.setTextPosition(iLabelLocation | IConstants.POSITION_MOVE_RIGHT);
                        } else {
                            tre.setTextPosition(iLabelLocation);
                        }
                    }
                    if (this.renderer.rtc.isRightToLeftText()) {
                        tre.setRtlCaption();
                    }
                    ipr.drawText(tre);
                }
            }
            ScriptHandler.callFunction(sh, ScriptHandler.AFTER_DRAW_AXIS_LABEL, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.AFTER_DRAW_AXIS_LABEL, la);
        }
        computation.handlePostEachTick(i);
    }
    computation.close();
}

Output:
                     } else {
-                        if (!bSkipTickLine) {
+                        if (!bSkipTickLine && ((i > 0 && i < length - 1) || !axModel.isCategoryAxis() || bTickBetweenCategories)) {
                             LineRenderEvent lreMinor = null;


Input:
private static List<Sql> createIndexs(Dao dao, Entity<?> en, Set<String> indexsHis, Object t) {
    List<Sql> sqls = new ArrayList<Sql>();
    StringBuilder sb = new StringBuilder();
    List<EntityIndex> indexs = en.getIndexes();
    for (EntityIndex index : indexs) {
        if (indexsHis.contains(index.getName())) {
            continue;
        }
        sb.setLength(0);
        if (index.isUnique())
            sb.append("String_Node_Str");
        else
            sb.append("String_Node_Str");
        if (index.getName().contains("String_Node_Str")) {
            final String name = index.getName();
            final Molecule<String> m = new Molecule<String>() {
                public void run() {
                    setObj(TableName.render(new CharSegment(name)));
                }
            };
            TableName.run(t, m);
            sb.append(m.getObj());
        } else
            sb.append(index.getName());
        sb.append("String_Node_Str").append(getTableName(dao, en, t)).append("String_Node_Str");
        for (EntityField field : index.getFields()) {
            if (field instanceof MappingField) {
                MappingField mf = (MappingField) field;
                sb.append(mf.getColumnName()).append(',');
            } else {
                throw Lang.makeThrow(DaoException.class, "String_Node_Str", en.getClass(), field.getName());
            }
        }
        sb.setCharAt(sb.length() - 1, ')');
        sqls.add(Sqls.create(sb.toString()));
    }
    return sqls;
}

Output:
     for (EntityIndex index : indexs) {
-        if (indexsHis.contains(index.getName())) {
-            continue;
-        }
-        sb.setLength(0);
-        if (index.isUnique())
-            sb.append("String_Node_Str");
-        else
-            sb.append("String_Node_Str");
-        if (index.getName().contains("String_Node_Str")) {
+        String indexName = index.getName();
+        if (indexName.contains("String_Node_Str")) {
             final String name = index.getName();


Input:
private void execChefClient(String specFilePath) {
    CommandLine cmdLine = new CommandLine(sudoCmd).addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str" + specFilePath + "String_Node_Str");
    execCommand(cmdLine);
}

Output:
 private void execChefClient(String specFilePath) {
-    CommandLine cmdLine = new CommandLine(sudoCmd).addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str" + specFilePath + "String_Node_Str");
+    CommandLine cmdLine = new CommandLine(sudoCmd).addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str" + specFilePath + "String_Node_Str").addArgument("String_Node_Str").addArgument("String_Node_Str");
     execCommand(cmdLine);


Input:
public void process(Document document) {
    Element depElement = PomHelper.findDependency(document, dependency);
    if (depElement != null) {
        Element exclusionsElement = getChild(depElement, EXCLUSIONS);
        Element exclusionElement = createElement(exclusionsElement, EXCLUSION);
        createElementWithText(exclusionElement, ARTIFACT_ID, exclusion.getArtifactId());
        createElementWithText(exclusionElement, GROUP_ID, exclusion.getGroupId());
        format(exclusionElement);
    }
}

Output:
         Element exclusionsElement = getChild(depElement, EXCLUSIONS);
-        Element exclusionElement = createElement(exclusionsElement, EXCLUSION);
-        createElementWithText(exclusionElement, ARTIFACT_ID, exclusion.getArtifactId());
-        createElementWithText(exclusionElement, GROUP_ID, exclusion.getGroupId());
-        format(exclusionElement);
+        if (null == PomEdits.findChild(exclusionsElement, EXCLUSION, childEquals(GROUP_ID, exclusion.getGroupId()), childEquals(ARTIFACT_ID, exclusion.getArtifactId()))) {
+            Element exclusionElement = createElement(exclusionsElement, EXCLUSION);
+            createElementWithText(exclusionElement, ARTIFACT_ID, exclusion.getArtifactId());
+            createElementWithText(exclusionElement, GROUP_ID, exclusion.getGroupId());
+            format(exclusionElement);
+        }
+    } else {
+        log.debug("String_Node_Str" + dependency + "String_Node_Str" + exclusion.toString());
     }


Input:
protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse msg) throws Exception {
    ((Promise<String>) ((EtcdVersionRequest) req).getPromise()).setSuccess(msg.content().toString(Charset.defaultCharset()));
}

Output:
 protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse msg) throws Exception {
-    ((Promise<String>) ((EtcdVersionRequest) req).getPromise()).setSuccess(msg.content().toString(Charset.defaultCharset()));
+    (((EtcdVersionRequest) req).getPromise()).getNettyPromise().setSuccess(msg.content().toString(Charset.defaultCharset()));
 }


Input:
public Range execute(Document document) {
    TreeUpdateElement op = getOperation();
    String newNodeName = op.getValue();
    Node node = getTargetNode(document);
    Range caret = document.createRange();
    caret.setStart(node, op.getPosition());
    if (shouldUpdate(node.getNodeName(), newNodeName)) {
        Node newNode = document.createElement(newNodeName);
        for (int i = 0; i < node.getChildCount(); i++) {
            newNode.appendChild(node.getChild(i));
        }
        if (node.getParentElement() != null) {
            node.getParentElement().replaceChild(newNode, node);
        }
        caret.setStart(newNode, op.getPosition());
    }
    caret.collapse(true);
    return caret;
}

Output:
         }
-        caret.setStart(newNode, op.getPosition());
+        caret.setStart(newNode, 0);
     }


Input:
public boolean unregisterListeners(Plugin plugin) {
    boolean toRet = false;
    for (List<RegisteredChannelListener> list : listeners.values()) {
        for (RegisteredChannelListener listener : list) {
            if (listener.getPlugin().equals(plugin)) {
                list.remove(listener);
                toRet = true;
            }
        }
    }
    return toRet;
}

Output:
     for (List<RegisteredChannelListener> list : listeners.values()) {
-        for (RegisteredChannelListener listener : list) {
-            if (listener.getPlugin().equals(plugin)) {
-                list.remove(listener);
-                toRet = true;
+        synchronized (list) {
+            for (RegisteredChannelListener listener : list) {
+                if (listener.getPlugin().equals(plugin)) {
+                    list.remove(listener);
+                    toRet = true;
+                }
             }


Input:
public void addObjectRisky(RpslObject rpslObject, Result result, int pass) {
    addObject(rpslObject, result, pass);
}

Output:
 public void addObjectRisky(RpslObject rpslObject, Result result, int pass) {
-    addObject(rpslObject, result, pass);
+    try {
+        addObject(rpslObject, result, pass);
+    } catch (Exception e) {
+        StringWriter stringWriter = new StringWriter();
+        e.printStackTrace(new PrintWriter(stringWriter));
+        result.addFail(String.format("String_Node_Str", pass, rpslObject.getFormattedKey(), stringWriter), pass);
+    }
 }


Input:
public int getHighlightedEdgeId() {
    final E e = graph.edgeRef();
    final E h = highlight.getHighlightedEdge(e);
    final int id = (h == null) ? -1 : idmap.getEdgeId(e);
    graph.releaseRef(e);
    return id;
}

Output:
     final E h = highlight.getHighlightedEdge(e);
-    final int id = (h == null) ? -1 : idmap.getEdgeId(e);
+    final int id = (h == null) ? -1 : idmap.getEdgeId(h);
     graph.releaseRef(e);


Input:
private void synchronize(double height) {
    XlsContainer rowContainer = getCurrentContainer();
    ContainerSizeInfo rowSizeInfo = rowContainer.getSizeInfo();
    int startCoordinate = rowSizeInfo.getStartCoordinate();
    int endCoordinate = rowSizeInfo.getEndCoordinate();
    int startColumnIndex = axis.getColumnIndexByCoordinate(startCoordinate);
    int endColumnIndex = axis.getColumnIndexByCoordinate(endCoordinate);
    int maxRowIndex = 0;
    int[] rowIndexes = new int[endColumnIndex - startColumnIndex];
    for (int currentColumnIndex = startColumnIndex; currentColumnIndex < endColumnIndex; currentColumnIndex++) {
        int rowIndex = cache.getMaxRowIndex(currentColumnIndex);
        rowIndexes[currentColumnIndex - startColumnIndex] = rowIndex;
        maxRowIndex = maxRowIndex > rowIndex ? maxRowIndex : rowIndex;
    }
    int startRowIndex = rowContainer.getRowIndex();
    if (maxRowIndex == startRowIndex) {
        maxRowIndex++;
    }
    rowContainer.setRowIndex(maxRowIndex);
    double resize = height / (maxRowIndex - startRowIndex);
    for (int i = startRowIndex + 1; i <= maxRowIndex; i++) {
        cache.setRowHeight(i, resize);
    }
    for (int currentColumnIndex = startColumnIndex; currentColumnIndex < endColumnIndex; currentColumnIndex++) {
        int rowspan = maxRowIndex - rowIndexes[currentColumnIndex - startColumnIndex];
        if (rowspan > 0) {
            SheetData upstair = cache.getColumnLastData(currentColumnIndex);
            if (upstair != null && canSpan(upstair, rowContainer)) {
                SheetData predata = upstair;
                int rs = predata.getRowSpan() + rowspan;
                predata.setRowSpan(rs);
                SheetData realData = getRealData(predata);
                BlankData blankData = new BlankData(realData);
                if (!isInContainer(predata, rowContainer)) {
                    blankData.decreasRowSpanInDesign();
                }
                int rowIndex = predata.getRowIndex();
                for (int p = 1; p <= rowspan; p++) {
                    BlankData blank = new BlankData(predata);
                    blank.setRowIndex(rowIndex + p);
                    cache.addData(currentColumnIndex, blank);
                }
            }
        }
    }
}

Output:
             if (upstair != null && canSpan(upstair, rowContainer)) {
-                SheetData predata = upstair;
-                int rs = predata.getRowSpan() + rowspan;
-                predata.setRowSpan(rs);
-                SheetData realData = getRealData(predata);
-                BlankData blankData = new BlankData(realData);
-                if (!isInContainer(predata, rowContainer)) {
-                    blankData.decreasRowSpanInDesign();
+                upstair.setRowSpan(rowspan);
+                SheetData realData = getRealData(upstair);
+                if (!isInContainer(upstair, rowContainer)) {
+                    realData.decreasRowSpanInDesign();
                 }


Input:
private Bitmap getProfileBadge() {
    UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
    Drawable badge = userManager.getBadgeForUser(new UserHandle(mOriginatingUserId), 0);
    if (badge == null) {
        return null;
    }
    final int width = badge.getIntrinsicWidth();
    final int height = badge.getIntrinsicHeight();
    Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    badge.setBounds(0, 0, width, height);
    badge.draw(canvas);
    return bitmap;
}

Output:
 private Bitmap getProfileBadge() {
-    UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
-    Drawable badge = userManager.getBadgeForUser(new UserHandle(mOriginatingUserId), 0);
+    Drawable badge = getProfileBadgeDrawable();
     if (badge == null) {


Input:
private void assignWhite(HTTPDownloader dloader) throws IOException, TryAgainLaterException, FileNotFoundException, NotSharingException {
    Interval interval = null;
    synchronized (this) {
        interval = (Interval) needed.remove(0);
    }
    dloader.connectHTTP(getOverlapOffset(interval.low), interval.high);
    dloader.stopAt(interval.high + 1);
    debug("String_Node_Str" + interval + "String_Node_Str" + dloader);
}

Output:
     }
-    dloader.connectHTTP(getOverlapOffset(interval.low), interval.high);
+    dloader.connectHTTP(getOverlapOffset(interval.low), interval.high + 1);
     dloader.stopAt(interval.high + 1);


Input:
public static void init() {
    addDelayed(Dungeon.hero, -Float.MIN_VALUE);
    for (Mob mob : Dungeon.level.mobs) {
        add(mob);
    }
    for (Blob blob : Dungeon.level.blobs.values()) {
        add(blob);
    }
    current = null;
}

Output:
 public static void init() {
-    addDelayed(Dungeon.hero, -Float.MIN_VALUE);
+    add(Dungeon.hero);
     for (Mob mob : Dungeon.level.mobs) {


Input:
public void onInventoryClick(InventoryClickEvent event) {
    if (event.getWhoClicked() instanceof Player) {
        Player player = (Player) event.getWhoClicked();
        if (checkManager.willCheck(player, CheckType.FAST_INVENTORY)) {
            if (backend.checkInventoryClicks(player)) {
                if (!config.silentMode()) {
                    event.setCancelled(!config.silentMode());
                    player.setHealth(0);
                }
                log("String_Node_Str", player, CheckType.FAST_INVENTORY);
            } else {
                decrease(player);
            }
        }
    }
    Anticheat.getManager().addEvent(event.getEventName(), event.getHandlers().getRegisteredListeners());
}

Output:
                     event.setCancelled(!config.silentMode());
-                    player.setHealth(0);
+                    player.damage(9999);
                 }


Input:
public boolean init() {
    looper = new Progress();
    ClientConnectHandler connectHandler = new ClientConnectHandler();
    rrClient = new RRClient(masterAddress, masterPort, null, looper, thisWorker.getWorkerID(), connectHandler);
    long interval = JobMasterContext.pingInterval(config);
    pinger = new Pinger(thisWorker, rrClient, interval);
    workerController = new WorkerController(config, thisWorker, rrClient);
    Network.Ping.Builder pingBuilder = Network.Ping.newBuilder();
    rrClient.registerResponseHandler(pingBuilder, pinger);
    ListWorkersRequest.Builder listRequestBuilder = ListWorkersRequest.newBuilder();
    ListWorkersResponse.Builder listResponseBuilder = ListWorkersResponse.newBuilder();
    rrClient.registerResponseHandler(listRequestBuilder, workerController);
    rrClient.registerResponseHandler(listResponseBuilder, workerController);
    Network.WorkerStateChange.Builder stateChangeBuilder = Network.WorkerStateChange.newBuilder();
    Network.WorkerStateChangeResponse.Builder stateChangeResponseBuilder = Network.WorkerStateChangeResponse.newBuilder();
    ResponseMessageHandler responseMessageHandler = new ResponseMessageHandler();
    rrClient.registerResponseHandler(stateChangeBuilder, responseMessageHandler);
    rrClient.registerResponseHandler(stateChangeResponseBuilder, responseMessageHandler);
    long connectionTimeLimit = 100000;
    tryUntilConnected(connectionTimeLimit);
    if (rrClient.isConnected()) {
        LOG.info("String_Node_Str");
    } else {
        LOG.severe("String_Node_Str");
        return false;
    }
    this.start();
    return true;
}

Output:
     pinger = new Pinger(thisWorker, rrClient, interval);
-    workerController = new WorkerController(config, thisWorker, rrClient);
+    workerController = new WorkerController(config, thisWorker, rrClient, numberOfWorkers);
     Network.Ping.Builder pingBuilder = Network.Ping.newBuilder();


Input:
protected void applicationSetup() {
    installShutdownHook();
    KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(new GlobalAutoScrollerFocusListener());
    JPanel statusPanel = createStatusPanel();
    String showStatusBar = settings.getProperty("String_Node_Str");
    if (showStatusBar != null && showStatusBar.equals("String_Node_Str"))
        statusPanel.setVisible(false);
    mainPanel.add(statusPanel, BorderLayout.SOUTH);
    String str = getSettings().getProperty("String_Node_Str");
    Locale loc = PersistHelper.createLocale(str);
    if (loc != null) {
        Locale.setDefault(loc);
    }
    TimeZone defaultTimeZone = TimeZone.getDefault();
    if (defaultTimeZone != null) {
        str = getSettings().getProperty("String_Node_Str", defaultTimeZone.getID());
        TimeZone tz = TimeZone.getTimeZone(str);
        if (tz != null) {
            getClientInfo().setTimeZone(tz);
            TimeZone.setDefault(tz);
        }
    }
    super.applicationSetup();
    jsWindowManager = createJSWindowManager();
    cmdManager = createCmdManager();
    Map<String, Action> actions = getActions();
    toolbarsPanel = new ToolbarPanel(Settings.INITIAL_CLIENT_WIDTH - 200);
    mainPanel.add(toolbarsPanel, BorderLayout.NORTH);
    fillToolbar(actions);
    String showToolBar = settings.getProperty("String_Node_Str");
    if (showToolBar != null && showToolBar.equals("String_Node_Str"))
        toolbarsPanel.setVisible(false);
    JMenuBar menu = createMenuBar(actions);
    String showMenuBar = settings.getProperty("String_Node_Str");
    if (showMenuBar != null && showMenuBar.equals("String_Node_Str"))
        menu.setVisible(false);
    frame.setJMenuBar(menu);
    ((SwingRuntimeWindow) jsWindowManager.getWindow(null)).setJMenuBar(menu);
    if (Utils.isAppleMacOS()) {
        attachAppleMenu(actions);
    }
    setMainFrameInitialBounds();
    mainPanel.showSolutionLoading(true);
}

Output:
     setMainFrameInitialBounds();
-    mainPanel.showSolutionLoading(true);
+    showSolutionLoading(true);
 }


Input:
private byte[] createUploadChunk(long unitSize, int chunkNumber, BufferedInputStream fileStream) throws IOException {
    logger.info("String_Node_Str");
    byte[] readBytes = new byte[(int) unitSize];
    logger.info("String_Node_Str" + readBytes.length);
    int offset = (int) (unitSize * chunkNumber);
    int skipLength = offset;
    logger.info("String_Node_Str" + offset);
    logger.info("String_Node_Str" + unitSize);
    logger.info("String_Node_Str");
    fileStream.skip(skipLength);
    logger.info("String_Node_Str" + fileStream.available());
    int readSize = fileStream.read(readBytes, 0, (int) unitSize);
    logger.info("String_Node_Str" + readSize);
    if (readSize != unitSize) {
        logger.info("String_Node_Str");
        byte[] temp = new byte[readSize];
        System.arraycopy(readBytes, 0, temp, 0, readSize);
        readBytes = temp;
    }
    StringBuilder sb = new StringBuilder();
    for (Byte b : readBytes) {
        sb.append(b.toString());
    }
    logger.info("String_Node_Str" + sb.toString());
    return readBytes;
}

Output:
     logger.info("String_Node_Str" + unitSize);
-    logger.info("String_Node_Str");
+    logger.info("String_Node_Str" + skipLength + "String_Node_Str");
     fileStream.skip(skipLength);


Input:
public void testDuplicateDesign() throws Exception {
    openDesign(fileName);
    designHandle.includeLibrary(inputLibrary, "String_Node_Str");
    LibraryHandle libAHandle = designHandle.getLibrary("String_Node_Str");
    TextItemHandle text1LibA = (TextItemHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", text1LibA);
    TextItemHandle text1LibAHandle = (TextItemHandle) designHandle.getElementFactory().newElementFrom(text1LibA, "String_Node_Str");
    designHandle.getBody().add(text1LibAHandle);
    text1LibAHandle.setName("String_Node_Str");
    TextItemHandle text4LibA = (TextItemHandle) libAHandle.findElement("String_Node_Str");
    assertNotNull("String_Node_Str", text4LibA);
    try {
        TextItemHandle text4LibAHandle = (TextItemHandle) designHandle.getElementFactory().newElementFrom(text4LibA, "String_Node_Str");
        designHandle.getBody().add(text4LibAHandle);
    } catch (Exception e) {
        assertNotNull(e);
    }
}

Output:
     openDesign(fileName);
-    designHandle.includeLibrary(inputLibrary, "String_Node_Str");
+    designHandle.includeLibrary(inputLibraryName, "String_Node_Str");
     LibraryHandle libAHandle = designHandle.getLibrary("String_Node_Str");


Input:
public boolean sell(CommandSender player, String[] s) {
    String currency = iConomy.getBank().getCurrency();
    int amtSold = 1;
    double price = 0;
    MaterialData item = new MaterialData(0);
    if (!BSutils.hasPermission(player, "String_Node_Str", true)) {
        return true;
    }
    if ((s.length > 2) || (s.length == 0)) {
        return false;
    } else if (BSutils.anonymousCheck(player)) {
        return true;
    } else {
        try {
            item = itemDb.get(s[0]);
        } catch (Exception e1) {
            BSutils.sendMessage(player, String.format(BetterShop.configfile.getString("String_Node_Str").replace("String_Node_Str", "String_Node_Str"), s[0]));
            return false;
        }
        String itemname = null;
        try {
            itemname = itemDb.getName(item.getItemTypeId(), item.getData());
        } catch (Exception e2) {
            e2.printStackTrace();
        }
        try {
            price = PriceList.getSellPrice(itemname);
            if (price < 1)
                throw new Exception();
        } catch (Exception e1) {
            BSutils.sendMessage(player, String.format(BetterShop.configfile.getString("String_Node_Str").replace("String_Node_Str", "String_Node_Str"), itemname));
            return true;
        }
        ItemStack itemsToSell = item.toItemStack();
        if (s.length == 2)
            try {
                amtSold = Integer.parseInt(s[1]);
            } catch (Exception e) {
                BSutils.sendMessage(player, s[1] + "String_Node_Str");
            }
        if (amtSold < 0) {
            BSutils.sendMessage(player, BetterShop.configfile.getString("String_Node_Str"));
            return true;
        }
        itemsToSell.setAmount(amtSold);
        PlayerInventory inv = ((Player) player).getInventory();
        int amtHas = amtSold;
        leftover.clear();
        leftover.putAll(inv.removeItem(itemsToSell));
        if (leftover.size() > 0) {
            amtHas = amtSold - leftover.get(0).getAmount();
            BSutils.sendMessage(player, String.format(BetterShop.configfile.getString("String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"), amtHas, amtSold));
        }
        double total = amtHas * price;
        try {
            BSutils.credit(player, total);
            BSutils.sendMessage(player, String.format(BetterShop.configfile.getString("String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"), itemDb.getName(item.getItemTypeId(), item.getData()), amtHas, price, total, currency));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }
}

Output:
             price = PriceList.getSellPrice(itemname);
-            if (price < 1)
+            if (price <= 0)
                 throw new Exception();


Input:
public void setCurrentSearchQuery(String query) {
    mCurrentSearchQuery = query;
}

Output:
 public void setCurrentSearchQuery(String query) {
-    mCurrentSearchQuery = query;
+    if (!query.equals(mCurrentSearchQuery)) {
+        mCurrentSearchQuery = query;
+        reload();
+    }
 }


Input:
public void initInternalStructure(DatabaseSession databaseSession) throws BimserverLockConflictException, BimserverDatabaseException {
    RecordIterator recordIterator = keyValueStore.getRecordIterator(CLASS_LOOKUP_TABLE, databaseSession);
    try {
        Record record = recordIterator.next();
        while (record != null) {
            String packageAndClassName = BinUtils.byteArrayToString(record.getValue());
            String packageName = packageAndClassName.substring(0, packageAndClassName.indexOf("String_Node_Str"));
            String className = packageAndClassName.substring(packageAndClassName.indexOf("String_Node_Str") + 1);
            EClass eClass = (EClass) getEClassifier(packageName, className);
            keyValueStore.openTable(packageAndClassName);
            for (EStructuralFeature eStructuralFeature : eClass.getEAllStructuralFeatures()) {
                if (eStructuralFeature.getEAnnotation("String_Node_Str") != null) {
                    String indexTableName = eClass.getEPackage().getName() + "String_Node_Str" + eClass.getName() + "String_Node_Str" + eStructuralFeature.getName();
                    try {
                        keyValueStore.openIndexTable(indexTableName);
                    } catch (DatabaseNotFoundException e) {
                    }
                }
            }
            Short cid = BinUtils.byteArrayToShort(record.getKey());
            classifiers.put(cid, eClass);
            record = recordIterator.next();
        }
    } finally {
        recordIterator.close();
    }
}

Output:
             EClass eClass = (EClass) getEClassifier(packageName, className);
-            keyValueStore.openTable(packageAndClassName);
+            boolean transactional = !(eClass.getEPackage() == Ifc2x3tc1Package.eINSTANCE || eClass.getEPackage() == Ifc4Package.eINSTANCE);
+            keyValueStore.openTable(packageAndClassName, transactional);
             for (EStructuralFeature eStructuralFeature : eClass.getEAllStructuralFeatures()) {


Input:
public void testRetainAllNull() {
    List<List<String>> listTypes = new ArrayList<>();
    listTypes.add(new ArrayList<>());
    listTypes.add(new BasicEventList<>());
    listTypes.add(SortedList.create(new BasicEventList<>()));
    for (List<String> list : listTypes) {
        list.clear();
        list.addAll(Arrays.asList("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str"));
        assertEquals(true, list.retainAll(Arrays.asList("String_Node_Str", null)));
        assertEquals(true, list.retainAll(Arrays.asList("String_Node_Str", null)));
        list.clear();
        list.addAll(Arrays.asList(null, "String_Node_Str", null, "String_Node_Str"));
        assertEquals(true, list.retainAll(Arrays.asList("String_Node_Str", null)));
        assertEquals(true, list.retainAll(Arrays.asList("String_Node_Str", null)));
    }
}

Output:
     listTypes.add(new BasicEventList<>());
-    listTypes.add(SortedList.create(new BasicEventList<>()));
+    listTypes.add(SortedList.create(new BasicEventList<String>()));
     for (List<String> list : listTypes) {


Input:
private void handleGlobalAction() {
    for (int i = 0; i < GlobalActionFactory.GLOBAL_STACK_ACTIONS.length; i++) {
        String id = GlobalActionFactory.GLOBAL_STACK_ACTIONS[i];
        getSite().getActionBars().setGlobalActionHandler(id, GlobalActionFactory.createStackAction(id, SessionHandleAdapter.getInstance().getCommandStack()));
    }
}

Output:
         String id = GlobalActionFactory.GLOBAL_STACK_ACTIONS[i];
-        getSite().getActionBars().setGlobalActionHandler(id, GlobalActionFactory.createStackAction(id, SessionHandleAdapter.getInstance().getCommandStack()));
+        getSite().getActionBars().setGlobalActionHandler(id, GlobalActionFactory.createStackAction(id, SessionHandleAdapter.getInstance().getCommandStack(moduleHandle)));
     }


Input:
private IJstType checkFullyQualifierTypeInvocation(MtdInvocationExpr mtdInvocationExpr) {
    final String fullName = JstExpressionTypeLinkerHelper.getFullName(mtdInvocationExpr);
    IJstType type = JstExpressionTypeLinkerHelper.findFullQualifiedType(m_resolver, fullName);
    if (type != null) {
        JstExpressionTypeLinkerHelper.bindMtdInvocations(m_resolver, this, mtdInvocationExpr, type.getConstructor());
        JstExpressionTypeLinkerHelper.doExprTypeUpdate(m_resolver, this, mtdInvocationExpr, type, m_groupInfo);
        JstExpressionTypeLinkerHelper.setPackageBindingForQualifier(mtdInvocationExpr.getQualifyExpr());
        return type;
    }
    return null;
}

Output:
     final String fullName = JstExpressionTypeLinkerHelper.getFullName(mtdInvocationExpr);
-    IJstType type = JstExpressionTypeLinkerHelper.findFullQualifiedType(m_resolver, fullName);
+    IJstType type = JstExpressionTypeLinkerHelper.findFullQualifiedType(m_resolver, fullName, m_groupInfo);
     if (type != null) {


Input:
public static boolean generateMaze(World world, Random random, BlockCoord coord, List<MazeComponentPosition> placedComponents, int[] roomSize, int layer) {
    int[] pathLengths = new int[] { 0, 0, 0 };
    for (MazeComponentPosition position : placedComponents) {
        String identifier = position.getComponent().getIdentifier();
        int splitIndex0 = identifier.lastIndexOf("String_Node_Str");
        boolean mirror = Boolean.valueOf(identifier.substring(splitIndex0 + 1));
        int splitIndex1 = identifier.lastIndexOf("String_Node_Str", splitIndex0 - 1);
        String structure = identifier.substring(0, splitIndex1);
        int rotations = Integer.valueOf(identifier.substring(splitIndex1 + 1, splitIndex0));
        MazeRoom mazePosition = position.getPositionInMaze();
        int[] scaledCompMazePosition = Maze.getRoomPosition(mazePosition, pathLengths, roomSize);
        AxisAlignedTransform2D componentTransform = AxisAlignedTransform2D.transform(rotations, mirror);
        StructureInfo compStructureInfo = StructureHandler.getStructure(structure);
        if (compStructureInfo != null) {
            int[] compSize = compStructureInfo.structureBoundingBox();
            int[] sizeDependentShift = new int[] { (roomSize[0] - compSize[0]) / 2 };
            BlockCoord compMazeCoordLower = coord.add(scaledCompMazePosition[0] + sizeDependentShift[0], scaledCompMazePosition[1] + sizeDependentShift[1], scaledCompMazePosition[2] + +sizeDependentShift[2]);
            compStructureInfo.generate(world, random, compMazeCoordLower, componentTransform, layer + 1);
        } else {
            StructureGen.logger.error("String_Node_Str" + structure + "String_Node_Str");
        }
    }
    return true;
}

Output:
             int[] compSize = compStructureInfo.structureBoundingBox();
-            int[] sizeDependentShift = new int[] { (roomSize[0] - compSize[0]) / 2 };
+            int[] sizeDependentShift = new int[] { (roomSize[0] - compSize[0]) / 2, (roomSize[1] - compSize[1]) / 2, (roomSize[2] - compSize[2]) / 2 };
             BlockCoord compMazeCoordLower = coord.add(scaledCompMazePosition[0] + sizeDependentShift[0], scaledCompMazePosition[1] + sizeDependentShift[1], scaledCompMazePosition[2] + +sizeDependentShift[2]);


Input:
public final void activate(Lock lock) {
    super.activate(lock);
    set = getBackend().readIndex();
    map = new HashMap<String, Key>();
    for (Key key : set) {
        map.put(key.getName(), key);
    }
    global = new ReadOnlyKeyList(set, false);
    active = true;
}

Output:
     for (Key key : set) {
-        map.put(key.getName(), key);
+        map.put(key.getOsisRef(), key);
     }


Input:
public com.cloudant.client.api.model.Response save(Object object, int writeQuorum) {
    Response couchDbResponse = client.put(getDBUri(), object, true, writeQuorum, getGson());
    com.cloudant.client.api.model.Response response = new com.cloudant.client.api.model.Response(couchDbResponse);
    return response;
}

Output:
 public com.cloudant.client.api.model.Response save(Object object, int writeQuorum) {
-    Response couchDbResponse = client.put(getDBUri(), object, true, writeQuorum, getGson());
+    Response couchDbResponse = client.put(getDBUri(), object, true, writeQuorum, client.getGson());
     com.cloudant.client.api.model.Response response = new com.cloudant.client.api.model.Response(couchDbResponse);


Input:
private static String readUTF(DataInput in) throws IOException {
    int utflen = in.readInt();
    byte[] bytearr;
    char[] chararr;
    try {
        bytearr = new byte[utflen];
        chararr = new char[utflen];
    } catch (OutOfMemoryError e) {
        final IOException ex = new IOException("String_Node_Str" + "String_Node_Str");
        ex.initCause(e);
        throw ex;
    }
    int c, char2, char3;
    int count = 0;
    int chararr_count = 0;
    in.readFully(bytearr, 0, utflen);
    while (count < utflen) {
        c = bytearr[count] & 0xff;
        if (c > 127) {
            break;
        }
        count++;
        chararr[chararr_count++] = (char) c;
    }
    while (count < utflen) {
        c = bytearr[count] & 0xff;
        switch(c >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                count++;
                chararr[chararr_count++] = (char) c;
                break;
            case 12:
            case 13:
                count += 2;
                if (count > utflen) {
                    throw new UTFDataFormatException("String_Node_Str");
                }
                char2 = bytearr[count - 1];
                if ((char2 & 0xC0) != 0x80) {
                    throw new UTFDataFormatException("String_Node_Str" + count);
                }
                chararr[chararr_count++] = (char) (((c & 0x1F) << 6) | (char2 & 0x3F));
                break;
            case 14:
                count += 3;
                if (count > utflen) {
                    throw new UTFDataFormatException("String_Node_Str");
                }
                char2 = bytearr[count - 2];
                char3 = bytearr[count - 1];
                if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80)) {
                    throw new UTFDataFormatException("String_Node_Str" + (count - 1));
                }
                chararr[chararr_count++] = (char) (((c & 0x0F) << 12) | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));
                break;
            default:
                throw new UTFDataFormatException("String_Node_Str" + count);
        }
    }
    return new String(chararr, 0, chararr_count);
}

Output:
     int count = 0;
-    int chararr_count = 0;
+    int chararrCount = 0;
     in.readFully(bytearr, 0, utflen);


Input:
public static String createHIT(String title, String description, String keywords, String xml, double reward, long assignmentDuration, long maxAutoApproveDelay, long lifetime, QualificationType qualificationType) {
    int waittime = 1;
    synchronized (service) {
        while (true) {
            try {
                QualificationRequirement qr = new QualificationRequirement(qualificationType.getQualificationTypeId(), null, null, null, true);
                HIT hitid = service.createHIT(null, title, description, keywords, xml, reward, assignmentDuration, maxAutoApproveDelay, lifetime, 1, "String_Node_Str", new QualificationRequirement[] { qr }, null);
                return hitid.getHITId();
            } catch (InternalServiceException ise) {
                LOGGER.info(ise);
                chill(waittime);
                waittime = waittime * 2;
            }
        }
    }
}

Output:
             try {
-                QualificationRequirement qr = new QualificationRequirement(qualificationType.getQualificationTypeId(), null, null, null, true);
+                QualificationRequirement qr = new QualificationRequirement(qualificationType.getQualificationTypeId(), Comparator.fromString("String_Node_Str"), null, null, true);
                 HIT hitid = service.createHIT(null, title, description, keywords, xml, reward, assignmentDuration, maxAutoApproveDelay, lifetime, 1, "String_Node_Str", new QualificationRequirement[] { qr }, null);


Input:
public Principal apply(Authorizable authorizable) {
    if (authorizable == null) {
        return null;
    }
    try {
        return authorizable.getPrincipal();
    } catch (RepositoryException e) {
        String msg = "String_Node_Str" + e.getMessage();
        log.error(msg);
        throw new IllegalStateException(msg);
    }
}

Output:
         log.error(msg);
-        throw new IllegalStateException(msg);
+        throw new IllegalStateException(msg, e);
     }


Input:
private void closeClient() {
    if (client != null) {
        log.debug("String_Node_Str", label);
        try {
            client.stop();
            client.destroy();
            execService.shutdown();
        } catch (Exception e1) {
            log.debug("String_Node_Str", label);
        }
        client = null;
    }
}

Output:
             execService.shutdown();
-        } catch (Exception e1) {
-            log.debug("String_Node_Str", label);
+        } catch (Exception e) {
+            log.debug("String_Node_Str", label, e);
         }


Input:
protected String getSchemaTypeString(QName schemaType, Schema workingSchema) {
    String schemaTypeString = schemaType.getLocalPart();
    String uri = schemaType.getNamespaceURI();
    String prefix = workingSchema.getNamespaceResolver().resolveNamespaceURI(uri);
    if (prefix == null && !uri.equals(workingSchema.getDefaultNamespace())) {
        if (uri.equals(XMLConstants.SCHEMA_URL)) {
            prefix = workingSchema.getNamespaceResolver().generatePrefix(XMLConstants.SCHEMA_PREFIX);
        } else if (uri.equals(XMLConstants.SCHEMA_INSTANCE_URL)) {
            prefix = workingSchema.getNamespaceResolver().generatePrefix(XMLConstants.SCHEMA_INSTANCE_PREFIX);
        } else {
            prefix = workingSchema.getNamespaceResolver().generatePrefix();
        }
        workingSchema.getNamespaceResolver().put(prefix, uri);
    }
    if (prefix != null) {
        schemaTypeString = prefix + COLON + schemaTypeString;
    }
    return schemaTypeString;
}

Output:
     String prefix = workingSchema.getNamespaceResolver().resolveNamespaceURI(uri);
-    if (prefix == null && !uri.equals(workingSchema.getDefaultNamespace())) {
+    if (prefix == null && !areNamespacesEqual(uri, workingSchema.getDefaultNamespace())) {
         if (uri.equals(XMLConstants.SCHEMA_URL)) {


Input:
public boolean apply(Game game, Ability source) {
    Card card = game.getCard(getTargetPointer().getFirst(game, source));
    if (card != null) {
        Effect effect = new ReturnFromGraveyardToBattlefieldTargetEffect();
        effect.setTargetPointer(new FixedTarget(card.getId()));
        effect.setText("String_Node_Str");
        DelayedTriggeredAbility delayedAbility = new AtTheBeginOfNextEndStepDelayedTriggeredAbility(effect);
        delayedAbility.setSourceId(source.getSourceId());
        delayedAbility.setControllerId(source.getControllerId());
        delayedAbility.setSourceObject(source.getSourceObject(game));
        game.addDelayedTriggeredAbility(delayedAbility);
        return true;
    }
    return false;
}

Output:
         effect.setText("String_Node_Str");
-        DelayedTriggeredAbility delayedAbility = new AtTheBeginOfNextEndStepDelayedTriggeredAbility(effect);
+        DelayedTriggeredAbility delayedAbility = new AtTheBeginOfNextEndStepDelayedTriggeredAbility(Zone.COMMAND, effect, TargetController.ANY);
         delayedAbility.setSourceId(source.getSourceId());


Input:
private IAggregationResultSet[] executeQuery(BirtCubeView view, AggregationDefinition[] aggrDefns, boolean saveToRD, String queryResutID, IBindingValueFetcher fetcher) throws IOException, BirtException {
    IAggregationResultSet[] rs;
    CubeQueryExecutor executor = view.getCubeQueryExecutor();
    rs = cubeQueryExecutorHelper.execute(aggrDefns, executor.getSession().getStopSign());
    rs = QueryExecutorUtil.applyFilterOnOperation(view, cubeQueryExecutorHelper, executor, aggrDefns, rs, fetcher, executor.getSession().getStopSign());
    rs = noUpdateFilterHelper.applyNoAggrUpdateFilters(executor.getCubeQueryDefinition().getFilters(), executor, rs, view.getCube(), fetcher, false);
    MirrorOperationExecutor moe = new MirrorOperationExecutor();
    rs = moe.execute(rs, view, cubeQueryExecutorHelper);
    QueryExecutorUtil.validateLimitSetting(view, rs);
    rs = this.processNestedAggrOperation(executor, view, executor.getSession().getStopSign(), rs, fetcher);
    if (executor.getCubeQueryDefinition().cacheQueryResults()) {
        File tmpDir = new File(executor.getSession().getTempDir());
        if (!FileSecurity.fileExist(tmpDir) || !FileSecurity.fileIsDirectory(tmpDir)) {
            FileSecurity.fileMakeDirs(tmpDir);
        }
        ArchiveWriter writer = new ArchiveWriter(new ArchiveFile(executor.getSession().getTempDir() + "String_Node_Str", "String_Node_Str"));
        AggregationResultSetSaveUtil.save(queryResutID, rs, writer);
        writer.finish();
    }
    if (saveToRD) {
        CubeQueryDefinitionIOUtil.save(queryResutID, executor.getContext(), executor.getCubeQueryDefinition());
        AggregationResultSetSaveUtil.save(queryResutID, rs, executor.getContext().getDocWriter());
    }
    return rs;
}

Output:
     if (executor.getCubeQueryDefinition().cacheQueryResults()) {
-        File tmpDir = new File(executor.getSession().getTempDir());
+        String tmpDirPath = executor.getSession().getTempDir();
+        File tmpDir = new File(tmpDirPath);
         if (!FileSecurity.fileExist(tmpDir) || !FileSecurity.fileIsDirectory(tmpDir)) {