Input:
private void onStartInputViewInternal(final EditorInfo editorInfo, final boolean restarting) {
    super.onStartInputView(editorInfo, restarting);
    final KeyboardSwitcher switcher = mKeyboardSwitcher;
    final MainKeyboardView mainKeyboardView = switcher.getMainKeyboardView();
    if (editorInfo == null) {
        Log.e(TAG, "String_Node_Str");
        if (LatinImeLogger.sDBG) {
            throw new NullPointerException("String_Node_Str");
        }
        return;
    }
    if (DEBUG) {
        Log.d(TAG, "String_Node_Str" + String.format("String_Node_Str", editorInfo.inputType, editorInfo.imeOptions));
        Log.d(TAG, "String_Node_Str" + ((editorInfo.inputType & InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS) != 0) + "String_Node_Str" + ((editorInfo.inputType & InputType.TYPE_TEXT_FLAG_CAP_SENTENCES) != 0) + "String_Node_Str" + ((editorInfo.inputType & InputType.TYPE_TEXT_FLAG_CAP_WORDS) != 0));
    }
    if (ProductionFlag.IS_EXPERIMENTAL) {
        ResearchLogger.latinIME_onStartInputViewInternal(editorInfo, mPrefs);
    }
    if (InputAttributes.inPrivateImeOptions(null, NO_MICROPHONE_COMPAT, editorInfo)) {
        Log.w(TAG, "String_Node_Str" + editorInfo.privateImeOptions);
        Log.w(TAG, "String_Node_Str" + getPackageName() + "String_Node_Str" + NO_MICROPHONE + "String_Node_Str");
    }
    if (InputAttributes.inPrivateImeOptions(getPackageName(), FORCE_ASCII, editorInfo)) {
        Log.w(TAG, "String_Node_Str" + editorInfo.privateImeOptions);
        Log.w(TAG, "String_Node_Str");
    }
    mTargetApplicationInfo = TargetApplicationGetter.getCachedApplicationInfo(editorInfo.packageName);
    if (null == mTargetApplicationInfo) {
        new TargetApplicationGetter(this, this).execute(editorInfo.packageName);
    }
    LatinImeLogger.onStartInputView(editorInfo);
    if (mainKeyboardView == null) {
        return;
    }
    final AccessibilityUtils accessUtils = AccessibilityUtils.getInstance();
    if (accessUtils.isTouchExplorationEnabled()) {
        accessUtils.onStartInputViewInternal(mainKeyboardView, editorInfo, restarting);
    }
    final boolean selectionChanged = mLastSelectionStart != editorInfo.initialSelStart || mLastSelectionEnd != editorInfo.initialSelEnd;
    final boolean inputTypeChanged = !mCurrentSettings.isSameInputType(editorInfo);
    final boolean isDifferentTextField = !restarting || inputTypeChanged;
    if (isDifferentTextField) {
        final boolean currentSubtypeEnabled = mSubtypeSwitcher.updateParametersOnStartInputViewAndReturnIfCurrentSubtypeEnabled();
        if (!currentSubtypeEnabled) {
            final InputMethodSubtype newSubtype = ImfUtils.getCurrentInputMethodSubtype(this, mSubtypeSwitcher.getNoLanguageSubtype());
            mSubtypeSwitcher.updateSubtype(newSubtype);
            loadKeyboard();
        }
    }
    updateFullscreenMode();
    mApplicationSpecifiedCompletions = null;
    if (isDifferentTextField || selectionChanged) {
        mEnteredText = null;
        resetComposingState(true);
        mDeleteCount = 0;
        mSpaceState = SPACE_STATE_NONE;
        if (mSuggestionStripView != null) {
            mSuggestionStripView.clear();
        }
    }
    mConnection.resetCachesUponCursorMove(mLastSelectionStart);
    if (isDifferentTextField) {
        mainKeyboardView.closing();
        loadSettings();
        if (mSuggest != null && mCurrentSettings.mCorrectionEnabled) {
            mSuggest.setAutoCorrectionThreshold(mCurrentSettings.mAutoCorrectionThreshold);
        }
        switcher.loadKeyboard(editorInfo, mCurrentSettings);
    }
    setSuggestionStripShownInternal(isSuggestionsStripVisible(), false);
    mLastSelectionStart = editorInfo.initialSelStart;
    mLastSelectionEnd = editorInfo.initialSelEnd;
    mKeyboardSwitcher.updateShiftState();
    mHandler.cancelUpdateSuggestionStrip();
    mHandler.cancelDoubleSpacesTimer();
    mainKeyboardView.setMainDictionaryAvailability(mIsMainDictionaryAvailable);
    mainKeyboardView.setKeyPreviewPopupEnabled(mCurrentSettings.mKeyPreviewPopupOn, mCurrentSettings.mKeyPreviewPopupDismissDelay);
    mainKeyboardView.setGestureHandlingEnabledByUser(mCurrentSettings.mGestureInputEnabled);
    mainKeyboardView.setGesturePreviewMode(mCurrentSettings.mGesturePreviewTrailEnabled, mCurrentSettings.mGestureFloatingPreviewTextEnabled);
    if (TRACE)
        Debug.startMethodTracing("String_Node_Str");
}

Output:
     }
-    mConnection.resetCachesUponCursorMove(mLastSelectionStart);
+    mConnection.resetCachesUponCursorMove(editorInfo.initialSelStart);
     if (isDifferentTextField) {


Input:
protected void waitForResponse(Game game) {
    if (isExecutingMacro()) {
        pullResponseFromQueue(game);
        return;
    }
    response.clear();
    logger.debug("String_Node_Str" + getId());
    game.resumeTimer(getTurnControlledBy());
    boolean loop = true;
    while (loop) {
        loop = false;
        synchronized (response) {
            try {
                response.wait();
            } catch (InterruptedException ex) {
                logger.error("String_Node_Str" + getName() + "String_Node_Str" + game.getId(), ex);
            } finally {
                game.pauseTimer(getTurnControlledBy());
            }
        }
        if (response.getResponseConcedeCheck()) {
            ((GameImpl) game).checkConcede();
            if (game.hasEnded()) {
                return;
            }
            response.clear();
            loop = true;
        }
    }
    if (recordingMacro && !macroTriggeredSelectionFlag) {
        actionQueueSaved.add(new PlayerResponse(response));
    }
}

Output:
             response.clear();
-            loop = true;
+            if (isInGame()) {
+                loop = true;
+            }
         }


Input:
private static int calcBasePower(BattlePlayer playerAttacker, BattlePlayer playerDefender, Move move, Battle stats) {
    Pokemon attacker = playerAttacker.getPokemon();
    Pokemon defender = playerDefender.getPokemon();
    double hh = 1;
    double bp = move.getBasePower();
    double it = 1;
    double chg = 1;
    double ms = 1;
    double ws = 1;
    double ua = 1;
    double fa = 1;
    switch(attacker.getHeldItem()) {
        case Items.MUSCLE_BAND:
            if (move.getKind() == MoveKinds.PHYSICAL) {
                it = 1.1;
            }
            break;
        case Items.WISE_GLASSES:
            if (move.getKind() == MoveKinds.SPECIAL) {
                it = 1.1;
            }
            break;
        case Items.ADAMANT_ORB:
            if (attacker.getSpecies().getDexNumber() == 483) {
                if (move.getType() == Types.STEEL || move.getType() == Types.DRAGON) {
                    it = (long) 1.2;
                }
            }
            break;
        case Items.LUSTROUS_ORB:
            if (attacker.getSpecies().getDexNumber() == 484 && (move.getType() == Types.WATER || move.getType() == Types.DRAGON)) {
                it = (long) 1.2;
            }
            break;
        case Items.GRISEOUS_ORB:
            if (attacker.getSpecies().getDexNumber() == 480 && (move.getType() == Types.GHOST || move.getType() == Types.DRAGON)) {
                it = (long) 1.2;
            }
            break;
    }
    if (stats.getSport() == Sport.MUD_SPORT && move.getType() == Types.ELECTRIC) {
        ms = (long) 0.5;
    }
    if (stats.getSport() == Sport.WATER_SPORT && move.getType() == Types.FIRE) {
        ws = (long) 0.5;
    }
    switch(attacker.getAbility()) {
        case RIVALRY:
            if (attacker.getGender() == defender.getGender()) {
                ua = (long) 1.25;
            } else if (attacker.getGender() != defender.getGender()) {
                ua = (long) 0.75;
            } else {
                ua = 1;
            }
            break;
        case RECKLESS:
            if (move.isRecoil()) {
                ua = (long) 1.2;
            }
            break;
        case IRON_FIST:
            if (move.isPunching()) {
                ua = (long) 1.2;
            }
            break;
        case BLAZE:
            if (attacker.getCurrentHealthRatio() < 0.3 && move.getType() == Types.FIRE) {
                ua = (long) 1.5;
            }
            break;
        case TORRENT:
            if (attacker.getCurrentHealthRatio() < 0.3 && move.getType() == Types.WATER) {
                ua = (long) 1.5;
            }
            break;
        case OVERGROW:
            if (attacker.getCurrentHealthRatio() < 0.3 && move.getType() == Types.GRASS) {
                ua = (long) 1.5;
            }
            break;
        case SWARM:
            if (attacker.getCurrentHealthRatio() < 0.3 && move.getType() == Types.BUG) {
                ua = (long) 1.5;
            }
            break;
        case TECHNICIAN:
            if (move.getBasePower() <= 60) {
                ua = (long) 1.5;
            }
            break;
    }
    switch(defender.getAbility()) {
        case THICK_FAT:
            if (move.getType() == Types.FIRE || move.getType() == Types.ICE) {
                fa = (long) 0.5;
            }
            break;
        case HEATPROOF:
            if (move.getType() == Types.FIRE) {
                fa = (long) 0.5;
            }
            break;
        case DRY_SKIN:
            if (move.getType() == Types.FIRE) {
                fa = (long) 1.25;
            }
            break;
    }
    int basePower = (int) (hh * bp * it * chg * ms * ws * ua * fa);
    return basePower;
}

Output:
     }
-    switch(attacker.getAbility()) {
+    switch(attacker.getBattleAbility()) {
         case RIVALRY:


Input:
public void onClick(AjaxRequestTarget target) {
    SelectSubOClassDialogPage.this.modal.close(target);
    onSelect(target, getModelObject());
}

Output:
     SelectSubOClassDialogPage.this.modal.close(target);
-    onSelect(target, getModelObject());
+    SelectSubOClassDialogPage.this.modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
+        public void onClose(AjaxRequestTarget target) {
+            onSelect(target, getModelObject());
+        }
+    });
 }


Input:
public Object fromColumnThriftRow(Class<?> clazz, EntityMetadata m, ThriftRow thriftRow, List<String> relationNames, boolean isWrapperReq) throws Exception {
    Object entity = null;
    Map<String, Object> relations = new HashMap<String, Object>();
    for (Column c : thriftRow.getColumns()) {
        if (entity == null) {
            entity = clazz.newInstance();
            PropertyAccessorHelper.setId(entity, m, thriftRow.getId());
        }
        String thriftColumnName = PropertyAccessorFactory.STRING.fromBytes(String.class, c.getName());
        byte[] thriftColumnValue = c.getValue();
        if (null == thriftColumnValue) {
            continue;
        }
        com.impetus.kundera.metadata.model.Column column = m.getColumn(thriftColumnName);
        if (column != null) {
            try {
                PropertyAccessorHelper.set(entity, column.getField(), thriftColumnValue);
            } catch (PropertyAccessException pae) {
                log.warn(pae.getMessage());
            }
        } else {
            if (relationNames != null && !relationNames.isEmpty() && relationNames.contains(thriftColumnName)) {
                String value = PropertyAccessorFactory.STRING.fromBytes(String.class, thriftColumnValue);
                relations.put(thriftColumnName, value);
            }
        }
    }
    return isWrapperReq ? new EnhanceEntity(entity, thriftRow.getId(), relations) : entity;
}

Output:
     }
-    return isWrapperReq ? new EnhanceEntity(entity, thriftRow.getId(), relations) : entity;
+    return isWrapperReq && relations != null && !relations.isEmpty() ? new EnhanceEntity(entity, thriftRow.getId(), relations) : entity;
 }


Input:
public void writeWrap(MethodWriter writer, int index) throws BytecodeException {
    String internal = this.theClass.getInternalName();
    if (this.theClass == Types.getObjectRefClass()) {
        writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE, internal, "String_Node_Str", "String_Node_Str", true);
        return;
    }
    StringBuilder sb = new StringBuilder().append('(');
    this.type.appendExtendedName(sb);
    sb.append("String_Node_Str");
    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE, internal, "String_Node_Str", sb.toString(), true);
}

Output:
     }
-    StringBuilder sb = new StringBuilder().append('(');
-    this.type.appendExtendedName(sb);
-    sb.append("String_Node_Str");
-    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE, internal, "String_Node_Str", sb.toString(), true);
+    final StringBuilder stringBuilder = new StringBuilder().append('(');
+    this.type.appendExtendedName(stringBuilder);
+    stringBuilder.append("String_Node_Str");
+    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE, internal, "String_Node_Str", stringBuilder.toString(), true);
 }


Input:
protected boolean needPaginate() {
    return false;
}

Output:
 protected boolean needPaginate() {
-    return false;
+    return true;
 }


Input:
public void testFitToPageTrue() throws EngineException {
    List pages = getPages(true, false);
    float[] scales = new float[] { 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f };
    assertTrue(pages.size() == scales.length);
    for (int i = 0; i < pages.size(); i++) {
        PageArea page = (PageArea) pages.get(i);
        assertEquals(new Float(scales[i]), new Float(page.getScale()));
    }
    pages = getPages(true, true);
    scales = new float[] { 0.75f, 0.75f, 0.75f, 0.234f };
    assertTrue(pages.size() == scales.length);
    for (int i = 0; i < pages.size(); i++) {
        PageArea page = (PageArea) pages.get(i);
        float delta = scales[i] - page.getScale();
        assertTrue(delta > -0.001 && delta < 0.001);
    }
}

Output:
 public void testFitToPageTrue() throws EngineException {
-    List pages = getPages(true, false);
-    float[] scales = new float[] { 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f };
-    assertTrue(pages.size() == scales.length);
-    for (int i = 0; i < pages.size(); i++) {
-        PageArea page = (PageArea) pages.get(i);
-        assertEquals(new Float(scales[i]), new Float(page.getScale()));
-    }
-    pages = getPages(true, true);
-    scales = new float[] { 0.75f, 0.75f, 0.75f, 0.234f };
+    List pages = getPages(true, true);
+    float[] scales = new float[] { 0.75f, 0.75f, 0.75f, 0.23f };
     assertTrue(pages.size() == scales.length);


Input:
public static void deleteUser(User user) {
    PortalManager.deletePortals(user);
    deleteDroppedItems(user);
    for (Map.Entry<String, User> entry : UserManager.getUserList().entrySet()) if (entry.getValue() == user)
        users.remove(entry.getKey());
}

Output:
     deleteDroppedItems(user);
-    for (Map.Entry<String, User> entry : UserManager.getUserList().entrySet()) if (entry.getValue() == user)
+    for (Map.Entry<String, User> entry : users.entrySet()) if (entry.getValue() == user)
         users.remove(entry.getKey());


Input:
protected String getDateString(Date date) {
    return this.getDateFormat().format(date);
}

Output:
 protected String getDateString(Date date) {
-    return this.getDateFormat().format(date);
+    if (getDateFormat() != null) {
+        return getDateFormat().format(date);
+    }
+    if (date == null) {
+        return null;
+    }
+    return ConversionManager.getDefaultManager().convertObject(date, String.class).toString();
 }


Input:
private void printMethods(FutureType type, String typeName, Iterable<Method> methods) {
    for (Method m : methods) {
        context = new MethodContext(type, m);
        String methodName = m.getName();
        String returnType = m.getReturnType().getName();
        if (methodName.equals("String_Node_Str")) {
            println(getKeywords(m.getFlags()) + "String_Node_Str" + typeName + "String_Node_Str" + paramString(m.getParameters()) + "String_Node_Str");
        } else {
            println(getKeywords(m.getFlags()) + "String_Node_Str" + returnType + "String_Node_Str" + methodName + "String_Node_Str" + paramString(m.getParameters()) + "String_Node_Str");
        }
        incIndent();
        for (Statement s : m.getStatements()) {
            s.accept(this);
        }
        decIndent();
        println("String_Node_Str");
        println();
    }
}

Output:
         String methodName = m.getName();
-        String returnType = m.getReturnType().getName();
+        String returnType = m.getReturnType().getPrintableName();
         if (methodName.equals("String_Node_Str")) {


Input:
public ServletRegistration.Dynamic addServletFacade(String servletName, String className) {
    if (servletName == null || className == null) {
        throw new NullPointerException("String_Node_Str");
    }
    DynamicServletRegistrationImpl regis = (DynamicServletRegistrationImpl) servletRegisMap.get(servletName);
    if (regis == null) {
        StandardWrapper wrapper = new StandardWrapper();
        wrapper.setName(servletName);
        wrapper.setServletClassName(className);
        regis = (DynamicServletRegistrationImpl) createDynamicServletRegistrationImpl((StandardWrapper) wrapper);
        servletRegisMap.put(servletName, regis);
        servlets.put(servletName, className);
    }
    return regis;
}

Output:
         wrapper.setServletClassName(className);
-        regis = (DynamicServletRegistrationImpl) createDynamicServletRegistrationImpl((StandardWrapper) wrapper);
-        servletRegisMap.put(servletName, regis);
+        regis = (DynamicServletRegistrationImpl) createDynamicServletRegistrationImpl(wrapper);
+        DynamicServletRegistrationImpl tmpRegis = (DynamicServletRegistrationImpl) servletRegisMap.putIfAbsent(servletName, regis);
+        if (tmpRegis != null) {
+            regis = tmpRegis;
+        }
         servlets.put(servletName, className);


Input:
public GerritSystemInfo getInfo(IProgressMonitor monitor) throws GerritException {
    Account account = execute(monitor, new GerritOperation<Account>() {
        public void execute(IProgressMonitor monitor) throws GerritException {
            getAccountService().myAccount(this);
        }
    });
    return new GerritSystemInfo(account);
}

Output:
     Account account = execute(monitor, new GerritOperation<Account>() {
-        public void execute(IProgressMonitor monitor) throws GerritException {
-            getAccountService().myAccount(this);
-        }
-    });
-    return new GerritSystemInfo(account);
+            public void execute(IProgressMonitor monitor) throws GerritException {
+                getAccountService().myAccount(this);
+            }
+        });
+    } else {
+        executeQuery(monitor, "String_Node_Str");
+    }
+    return new GerritSystemInfo(contributorAgreements, account);
 }


Input:
public void actionCollection(ServerContext context, ActionRequest request, ResultHandler<JsonValue> handler) {
    try {
        switch(request.getActionAsEnum(ObjectClassAction.class)) {
            case authenticate:
                handleAuthenticate(context, request, handler);
                break;
            case liveSync:
                handleLiveSync(context, request, handler);
                break;
            default:
                throw new BadRequestException("String_Node_Str" + request.getAction());
        }
    } catch (ResourceException e) {
        handler.handleError(e);
    } catch (JsonValueException e) {
        handler.handleError(new BadRequestException(e));
    } catch (Exception e) {
        handler.handleError(new InternalServerErrorException(e));
    }
}

Output:
     } catch (JsonValueException e) {
-        handler.handleError(new BadRequestException(e));
+        handler.handleError(new BadRequestException(e.getMessage(), e));
     } catch (Exception e) {


Input:
private void getAllFeatures() throws IOException {
    Feature feature = null;
    FeatureFrame frame = frontend.getFeatureFrame(1);
    if (frame != null) {
        feature = frame.getFeatures()[0];
        if (feature.hasContent()) {
            allFeatures.add(feature);
        }
    }
}

Output:
     Feature feature = null;
-    FeatureFrame frame = frontend.getFeatureFrame(1);
-    if (frame != null) {
+    FeatureFrame frame = null;
+    while ((frame = frontend.getFeatureFrame(1)) != null) {
         feature = frame.getFeatures()[0];


Input:
static void SKP_Silk_A2NLSF(int[] NLSF, int[] a_Q16, final int d) {
    int i, k, m, dd, root_ix, ffrac;
    int xlo, xhi, xmid;
    int ylo, yhi, ymid;
    int nom, den;
    int[] P = new int[SigProcFIX.SKP_Silk_MAX_ORDER_LPC / 2 + 1];
    int[] Q = new int[SigProcFIX.SKP_Silk_MAX_ORDER_LPC / 2 + 1];
    int[][] PQ = new int[2][];
    int[] p;
    PQ[0] = P;
    PQ[1] = Q;
    dd = d >> 1;
    SKP_Silk_A2NLSF_init(a_Q16, P, Q, dd);
    p = P;
    xlo = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[0];
    ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
    if (ylo < 0) {
        NLSF[0] = 0;
        p = Q;
        ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
        root_ix = 1;
    } else {
        root_ix = 0;
    }
    k = 1;
    i = 0;
    while (true) {
        if (OVERSAMPLE_COSINE_TABLE) {
            xhi = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[k >> 1] + ((LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[(k + 1) >> 1] - LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[k >> 1]) >> 1);
        } else {
            xhi = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[k];
        }
        yhi = SKP_Silk_A2NLSF_eval_poly(p, xhi, dd);
        if ((ylo <= 0 && yhi >= 0) || (ylo >= 0 && yhi <= 0)) {
            if (OVERSAMPLE_COSINE_TABLE)
                ffrac = -128;
            else
                ffrac = -256;
            for (m = 0; m < BIN_DIV_STEPS_A2NLSF_FIX; m++) {
                xmid = SigProcFIX.SKP_RSHIFT_ROUND(xlo + xhi, 1);
                ymid = SKP_Silk_A2NLSF_eval_poly(p, xmid, dd);
                if ((ylo <= 0 && ymid >= 0) || (ylo >= 0 && ymid <= 0)) {
                    xhi = xmid;
                    yhi = ymid;
                } else {
                    xlo = xmid;
                    ylo = ymid;
                    if (OVERSAMPLE_COSINE_TABLE)
                        ffrac = ffrac + (64 >> m);
                    else
                        ffrac = ffrac + (128 >> m);
                }
            }
            if (Math.abs(ylo) < 65536) {
                den = ylo - yhi;
                nom = (ylo << (8 - BIN_DIV_STEPS_A2NLSF_FIX)) + (den >> 1);
                if (den != 0) {
                    ffrac += nom / den;
                }
            } else {
                ffrac += ylo / ((ylo - yhi) >> (8 - BIN_DIV_STEPS_A2NLSF_FIX));
            }
            if (OVERSAMPLE_COSINE_TABLE)
                NLSF[root_ix] = Math.min((k << 7) + ffrac, SKP_int16_MAX);
            else
                NLSF[root_ix] = Math.min((k << 8) + ffrac, SKP_int16_MAX);
            assert (NLSF[root_ix] >= 0);
            assert (NLSF[root_ix] <= 32767);
            root_ix++;
            if (root_ix >= d) {
                break;
            }
            p = PQ[root_ix & 1];
            if (OVERSAMPLE_COSINE_TABLE)
                xlo = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[(k - 1) >> 1] + ((LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[k >> 1] - LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[(k - 1) >> 1]) >> 1);
            else
                xlo = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[k - 1];
            ylo = (1 - (root_ix & 2)) << 12;
        } else {
            k++;
            xlo = xhi;
            ylo = yhi;
            if (OVERSAMPLE_COSINE_TABLE) {
                if (k > 2 * SigProcFIX.LSF_COS_TAB_SZ_FIX) {
                    i++;
                    if (i > MAX_ITERATIONS_A2NLSF_FIX) {
                        NLSF[0] = (1 << 15) / (d + 1);
                        for (k = 1; k < d; k++) {
                            NLSF[k] = SKP_SMULBB(k + 1, NLSF[0]);
                        }
                        return;
                    }
                    Bwexpander32.SKP_Silk_bwexpander_32(a_Q16, d, 65536 - SKP_SMULBB(66, i));
                    SKP_Silk_A2NLSF_init(a_Q16, P, Q, dd);
                    p = P;
                    xlo = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[0];
                    ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
                    if (ylo < 0) {
                        NLSF[0] = 0;
                        p = Q;
                        ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
                        root_ix = 1;
                    } else {
                        root_ix = 0;
                    }
                    k = 1;
                }
            } else {
                if (k > SigProcFIX.LSF_COS_TAB_SZ_FIX) {
                    i++;
                    if (i > MAX_ITERATIONS_A2NLSF_FIX) {
                        NLSF[0] = (1 << 15) / (d + 1);
                        for (k = 1; k < d; k++) {
                            NLSF[k] = SKP_SMULBB(k + 1, NLSF[0]);
                        }
                        return;
                    }
                    Bwexpander32.SKP_Silk_bwexpander_32(a_Q16, d, 65536 - SKP_SMULBB(66, i));
                    SKP_Silk_A2NLSF_init(a_Q16, P, Q, dd);
                    p = P;
                    xlo = LSFCosTable.SKP_Silk_LSFCosTab_FIX_Q12[0];
                    ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
                    if (ylo < 0) {
                        NLSF[0] = 0;
                        p = Q;
                        ylo = SKP_Silk_A2NLSF_eval_poly(p, xlo, dd);
                        root_ix = 1;
                    } else {
                        root_ix = 0;
                    }
                    k = 1;
                }
            }
        }
    }
}

Output:
             ylo = yhi;
-            if (OVERSAMPLE_COSINE_TABLE) {
-                if (k > 2 * SigProcFIX.LSF_COS_TAB_SZ_FIX) {
-                    i++;
-                    if (i > MAX_ITERATIONS_A2NLSF_FIX) {
-                        NLSF[0] = (1 << 15) / (d + 1);
-                        for (k = 1; k < d; k++) {
-                            NLSF[k] = SKP_SMULBB(k + 1, NLSF[0]);
-                        }
-                        return;
+            boolean b;
+            if (OVERSAMPLE_COSINE_TABLE)
+                b = (k > 2 * SigProcFIX.LSF_COS_TAB_SZ_FIX);
+            else
+                b = (k > SigProcFIX.LSF_COS_TAB_SZ_FIX);
+            if (b) {
+                i++;
+                if (i > MAX_ITERATIONS_A2NLSF_FIX) {
+                    NLSF[0] = (1 << 15) / (d + 1);
+                    for (k = 1; k < d; k++) {
+                        NLSF[k] = SKP_SMULBB(k + 1, NLSF[0]);
                     }


Input:
protected void validateConnector() {
    if (connector.getPolicies() == null) {
        addActionError("String_Node_Str");
    } else {
        for (Map.Entry<String, Policy> entry : getPolicyMap().entrySet()) {
            String policyId = entry.getKey();
            Policy policy = entry.getValue();
            List<String> options = policy.getOptions();
            if (!connector.getPolicies().containsKey(policyId)) {
                addActionError("String_Node_Str" + policyId + "String_Node_Str");
                continue;
            }
            Map<String, Object> properties = connector.getProperties();
            for (String key : properties.keySet()) {
                Object value = properties.get(key);
                if (value.getClass().isArray()) {
                    String[] arr = (String[]) value;
                    properties.put(key, arr[0]);
                }
            }
            Object o = connector.getPolicies().get(policyId);
            String value;
            if (o.getClass().isArray()) {
                String[] arr = (String[]) o;
                value = arr[0];
            } else {
                value = (String) o;
            }
            connector.getPolicies().put(policyId, value);
            if (StringUtils.isBlank(value)) {
                addActionError("String_Node_Str" + policyId + "String_Node_Str");
                continue;
            }
            if (!options.contains(value)) {
                addActionError("String_Node_Str" + value + "String_Node_Str" + policyId + "String_Node_Str" + options);
                continue;
            }
        }
    }
}

Output:
             Map<String, Object> properties = connector.getProperties();
-            for (String key : properties.keySet()) {
-                Object value = properties.get(key);
+            for (Map.Entry<String, Object> entry2 : properties.entrySet()) {
+                Object value = entry2.getValue();
                 if (value.getClass().isArray()) {


Input:
public static ApplicationInfoBean convertApplicationToApplicationInstanceBean(Application application) {
    if (application == null) {
        return null;
    }
    ApplicationInfoBean applicationBean = new ApplicationInfoBean();
    applicationBean.setId(application.getId());
    applicationBean.setName(application.getName());
    applicationBean.setStatus(application.getStatus().name());
    applicationBean.setDescription(application.getDescription());
    applicationBean.setTenantDomain(application.getTenantDomain());
    applicationBean.setTenantAdminUsername(application.getTenantAdminUserName());
    applicationBean.setApplicationInstances(convertApplicationInstancesToApplicationInstances(application));
    return applicationBean;
}

Output:
     ApplicationInfoBean applicationBean = new ApplicationInfoBean();
-    applicationBean.setId(application.getId());
+    applicationBean.setId(application.getUniqueIdentifier());
     applicationBean.setName(application.getName());


Input:
public boolean onTouchEvent(MotionEvent event) {
    if (isEnabled()) {
        isLastTouch = true;
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            changeBackgroundColor((check) ? makePressColor() : Color.parseColor("String_Node_Str"));
        } else if (event.getAction() == MotionEvent.ACTION_UP) {
            changeBackgroundColor(getResources().getColor(android.R.color.transparent));
            press = false;
            if ((event.getX() <= getWidth() && event.getX() >= 0) && (event.getY() <= getHeight() && event.getY() >= 0)) {
                isLastTouch = false;
                check = !check;
                if (onCheckListener != null)
                    onCheckListener.onCheck(check);
                if (check) {
                    step = 0;
                }
                if (check)
                    checkView.changeBackground();
            }
        }
    }
    return true;
}

Output:
         if (event.getAction() == MotionEvent.ACTION_DOWN) {
-            changeBackgroundColor((check) ? makePressColor() : Color.parseColor("String_Node_Str"));
+            changeBackgroundColor((check) ? makePressColor(70) : Color.parseColor("String_Node_Str"));
         } else if (event.getAction() == MotionEvent.ACTION_UP) {


Input:
private Data createDateData(Object txt, StyleEntry entry, String timeFormat, String dlocale) {
    ULocale dateLocale = getLocale(dlocale);
    timeFormat = ExcelUtil.parse(txt, timeFormat, dateLocale);
    timeFormat = DateTimeUtil.formatDateTime(timeFormat, dateLocale);
    entry.setProperty(StyleConstant.DATE_FORMAT_PROP, timeFormat);
    entry.setProperty(StyleConstant.DATA_TYPE_PROP, SheetData.DATE);
    return createData(txt, entry, SheetData.DATE);
}

Output:
     entry.setProperty(StyleConstant.DATA_TYPE_PROP, SheetData.DATE);
-    return createData(txt, entry, SheetData.DATE);
+    return createData(txt, entry);
 }


Input:
public int getMaxRow() {
    int max = 0;
    for (int i = 0; i < columns.size(); i++) {
        int size = getStartRowId(i);
        max = max >= size ? max : size;
    }
    return max;
}

Output:
 public int getMaxRow() {
-    int max = 0;
-    for (int i = 0; i < columns.size(); i++) {
-        int size = getStartRowId(i);
-        max = max >= size ? max : size;
-    }
-    return max;
+    return maxRowIndex;
 }


Input:
protected String getRelativeRequestURI(Command command) {
    List<String> argumentList = command.getArgumentList();
    if (null == argumentList || argumentList.isEmpty()) {
        throw new ServiceException("String_Node_Str");
    }
    if (StringUtils.isBlank(argumentList.get(0))) {
        throw new ServiceException("String_Node_Str");
    }
    return "String_Node_Str" + urlEncode(argumentList.get(0));
}

Output:
     }
-    return "String_Node_Str" + urlEncode(argumentList.get(0));
+    return "String_Node_Str" + argumentList.get(0);
 }


Input:
public void maintainOptionMenu() {
    DataSet data = controller.getCurrentDataSet();
    closeDataSetMenuItem.setEnabled(true);
    saveMenuItem.setEnabled(true);
    if (data.countSelection() == 0)
        selectionMenuItem.setEnabled(false);
    else
        selectionMenuItem.setEnabled(true);
    if (data.colorBrush)
        colorsMenuItem.setEnabled(true);
    else
        colorsMenuItem.setEnabled(false);
    boolean mode = DragBox.extSelMode;
    orSelectionCheckMenuItem.setSelected(mode);
    andSelectionCheckMenuItem.setSelected(!mode);
}

Output:
     closeDataSetMenuItem.setEnabled(true);
-    saveMenuItem.setEnabled(true);
+    saveAction.setEnabled(true);
     if (data.countSelection() == 0)


Input:
public void onWailaEntityDescription(Entity entity, List<String> tooltip, IWailaEntityAccessor accessor) {
    if (entity instanceof EntityLiving) {
        String ench = StatCollector.translateToLocal("String_Node_Str") + "String_Node_Str";
        EntityLiving living = (EntityLiving) entity;
        for (int i = 0; i < 5; i++) {
            ItemStack stack = living.getEquipmentInSlot(i);
            if (stack != null) {
                tooltip.add(StatCollector.translateToLocal("String_Node_Str" + itemTypes[i]) + "String_Node_Str" + stack.getDisplayName());
                Enchantment[] enchantments = Utilities.getEnchantmentsFromStack(stack, false);
                if (accessor.getPlayer().isSneaking()) {
                    for (int x = 0; x < enchantments.length; x++) {
                        String name = StatCollector.translateToLocal(enchantments[x].getName());
                        if (!ench.contains(name))
                            ench = ench + name + "String_Node_Str";
                    }
                }
            }
        }
        if (accessor.getPlayer().isSneaking()) {
            if (ench.equals("String_Node_Str"))
                tooltip.add(StatCollector.translateToLocal("String_Node_Str"));
            else {
                ench = ench.substring(0, ench.length() - 2);
                Utilities.wrapStringToList(ench, 50, false, tooltip);
            }
        }
    }
}

Output:
         if (accessor.getPlayer().isSneaking()) {
-            if (ench.equals("String_Node_Str"))
-                tooltip.add(StatCollector.translateToLocal("String_Node_Str"));
-            else {
+            if (!ench.equals("String_Node_Str")) {
                 ench = ench.substring(0, ench.length() - 2);


Input:
public void init(FMLInitializationEvent evt) {
    NetworkRegistry.INSTANCE.registerGuiHandler(instance, new BuildersGuiHandler());
    ISchematicRegistry schemes = BuilderAPI.schematicRegistry;
    schemes.registerSchematicBlock(Blocks.air, SchematicAir.class);
    schemes.registerSchematicBlock(Blocks.snow, SchematicIgnore.class);
    schemes.registerSchematicBlock(Blocks.tallgrass, SchematicIgnore.class);
    schemes.registerSchematicBlock(Blocks.double_plant, SchematicIgnore.class);
    schemes.registerSchematicBlock(Blocks.ice, SchematicIgnore.class);
    schemes.registerSchematicBlock(Blocks.piston_head, SchematicIgnore.class);
    schemes.registerSchematicBlock(Blocks.dirt, SchematicDirt.class);
    schemes.registerSchematicBlock(Blocks.grass, SchematicDirt.class);
    schemes.registerSchematicBlock(Blocks.cactus, SchematicCactus.class);
    schemes.registerSchematicBlock(Blocks.farmland, SchematicFarmland.class);
    schemes.registerSchematicBlock(Blocks.wheat, SchematicSeeds.class, Items.wheat_seeds);
    schemes.registerSchematicBlock(Blocks.pumpkin_stem, SchematicSeeds.class, Items.pumpkin_seeds);
    schemes.registerSchematicBlock(Blocks.melon_stem, SchematicSeeds.class, Items.melon_seeds);
    schemes.registerSchematicBlock(Blocks.nether_wart, SchematicSeeds.class, Items.nether_wart);
    schemes.registerSchematicBlock(Blocks.tripwire, SchematicBlockFloored.class);
    schemes.registerSchematicBlock(Blocks.tripwire_hook, SchematicTripWireHook.class);
    schemes.registerSchematicBlock(Blocks.skull, SchematicSkull.class);
    schemes.registerSchematicBlock(Blocks.ladder, SchematicRotateMetaSupported.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.fence_gate, SchematicRotateMeta.class, new int[] { 0, 1, 2, 3 }, true);
    schemes.registerSchematicBlock(Blocks.log, SchematicRotateMeta.class, new int[] { 8, 4, 8, 4 }, true);
    schemes.registerSchematicBlock(Blocks.log2, SchematicRotateMeta.class, new int[] { 8, 4, 8, 4 }, true);
    schemes.registerSchematicBlock(Blocks.hay_block, SchematicRotateMeta.class, new int[] { 8, 4, 8, 4 }, true);
    schemes.registerSchematicBlock(Blocks.quartz_block, SchematicRotateMeta.class, new int[] { 4, 3, 4, 3 }, true);
    schemes.registerSchematicBlock(Blocks.hopper, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.anvil, SchematicRotateMeta.class, new int[] { 0, 1, 2, 3 }, true);
    schemes.registerSchematicBlock(Blocks.furnace, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.lit_furnace, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.chest, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.trapped_chest, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.dispenser, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.dropper, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(Blocks.ender_chest, SchematicEnderChest.class);
    schemes.registerSchematicBlock(Blocks.vine, SchematicRotateMeta.class, new int[] { 1, 4, 8, 2 }, false);
    schemes.registerSchematicBlock(Blocks.trapdoor, SchematicRotateMeta.class, new int[] { 0, 1, 2, 3 }, false);
    schemes.registerSchematicBlock(Blocks.stone, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.coal_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.lapis_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.diamond_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.redstone_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.lit_redstone_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.emerald_ore, SchematicStone.class);
    schemes.registerSchematicBlock(Blocks.monster_egg, SchematicSilverfish.class);
    schemes.registerSchematicBlock(Blocks.gravel, SchematicGravel.class);
    schemes.registerSchematicBlock(Blocks.redstone_wire, SchematicRedstoneWire.class, new ItemStack(Items.redstone));
    schemes.registerSchematicBlock(Blocks.cake, SchematicCustomStack.class, new ItemStack(Items.cake));
    schemes.registerSchematicBlock(Blocks.glowstone, SchematicCustomStack.class, new ItemStack(Blocks.glowstone));
    schemes.registerSchematicBlock(Blocks.powered_repeater, SchematicRedstoneDiode.class, Items.repeater);
    schemes.registerSchematicBlock(Blocks.unpowered_repeater, SchematicRedstoneDiode.class, Items.repeater);
    schemes.registerSchematicBlock(Blocks.powered_comparator, SchematicRedstoneDiode.class, Items.comparator);
    schemes.registerSchematicBlock(Blocks.unpowered_comparator, SchematicRedstoneDiode.class, Items.comparator);
    schemes.registerSchematicBlock(Blocks.redstone_lamp, SchematicRedstoneLamp.class);
    schemes.registerSchematicBlock(Blocks.lit_redstone_lamp, SchematicRedstoneLamp.class);
    schemes.registerSchematicBlock(Blocks.glass_pane, SchematicGlassPane.class);
    schemes.registerSchematicBlock(Blocks.stained_glass_pane, SchematicGlassPane.class);
    schemes.registerSchematicBlock(Blocks.piston, SchematicPiston.class);
    schemes.registerSchematicBlock(Blocks.piston_extension, SchematicPiston.class);
    schemes.registerSchematicBlock(Blocks.sticky_piston, SchematicPiston.class);
    schemes.registerSchematicBlock(Blocks.lit_pumpkin, SchematicPumpkin.class);
    schemes.registerSchematicBlock(Blocks.wooden_door, SchematicDoor.class, new ItemStack(Items.wooden_door));
    schemes.registerSchematicBlock(Blocks.iron_door, SchematicDoor.class, new ItemStack(Items.iron_door));
    schemes.registerSchematicBlock(Blocks.bed, SchematicBed.class);
    schemes.registerSchematicBlock(Blocks.wall_sign, SchematicSign.class, true);
    schemes.registerSchematicBlock(Blocks.standing_sign, SchematicSign.class, false);
    schemes.registerSchematicBlock(Blocks.portal, SchematicPortal.class);
    schemes.registerSchematicBlock(Blocks.rail, SchematicRail.class);
    schemes.registerSchematicBlock(Blocks.activator_rail, SchematicRail.class);
    schemes.registerSchematicBlock(Blocks.detector_rail, SchematicRail.class);
    schemes.registerSchematicBlock(Blocks.golden_rail, SchematicRail.class);
    schemes.registerSchematicBlock(Blocks.fire, SchematicFire.class);
    schemes.registerSchematicBlock(Blocks.bedrock, SchematicBlockCreative.class);
    schemes.registerSchematicBlock(Blocks.mob_spawner, SchematicTileCreative.class);
    schemes.registerSchematicEntity(EntityMinecartEmpty.class, SchematicMinecart.class, Items.minecart);
    schemes.registerSchematicEntity(EntityMinecartFurnace.class, SchematicMinecart.class, Items.furnace_minecart);
    schemes.registerSchematicEntity(EntityMinecartTNT.class, SchematicMinecart.class, Items.tnt_minecart);
    schemes.registerSchematicEntity(EntityMinecartChest.class, SchematicMinecart.class, Items.chest_minecart);
    schemes.registerSchematicEntity(EntityMinecartHopper.class, SchematicMinecart.class, Items.hopper_minecart);
    schemes.registerSchematicEntity(EntityPainting.class, SchematicHanging.class, Items.painting);
    schemes.registerSchematicEntity(EntityItemFrame.class, SchematicHanging.class, Items.item_frame);
    schemes.registerSchematicBlock(architectBlock, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    schemes.registerSchematicBlock(builderBlock, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
    if (constructionMarkerBlock != null) {
        schemes.registerSchematicBlock(constructionMarkerBlock, SchematicIgnore.class);
    }
    schemes.registerSchematicBlock(frameBlock, SchematicFree.class);
    SchematicFactory.registerSchematicFactory(SchematicBlock.class, new SchematicFactoryBlock());
    SchematicFactory.registerSchematicFactory(SchematicMask.class, new SchematicFactoryMask());
    SchematicFactory.registerSchematicFactory(SchematicEntity.class, new SchematicFactoryEntity());
    LibraryAPI.registerHandler(new LibraryBlueprintTypeHandler(false));
    LibraryAPI.registerHandler(new LibraryBlueprintTypeHandler(true));
    LibraryAPI.registerHandler(new LibraryBookTypeHandler());
    BlueprintDeployer.instance = new RealBlueprintDeployer();
    architectAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 11, 2, BuildCraftBuilders.architectBlock, BuildCraftCore.goldGearAchievement));
    builderAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 13, 2, BuildCraftBuilders.builderBlock, architectAchievement));
    blueprintAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 11, 4, BuildCraftBuilders.blueprintItem, architectAchievement));
    templateAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 13, 4, BuildCraftBuilders.templateItem, blueprintAchievement));
    libraryAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 15, 2, BuildCraftBuilders.libraryBlock, builderAchievement));
    chunkDestroyerAchievement = BuildCraftCore.achievementManager.registerAchievement(new Achievement("String_Node_Str", "String_Node_Str", 9, 2, quarryBlock, BuildCraftCore.diamondGearAchievement));
    if (BuildCraftCore.loadDefaultRecipes) {
        loadRecipes();
    }
    BuilderProxy.proxy.registerBlockRenderers();
}

Output:
     schemes.registerSchematicBlock(architectBlock, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
-    schemes.registerSchematicBlock(builderBlock, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
+    schemes.registerSchematicBlock(builderBlock, SchematicBuilderLike.class);
+    schemes.registerSchematicBlock(fillerBlock, SchematicBuilderLike.class);
+    schemes.registerSchematicBlock(libraryBlock, SchematicRotateMeta.class, new int[] { 2, 5, 3, 4 }, true);
+    schemes.registerSchematicBlock(quarryBlock, SchematicBuilderLike.class);
     if (constructionMarkerBlock != null) {


Input:
public static List<String> getSupportedProtocols(PmsConfiguration configuration) {
    ArrayList<String> protocols = new ArrayList<>();
    String output = ProcessUtil.run(configuration.getFfmpegPath(), "String_Node_Str");
    boolean add = false;
    boolean old = false;
    for (String line : output.split("String_Node_Str")) {
        if (line.equals("String_Node_Str")) {
            add = true;
        } else if (line.equals("String_Node_Str")) {
            break;
        } else if (add) {
            protocols.add(line);
        } else if (line.startsWith("String_Node_Str")) {
            old = true;
        } else if (old && line.startsWith("String_Node_Str")) {
            protocols.add(line.split("String_Node_Str")[1]);
        }
    }
    return protocols;
}

Output:
         } else if (add) {
-            protocols.add(line);
+            protocols.add(line.trim());
         } else if (line.startsWith("String_Node_Str")) {


Input:
public ReconQueryResult querySource(int pageSize, String pagingCookie) throws SynchronizationException {
    return query(sourceQuery.get("String_Node_Str").asString(), sourceQuery, reconContext, ((Collection<String>) Collections.synchronizedList(new ArrayList<String>())), true, QuerySide.SOURCE, pageSize, pagingCookie);
}

Output:
 public ReconQueryResult querySource(int pageSize, String pagingCookie) throws SynchronizationException {
-    return query(sourceQuery.get("String_Node_Str").asString(), sourceQuery, reconContext, ((Collection<String>) Collections.synchronizedList(new ArrayList<String>())), true, QuerySide.SOURCE, pageSize, pagingCookie);
+    return query(sourceQuery.get("String_Node_Str").asString(), sourceQuery, reconContext, Collections.synchronizedSet(new LinkedHashSet<String>()), true, QuerySide.SOURCE, pageSize, pagingCookie);
 }


Input:
public void testWorkflowForkFailure() throws Exception {
    Assert.assertEquals(200, deploy(WorkflowFailureInForkApp.class).getStatusLine().getStatusCode());
    Id.Application appId = Id.Application.from(Id.Namespace.DEFAULT, WorkflowFailureInForkApp.NAME);
    Id.Workflow workflowId = Id.Workflow.from(appId, WorkflowFailureInForkApp.WorkflowWithFailureInFork.NAME);
    Id.Program firstMRId = Id.Program.from(appId, ProgramType.MAPREDUCE, WorkflowFailureInForkApp.FIRST_MAPREDUCE_NAME);
    Id.Program secondMRId = Id.Program.from(appId, ProgramType.MAPREDUCE, WorkflowFailureInForkApp.SECOND_MAPREDUCE_NAME);
    String outputPath = new File(tmpFolder.newFolder(), "String_Node_Str").getAbsolutePath();
    File fileToSync = new File(tmpFolder.newFolder() + "String_Node_Str");
    File fileToWait = new File(tmpFolder.newFolder() + "String_Node_Str");
    startProgram(workflowId, ImmutableMap.of("String_Node_Str", createInput("String_Node_Str"), "String_Node_Str", outputPath, "String_Node_Str", fileToSync.getAbsolutePath(), "String_Node_Str", fileToWait.getAbsolutePath(), "String_Node_Str" + WorkflowFailureInForkApp.SECOND_MAPREDUCE_NAME + "String_Node_Str", "String_Node_Str"));
    waitState(workflowId, ProgramStatus.RUNNING.name());
    waitState(workflowId, ProgramStatus.STOPPED.name());
    verifyProgramRuns(workflowId, "String_Node_Str");
    List<RunRecord> mapReduceProgramRuns = getProgramRuns(firstMRId, ProgramRunStatus.KILLED.name());
    Assert.assertEquals(1, mapReduceProgramRuns.size());
    mapReduceProgramRuns = getProgramRuns(secondMRId, ProgramRunStatus.FAILED.name());
    Assert.assertEquals(1, mapReduceProgramRuns.size());
}

Output:
     waitState(workflowId, ProgramStatus.STOPPED.name());
-    verifyProgramRuns(workflowId, "String_Node_Str");
-    List<RunRecord> mapReduceProgramRuns = getProgramRuns(firstMRId, ProgramRunStatus.KILLED.name());
+    verifyProgramRuns(workflowId, ProgramRunStatus.FAILED);
+    List<RunRecord> mapReduceProgramRuns = getProgramRuns(firstMRId, ProgramRunStatus.KILLED);
     Assert.assertEquals(1, mapReduceProgramRuns.size());


Input:
public void stepUp() {
    TreeItem item;
    TreeItem[] items = viewer.getTree().getSelection();
    for (int i = 0; i < items.length; i++) {
        item = items[i];
        XSDConcreteComponent component = (XSDConcreteComponent) item.getData();
        if (!(component instanceof XSDParticle))
            continue;
        else {
            XSDParticle particle = (XSDParticle) component;
            if (particle.getContainer() instanceof XSDModelGroup) {
                XSDModelGroup mp = (XSDModelGroup) particle.getContainer();
                int index = mp.getContents().indexOf(particle);
                if (index > 0) {
                    mp.getContents().move(index - 1, index);
                    this.refresh();
                }
            }
        }
    }
    this.markDirty();
}

Output:
     }
-    this.markDirty();
+    this.markDirtyWithoutCommit();
 }


Input:
private String getFirstNumb() {
    String[] strA = expresssionToSelection().split(regexAnyValidOperator);
    return strA[0];
}

Output:
 private String getFirstNumb() {
-    String[] strA = expresssionToSelection().split(regexAnyValidOperator);
-    return strA[0];
+    return getFirstNumb(expresssionToSelection());
 }


Input:
private void onContainerAdded(BalanceableContainer<?> newContainer) {
    subscribe(newContainer, Startable.SERVICE_UP, eventHandler);
    if (!(newContainer instanceof Startable) || newContainer.getAttribute(Startable.SERVICE_UP)) {
        onContainerUp(newContainer);
    }
}

Output:
     subscribe(newContainer, Startable.SERVICE_UP, eventHandler);
-    if (!(newContainer instanceof Startable) || newContainer.getAttribute(Startable.SERVICE_UP)) {
+    if (!(newContainer instanceof Startable) || Boolean.TRUE.equals(newContainer.getAttribute(Startable.SERVICE_UP))) {
         onContainerUp(newContainer);


Input:
protected soot.Local handlePrivateFieldAssignSet(polyglot.ast.Assign assign) {
    if (assign.left() instanceof soot.javaToJimple.jj.ast.JjAccessField_c) {
        soot.javaToJimple.jj.ast.JjAccessField_c accessField = (soot.javaToJimple.jj.ast.JjAccessField_c) assign.left();
        if (assign.operator() == polyglot.ast.Assign.ASSIGN) {
            soot.Value right = base().getSimpleAssignRightLocal(assign);
            return base().handlePrivateFieldSet(accessField, right);
        } else {
            soot.Local baseLocal = (soot.Local) base().getBaseLocal(accessField.field().target());
            soot.Local leftLocal = handleCall(accessField.field(), accessField.getMeth(), null, baseLocal);
            soot.Value right = base().getAssignRightLocal(assign, leftLocal);
            return handleFieldSet(accessField, right, baseLocal);
        }
    } else {
        return ext().handlePrivateFieldAssignSet(assign);
    }
}

Output:
             soot.Value right = base().getSimpleAssignRightLocal(assign);
-            return base().handlePrivateFieldSet(accessField, right);
+            return base().handlePrivateFieldSet(accessField, right, baseLocal);
         } else {


Input:
private boolean updateNotification(String description) {
    ImageView notificationIcon = (ImageView) mPeekView.findViewById(NotificationPeek.NOTIFICATION_ICON_ID);
    TextView notificationTextView = (TextView) mPeekView.findViewById(NotificationPeek.NOTIFICATION_TEXT_ID);
    int currentNotificationIdex = getCurrentNotificationIndex(mNotificationsContainer, description);
    mNotificationsContainer.removeViewAt(currentNotificationIdex);
    int nextNotificationIndex = mNotificationsContainer.getChildCount() - 1;
    if (nextNotificationIndex >= 0) {
        StatusBarNotification nextNotification = (StatusBarNotification) mNotificationsContainer.getChildAt(nextNotificationIndex).getTag();
        if (nextNotification.getNotification().largeIcon != null) {
            notificationIcon.setImageDrawable(NotificationPeekViewUtils.getRoundedShape(notificationIcon, nextNotification.getNotification().largeIcon));
        } else {
            notificationIcon.setImageDrawable(NotificationPeekViewUtils.getIconFromResource(this, nextNotification));
        }
        notificationTextView.setText(NotificationPeekViewUtils.getNotificationDisplayText(this, nextNotification));
        mNotificationView.setTranslationX(0);
        mNotificationView.animate().alpha(1f).start();
        mNotificationView.setTag(nextNotification);
        if (nextNotification.getNotification().contentIntent != null) {
            final View.OnClickListener listener = new NotificationClicker(nextNotification, mPeek);
            notificationIcon.setOnClickListener(listener);
        }
        if (nextNotificationIndex == 0) {
            mNotificationsContainer.getChildAt(nextNotificationIndex).setVisibility(View.GONE);
        } else {
            mNotificationsContainer.getChildAt(nextNotificationIndex).setAlpha(1);
        }
        mPeek.updateNotificationTextAlpha(1);
        return true;
    }
    return false;
}

Output:
         if (nextNotification.getNotification().largeIcon != null) {
-            notificationIcon.setImageDrawable(NotificationPeekViewUtils.getRoundedShape(notificationIcon, nextNotification.getNotification().largeIcon));
+            notificationIcon.setImageDrawable(NotificationPeekViewUtils.getRoundedShape(getResources(), nextNotification.getNotification().largeIcon));
         } else {


Input:
private static void prepareScriptExpression(ScriptContext cx, IBaseExpression expr1) throws DataException {
    try {
        if (expr1 == null)
            return;
        if (expr1 instanceof IScriptExpression) {
            String exprText = ((IScriptExpression) expr1).getText();
            if (expr1.getHandle() == null && !((IScriptExpression) expr1).isConstant())
                expr1.setHandle(new OLAPExpressionHandler(cx.compile(expr1.getScriptId(), null, 0, exprText)));
        } else if (expr1 instanceof IExpressionCollection) {
            Object[] exprs = ((IExpressionCollection) expr1).getExpressions().toArray();
            for (int i = 0; i < exprs.length; i++) {
                prepareScriptExpression(cx, (IBaseExpression) exprs[i]);
            }
        }
    } catch (BirtException e) {
        throw DataException.wrap(e);
    }
}

Output:
             String exprText = ((IScriptExpression) expr1).getText();
-            if (expr1.getHandle() == null && !((IScriptExpression) expr1).isConstant())
+            if (expr1.getHandle() == null && !(BaseExpression.constantId.equals(expr1.getScriptId())))
                 expr1.setHandle(new OLAPExpressionHandler(cx.compile(expr1.getScriptId(), null, 0, exprText)));


Input:
public void cdata(String value) {
    try {
        if (isStartElementOpen) {
            openAndCloseStartElement();
            isStartElementOpen = false;
        }
        xmlEventWriter.add(xmlEventFactory.createCData(value));
    } catch (Exception e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
         }
-        xmlEventWriter.add(xmlEventFactory.createCData(value));
+        for (String part : MarshalRecord.splitCData(value)) {
+            xmlEventWriter.add(xmlEventFactory.createCData(part));
+        }
     } catch (Exception e) {


Input:
public SSAAbstractInvokeInstruction addDirectCall(int function, int[] params, CallSiteReference site) {
    CallSiteReference newSite = new JSCallSiteReference(statements.size());
    JavaScriptInvoke s = new JavaScriptInvoke(function, nextLocal++, params, nextLocal++, newSite);
    statements.add(s);
    return s;
}

Output:
     CallSiteReference newSite = new JSCallSiteReference(statements.size());
-    JavaScriptInvoke s = new JavaScriptInvoke(function, nextLocal++, params, nextLocal++, newSite);
+    JavaScriptInvoke s = new JavaScriptInvoke(statements.size(), function, nextLocal++, params, nextLocal++, newSite);
     statements.add(s);


Input:
public static ArrayList<ItemStack> getPlantFruits(ItemSeeds seed, World world, int x, int y, int z, int gain, int meta) {
    int nr = (int) (Math.ceil((gain + 0.00) / 3));
    Block plant = getPlant(seed);
    ArrayList<ItemStack> items = new ArrayList<ItemStack>();
    if (plant == Blocks.nether_wart) {
        items.add(new ItemStack(seed, 1, 0));
    } else if (plant instanceof BlockModPlant) {
        items.addAll(((BlockModPlant) plant).getFruit(nr, world.rand));
    } else if (ModIntegration.LoadedMods.natura && getPlantDomain(seed).equalsIgnoreCase("String_Node_Str")) {
        items.add(new ItemStack(NContent.plantItem, nr, meta * 3));
    } else if (ModIntegration.LoadedMods.harvestcraft && getPlantDomain(seed).equalsIgnoreCase("String_Node_Str")) {
        items.add(new ItemStack(getPlant(seed).getItemDropped(7, new Random(), 0), nr));
    } else if (ModIntegration.LoadedMods.chococraft && seed instanceof ItemGysahlSeeds) {
        items.add(ChococraftHelper.getFruit(gain, nr));
    } else {
        int harvestMeta = 7;
        if (ModIntegration.LoadedMods.plantMegaPack && getPlantDomain(seed).equalsIgnoreCase("String_Node_Str")) {
            harvestMeta = PlantMegaPackHelper.getTextureIndex(seed, harvestMeta);
        }
        ArrayList<ItemStack> defaultDrops = plant.getDrops(world, x, y, z, harvestMeta, 0);
        for (ItemStack drop : defaultDrops) {
            if (!(drop.getItem() instanceof ItemSeeds) && drop.getItem() != null) {
                boolean add = true;
                for (ItemStack item : items) {
                    if (item.getItem() == drop.getItem() && item.getItemDamage() == drop.getItemDamage()) {
                        add = false;
                    }
                }
                if (add) {
                    items.add(new ItemStack(drop.getItem(), nr, drop.getItemDamage()));
                }
            }
        }
    }
    return items;
}

Output:
     if (plant == Blocks.nether_wart) {
-        items.add(new ItemStack(seed, 1, 0));
+        LogHelper.debug("String_Node_Str");
+        items.add(new ItemStack(seed, nr, 0));
     } else if (plant instanceof BlockModPlant) {


Input:
public void handleCommand(ChannelUID channelUID, Command command) {
    String channelId = channelUID.getIdWithoutGroup();
    logger.debug("String_Node_Str", command, channelId);
    FritzahaWebInterface fritzBox = getWebInterface();
    if (fritzBox == null) {
        return;
    }
    String ain = getThing().getConfiguration().get(THING_AIN).toString();
    switch(channelId) {
        case CHANNEL_MODE:
        case CHANNEL_LOCKED:
        case CHANNEL_DEVICE_LOCKED:
        case CHANNEL_TEMP:
        case CHANNEL_ENERGY:
        case CHANNEL_POWER:
        case CHANNEL_ACTUALTEMP:
        case CHANNEL_ECOTEMP:
        case CHANNEL_COMFORTTEMP:
        case CHANNEL_NEXTCHANGE:
        case CHANNEL_NEXTTEMP:
        case CHANNEL_BATTERY:
            logger.debug("String_Node_Str", channelId, command);
            break;
        case CHANNEL_SWITCH:
            if (command instanceof OnOffType) {
                state.getSwitch().setState(OnOffType.ON.equals(command) ? SwitchModel.ON : SwitchModel.OFF);
                fritzBox.setSwitch(ain, OnOffType.ON.equals(command));
            } else {
                logger.warn("String_Node_Str", command, CHANNEL_SWITCH);
            }
            break;
        case CHANNEL_SETTEMP:
            if (command instanceof DecimalType) {
                BigDecimal temperature = new BigDecimal(command.toString());
                state.getHkr().setTsoll(temperature);
                fritzBox.setSetTemp(ain, HeatingModel.fromCelsius(temperature));
                updateState(CHANNEL_RADIATOR_MODE, new StringType(state.getHkr().getRadiatorMode()));
            } else if (command instanceof IncreaseDecreaseType) {
                BigDecimal temperature = state.getHkr().getTsoll();
                if (IncreaseDecreaseType.INCREASE.equals(command)) {
                    temperature.add(BigDecimal.ONE);
                } else {
                    temperature.subtract(BigDecimal.ONE);
                }
                state.getHkr().setTsoll(temperature);
                fritzBox.setSetTemp(ain, temperature);
                updateState(CHANNEL_RADIATOR_MODE, new StringType(state.getHkr().getRadiatorMode()));
            } else if (command instanceof OnOffType) {
                BigDecimal temperature = OnOffType.ON.equals(command) ? HeatingModel.TEMP_FRITZ_ON : HeatingModel.TEMP_FRITZ_OFF;
                state.getHkr().setTsoll(temperature);
                fritzBox.setSetTemp(ain, temperature);
                updateState(CHANNEL_RADIATOR_MODE, new StringType(state.getHkr().getRadiatorMode()));
            } else {
                logger.warn("String_Node_Str", command, CHANNEL_SETTEMP);
            }
            break;
        case CHANNEL_RADIATOR_MODE:
            if (command instanceof StringType) {
                String commandString = command.toString();
                if (MODE_ON.equals(commandString)) {
                    state.getHkr().setTsoll(HeatingModel.TEMP_FRITZ_ON);
                    fritzBox.setSetTemp(ain, HeatingModel.TEMP_FRITZ_ON);
                    updateState(CHANNEL_SETTEMP, new DecimalType(HeatingModel.toCelsius(HeatingModel.TEMP_FRITZ_ON)));
                } else if (MODE_OFF.equals(commandString)) {
                    state.getHkr().setTsoll(HeatingModel.TEMP_FRITZ_OFF);
                    fritzBox.setSetTemp(ain, HeatingModel.TEMP_FRITZ_OFF);
                    updateState(CHANNEL_SETTEMP, new DecimalType(HeatingModel.toCelsius(HeatingModel.TEMP_FRITZ_OFF)));
                } else if (MODE_COMFORT.equals(commandString)) {
                    BigDecimal comfort_temp = state.getHkr().getKomfort();
                    state.getHkr().setTsoll(comfort_temp);
                    fritzBox.setSetTemp(ain, comfort_temp);
                    updateState(CHANNEL_SETTEMP, new DecimalType(HeatingModel.toCelsius(comfort_temp)));
                } else if (MODE_ECO.equals(commandString)) {
                    BigDecimal eco_temp = state.getHkr().getAbsenk();
                    state.getHkr().setTsoll(eco_temp);
                    fritzBox.setSetTemp(ain, eco_temp);
                    updateState(CHANNEL_SETTEMP, new DecimalType(HeatingModel.toCelsius(eco_temp)));
                } else if (MODE_BOOST.equals(commandString)) {
                    state.getHkr().setTsoll(HeatingModel.TEMP_FRITZ_MAX);
                    fritzBox.setSetTemp(ain, HeatingModel.TEMP_FRITZ_MAX);
                    updateState(CHANNEL_SETTEMP, new DecimalType(HeatingModel.toCelsius(HeatingModel.TEMP_FRITZ_MAX)));
                } else {
                    logger.warn("String_Node_Str", command, CHANNEL_RADIATOR_MODE);
                }
            }
            break;
        default:
            logger.debug("String_Node_Str", channelId);
            break;
    }
}

Output:
             if (command instanceof DecimalType) {
-                BigDecimal temperature = new BigDecimal(command.toString());
+                BigDecimal temperature = ((DecimalType) command).toBigDecimal();
                 state.getHkr().setTsoll(temperature);


Input:
public WeixinMessageHandler[] getMessageHandlers() throws WeixinException {
    if (this.messageHandlers == null) {
        if (messageHandlerPackages != null) {
            List<Class<?>> messageHandlerClass = new LinkedList<Class<?>>();
            for (String packageName : messageHandlerPackages) {
                messageHandlerClass.addAll(ClassUtil.getClasses(packageName));
            }
            if (beanFactory != null) {
                for (Class<?> clazz : messageHandlerClass) {
                    messageHandlerList.add((WeixinMessageHandler) beanFactory.getBean(clazz));
                }
            } else {
                for (Class<?> clazz : messageHandlerClass) {
                    if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
                        continue;
                    }
                    try {
                        Constructor<?> ctor = clazz.getDeclaredConstructor();
                        ReflectionUtil.makeAccessible(ctor);
                        messageHandlerList.add((WeixinMessageHandler) ctor.newInstance((Object[]) null));
                    } catch (Exception ex) {
                        throw new WeixinException(clazz.getName() + "String_Node_Str", ex);
                    }
                }
            }
        }
        if (messageHandlerList != null && !this.messageHandlerList.isEmpty()) {
            this.messageHandlers = this.messageHandlerList.toArray(new WeixinMessageHandler[this.messageHandlerList.size()]);
        }
    }
    return this.messageHandlers;
}

Output:
                 for (Class<?> clazz : messageHandlerClass) {
-                    messageHandlerList.add((WeixinMessageHandler) beanFactory.getBean(clazz));
+                    messageHandlerList.add(0, (WeixinMessageHandler) beanFactory.getBean(clazz));
                 }


Input:
public <T extends ConfigBeanProxy> NotProcessed changed(TYPE type, Class<T> tClass, T t) {
    if (logger.isLoggable(Level.FINE)) {
        logger.log(Level.FINE, "String_Node_Str", new Object[] { type, tClass, t });
    }
    if (tClass == NetworkListener.class) {
        return processNetworkListener(type, (NetworkListener) t, events);
    } else if (tClass == Http.class) {
        return processProtocol(type, (Protocol) t.getParent(), events);
    } else if (tClass == FileCache.class) {
        return processProtocol(type, (Protocol) t.getParent().getParent(), null);
    } else if (tClass == Ssl.class) {
        return processProtocol(type, (Protocol) t.getParent(), null);
    } else if (tClass == Protocol.class) {
        return processProtocol(type, (Protocol) t, null);
    } else if (tClass == ThreadPool.class) {
        NotProcessed notProcessed = null;
        for (NetworkListener listener : ((ThreadPool) t).findNetworkListeners()) {
            notProcessed = processNetworkListener(type, listener, null);
        }
        return notProcessed;
    } else if (tClass == Transport.class) {
        NotProcessed notProcessed = null;
        for (NetworkListener listener : ((Transport) t).findNetworkListeners()) {
            notProcessed = processNetworkListener(type, listener, null);
        }
        return notProcessed;
    } else if (tClass == VirtualServer.class && !grizzlyService.hasMapperUpdateListener()) {
        return processVirtualServer(type, (VirtualServer) t);
    } else if (tClass == SystemProperty.class) {
        NetworkConfig networkConfig = config.getNetworkConfig();
        if ((networkConfig != null) && ((SystemProperty) t).getName().endsWith("String_Node_Str")) {
            for (NetworkListener listener : networkConfig.getNetworkListeners().getNetworkListener()) {
                if (listener.getPort().equals(((SystemProperty) t).getValue())) {
                    return processNetworkListener(Changed.TYPE.CHANGE, listener, events);
                }
            }
        }
        return null;
    }
    return null;
}

Output:
     }
-    if (tClass == NetworkListener.class) {
+    if (tClass == NetworkListener.class && t instanceof NetworkListener) {
         return processNetworkListener(type, (NetworkListener) t, events);


Input:
public int getValue() throws UninterruptiblePragma {
    return (this.value < LOG_BYTES_IN_ADDRESS) ? 0 : this.value - LOG_BYTES_IN_ADDRESS;
}

Output:
 public int getValue() throws UninterruptiblePragma {
-    return (this.value < LOG_BYTES_IN_ADDRESS) ? 0 : this.value - LOG_BYTES_IN_ADDRESS;
+    return (this.value < LOG_BYTES_IN_ADDRESS) ? 0 : 1 << (this.value - LOG_BYTES_IN_ADDRESS);
 }


Input:
private DispoItemData buildNewItem(DispoItemData destItem, DispoItem sourceItem, boolean isCoverageCopy, OperationReport report, boolean isSameDiscrepancies) throws JSONException {
    boolean isChangesMade = false;
    DispoItemData newItem = initNewItem(destItem, sourceItem);
    JSONArray newAnnotations = newItem.getAnnotationsList();
    JSONArray sourceAnnotations = sourceItem.getAnnotationsList();
    Set<String> destDefaultAnntationLocations = getDefaultAnnotations(newItem);
    for (int i = 0; i < sourceAnnotations.length(); i++) {
        JSONObject annotationJson = sourceAnnotations.getJSONObject(i);
        DispoAnnotationData sourceAnnotation = DispoUtil.jsonObjToDispoAnnotationData(annotationJson);
        String sourceLocation = sourceAnnotation.getLocationRefs();
        if (DispoUtil.isDefaultAnntoation(sourceAnnotation)) {
            if (!destDefaultAnntationLocations.contains(sourceLocation)) {
                report.addMessageForItem(destItem.getName(), "String_Node_Str", sourceAnnotation.getLocationRefs());
            }
        } else if (isCoverageCopy && destDefaultAnntationLocations.contains(sourceLocation)) {
            report.addMessageForItem(destItem.getName(), "String_Node_Str", sourceAnnotation.getLocationRefs());
        } else if (newAnnotations.toString().contains(sourceAnnotation.getGuid())) {
            report.addMessageForItem(destItem.getName(), "String_Node_Str", sourceAnnotation.getLocationRefs(), sourceAnnotation.getGuid());
        } else {
            if (isSameDiscrepancies || isCoverageCopy && isCoveredDiscrepanciesExistInDest(destItem, sourceItem, sourceAnnotation, report)) {
                DispoAnnotationData newAnnotation = sourceAnnotation;
                if (destDefaultAnntationLocations.contains(sourceLocation)) {
                    String locationRefs = sourceAnnotation.getLocationRefs();
                    Integer locationRefAsInt = Integer.valueOf(locationRefs);
                    if (locationRefAsInt > 0) {
                        newAnnotation.setLocationRefs(String.valueOf(locationRefAsInt * -1));
                    }
                    report.addMessageForItem(destItem.getName(), "String_Node_Str", locationRefs);
                }
                connector.connectAnnotation(newAnnotation, newItem.getDiscrepanciesList());
                isChangesMade = true;
                int nextIndex = newAnnotations.length();
                newAnnotation.setIndex(nextIndex);
                newAnnotations.put(nextIndex, DispoUtil.annotationToJsonObj(newAnnotation));
            }
        }
    }
    if (isChangesMade) {
        newItem.setAnnotationsList(newAnnotations);
        String newStatus = connector.getItemStatus(newItem);
        newItem.setStatus(newStatus);
    } else if (isCoverageCopy) {
        newItem = destItem;
        newItem.setGuid(sourceItem.getGuid());
    } else {
        report.addMessageForItem(destItem.getName(), "String_Node_Str");
        newItem = null;
    }
    return newItem;
}

Output:
         String sourceLocation = sourceAnnotation.getLocationRefs();
-        if (DispoUtil.isDefaultAnntoation(sourceAnnotation)) {
+        if (DispoUtil.isDefaultAnntoation(sourceAnnotation) || !Strings.isValid(sourceAnnotation.getResolutionType())) {
             if (!destDefaultAnntationLocations.contains(sourceLocation)) {


Input:
public Response createGraph(InputStream in, HttpHeaders header) throws IOException, StoreException {
    final URI graphURI = getGraphURI();
    final IStore store = getStore();
    final MediaType mt = MediaTypeUtils.toMediaType(header.getMediaType());
    final boolean wasKnown = store.containsGraph(graphURI);
    final IGraphInfo info = store.createOrReplaceGraph(graphURI, in, getBaseURI(graphURI), mt);
    return wasKnown ? noContent() : created(info.getURI());
}

Output:
     final MediaType mt = MediaTypeUtils.toMediaType(header.getMediaType());
-    final boolean wasKnown = store.containsGraph(graphURI);
+    final boolean wasKnown = graphURI == IStore.DEFAULT_GRAPH || store.containsGraph(graphURI);
     final IGraphInfo info = store.createOrReplaceGraph(graphURI, in, getBaseURI(graphURI), mt);


Input:
public void updateDialog(QBDialog dialog, String roomJidId) {
    DatabaseManager.updateDialog(context, dialog, roomJidId);
}

Output:
 public void updateDialog(QBDialog dialog, String roomJidId) {
-    DatabaseManager.updateDialog(context, dialog, roomJidId);
+    DatabaseManager.updateDialog(context, roomJidId, dialog.getLastMessage(), dialog.getLastMessageDateSent());
 }


Input:
private ExportEndpoint findExistingExportEndpoint(ServiceReference serviceReference, ID containerID) {
    for (ExportRegistration eReg : exportedRegistrations) {
        ExportEndpoint exportEndpoint = eReg.getExportEndpoint(serviceReference, containerID);
        if (exportEndpoint != null)
            return exportEndpoint;
    }
    return null;
}

Output:
 private ExportEndpoint findExistingExportEndpoint(ServiceReference serviceReference, ID containerID) {
-    for (ExportRegistration eReg : exportedRegistrations) {
-        ExportEndpoint exportEndpoint = eReg.getExportEndpoint(serviceReference, containerID);
-        if (exportEndpoint != null)
-            return exportEndpoint;
+    for (org.osgi.service.remoteserviceadmin.ExportRegistration eReg : exportedRegistrations) {
+        if (eReg instanceof ExportRegistration) {
+            ExportEndpoint exportEndpoint = ((ExportRegistration) eReg).getExportEndpoint(serviceReference, containerID);
+            if (exportEndpoint != null)
+                return exportEndpoint;
+        }
     }


Input:
public ServerResponse<String> resetPassword(String passwordOld, String passwordNew, User user) {
    int resultCount = userMapper.selectOldPassword(user.getId(), passwordOld);
    if (resultCount == 0) {
        return ServerResponse.createByErorrMessage("String_Node_Str");
    }
    user.setPassword(MD5Util.MD5EncodeUtf8(passwordNew));
    int updateCount = userMapper.updateByPrimaryKeySelective(user);
    if (updateCount > 0) {
        return ServerResponse.createBySuccessMessage("String_Node_Str");
    }
    return ServerResponse.createByErorrMessage("String_Node_Str");
}

Output:
 public ServerResponse<String> resetPassword(String passwordOld, String passwordNew, User user) {
-    int resultCount = userMapper.selectOldPassword(user.getId(), passwordOld);
+    int resultCount = userMapper.selectOldPassword(user.getId(), MD5Util.MD5EncodeUtf8(passwordOld));
     if (resultCount == 0) {


Input:
private Expression[] arithOpExpr(LocalOpcode op, ArrayList<Expression> argExpr) {
    switch(op) {
        case PLUS_INT:
        case PLUS_FLOAT:
        case MINUS_INT:
        case MINUS_FLOAT:
        case MULT_INT:
        case MULT_FLOAT:
        case DIV_FLOAT:
        case POW_FLOAT:
        case EQ_INT:
        case NEQ_INT:
        case LT_INT:
        case LTE_INT:
        case GT_INT:
        case GTE_INT:
        case LT_FLOAT:
        case LTE_FLOAT:
        case GT_FLOAT:
        case GTE_FLOAT:
        case EQ_FLOAT:
        case NEQ_FLOAT:
        case EQ_BOOL:
        case NEQ_BOOL:
        case EQ_STRING:
        case NEQ_STRING:
        case AND:
        case OR:
            assert (argExpr.size() == 2);
            return new Expression[] { argExpr.get(0), arithOpTok(op), argExpr.get(1) };
        case NOT:
        case NEGATE_INT:
        case NEGATE_FLOAT:
            assert (argExpr.size() == 1);
            return new Expression[] { arithOpTok(op), argExpr.get(0) };
        case IS_NAN:
            assert (argExpr.size() == 1);
            return new Expression[] { argExpr.get(0), new Token("String_Node_Str"), argExpr.get(0) };
        case CEIL:
        case FLOOR:
        case ROUND:
        case LOG:
        case EXP:
        case SQRT:
        case ABS_FLOAT:
        case ABS_INT:
            return new Expression[] { arithOpTok(op), new Token("String_Node_Str"), argExpr.get(0), new Token("String_Node_Str") };
        case RANDOM:
            return new Expression[] { arithOpTok(op), new Token("String_Node_Str") };
        case INTTOFLOAT:
            assert (argExpr.size() == 1);
            return new Expression[] { argExpr.get(0) };
        case MAX_FLOAT:
        case MAX_INT:
        case MIN_FLOAT:
        case MIN_INT:
            String fnName;
            if (op == LocalOpcode.MAX_FLOAT || op == LocalOpcode.MAX_INT) {
                fnName = "String_Node_Str";
            } else {
                fnName = "String_Node_Str";
            }
            return new Expression[] { new Token(fnName), new Token("String_Node_Str"), argExpr.get(0), new Token("String_Node_Str"), argExpr.get(1), new Token("String_Node_Str") };
        default:
            throw new ParserRuntimeException("String_Node_Str" + "String_Node_Str" + op.toString());
    }
}

Output:
             assert (argExpr.size() == 1);
-            return new Expression[] { argExpr.get(0) };
+            return new Expression[] { new Token("String_Node_Str"), argExpr.get(0), new Token("String_Node_Str") };
+        case CEIL:
+        case FLOOR:
+        case ROUND:
+            {
+                String fname;
+                assert (argExpr.size() == 1);
+                switch(op) {
+                    case CEIL:
+                        fname = "String_Node_Str";
+                        break;
+                    case FLOOR:
+                        fname = "String_Node_Str";
+                        break;
+                    case ROUND:
+                        fname = "String_Node_Str";
+                        break;
+                    default:
+                        throw new STCRuntimeError("String_Node_Str");
+                }
+                return new Expression[] { new Token("String_Node_Str" + fname + "String_Node_Str"), argExpr.get(0), new Token("String_Node_Str") };
+            }
         case MAX_FLOAT:


Input:
public void update() {
    FBO sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
    sceneOpaque.attachDepthBufferTo(dynamicFBOsManager.get(REFRACTIVE_REFLECTIVE_URN));
}

Output:
 public void update() {
-    FBO sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
+    FBO sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.READ_ONLY_GBUFFER.getName());
     sceneOpaque.attachDepthBufferTo(dynamicFBOsManager.get(REFRACTIVE_REFLECTIVE_URN));


Input:
public void testBasics() throws IOException {
    JobListRequest jobRequest = new JobListRequest();
    Assert.assertNotNull(jobSchedulerController.list(jobRequest));
    JobInstance job = null;
    try {
        JobBuildRequest jobBuildRequest = new JobBuildRequest();
        jobBuildRequest.setBuildType("String_Node_Str");
        jobBuildRequest.setStartTime(1386806400000L);
        jobBuildRequest.setEndTime(new Date().getTime());
        job = cubeController.rebuild("String_Node_Str", jobBuildRequest);
    } catch (Exception e) {
        e.printStackTrace();
    }
    Assert.assertNotNull(jobSchedulerController.get(job.getId()));
    Map<String, String> output = jobSchedulerController.getStepOutput(job.getId(), 0);
    Assert.assertNotNull(output);
}

Output:
     Assert.assertNotNull(jobSchedulerController.list(jobRequest));
-    JobInstance job = null;
-    try {
-        JobBuildRequest jobBuildRequest = new JobBuildRequest();
-        jobBuildRequest.setBuildType("String_Node_Str");
-        jobBuildRequest.setStartTime(1386806400000L);
-        jobBuildRequest.setEndTime(new Date().getTime());
-        job = cubeController.rebuild("String_Node_Str", jobBuildRequest);
-    } catch (Exception e) {
-        e.printStackTrace();
-    }
+    JobBuildRequest jobBuildRequest = new JobBuildRequest();
+    jobBuildRequest.setBuildType("String_Node_Str");
+    jobBuildRequest.setStartTime(1386806400000L);
+    jobBuildRequest.setEndTime(new Date().getTime());
+    JobInstance job = cubeController.rebuild(CUBE_NAME, jobBuildRequest);
     Assert.assertNotNull(jobSchedulerController.get(job.getId()));


Input:
private List<UpdateResult> checkNodeSchemaFromRepository(final Node node, boolean onlySimpleShow) {
    if (node == null) {
        return Collections.emptyList();
    }
    List<UpdateResult> schemaResults = new ArrayList<UpdateResult>();
    List<IProcess2> openedProcesses = UpdateManagerUtils.getOpenedProcess();
    if (PluginChecker.isEBCDICPluginLoaded()) {
        List<UpdateResult> resultForEBCDIC = checkNodeSchemaFromRepositoryForEBCDIC(node, onlySimpleShow);
        if (resultForEBCDIC != null && !resultForEBCDIC.isEmpty()) {
            return resultForEBCDIC;
        }
    }
    if (GlobalServiceRegister.getDefault().isServiceRegistered(IDesignerMapperService.class)) {
        List<UpdateResult> resultForTMap = checkNodeSchemaFromRepositoryForTMap(node, onlySimpleShow);
        if (resultForTMap != null && resultForTMap.size() > 0) {
            schemaResults.addAll(resultForTMap);
        }
    }
    List<IElementParameter> schemaTypeParams = node.getElementParametersFromField(EParameterFieldType.SCHEMA_TYPE);
    if (schemaTypeParams != null) {
        for (IElementParameter schemaTypeParam : schemaTypeParams) {
            UpdateCheckResult result = null;
            IElementParameter schemaParam = schemaTypeParam.getChildParameters().get(EParameterName.SCHEMA_TYPE.getName());
            if (schemaParam != null && ((ElementParameter) schemaTypeParam).isDisplayedByDefault()) {
                if (schemaParam.getValue().equals(EmfComponent.REPOSITORY)) {
                    String propertyValue = (String) schemaTypeParam.getChildParameters().get(EParameterName.REPOSITORY_SCHEMA_TYPE.getName()).getValue();
                    ConnectionItem connectionItem = null;
                    String schemaName = null;
                    String[] names = UpdateManagerUtils.getSourceIdAndChildName(propertyValue);
                    if (names != null && names.length > 1) {
                        connectionItem = UpdateRepositoryUtils.getConnectionItemByItemId(names[0]);
                        schemaName = names[1];
                    }
                    boolean builtIn = true;
                    if (connectionItem != null) {
                        final String uniqueName = node.getUniqueName();
                        String newSourceId = getSchemaRenamedMap().get(propertyValue);
                        Map<String, EUpdateResult> deletedOrReselect = getDeletedOrReselectTablesMap();
                        String connectionId = (String) node.getPropertyValue(EParameterName.REPOSITORY_PROPERTY_TYPE.getName());
                        List<Object> parameter = null;
                        if (newSourceId != null && !newSourceId.equals(propertyValue)) {
                            String[] newSourceIdAndName = UpdateManagerUtils.getSourceIdAndChildName(newSourceId);
                            if (newSourceIdAndName != null) {
                                IMetadataTable table = UpdateRepositoryUtils.getTableByName(connectionItem, newSourceIdAndName[1]);
                                if (table != null) {
                                    String source = UpdateRepositoryUtils.getRepositorySourceName(connectionItem);
                                    final IMetadataTable copyOfrepositoryMetadata = table.clone();
                                    copyOfrepositoryMetadata.setTableName(uniqueName);
                                    copyOfrepositoryMetadata.setAttachedConnector(schemaTypeParam.getContext());
                                    parameter = new ArrayList<Object>();
                                    parameter.add(copyOfrepositoryMetadata);
                                    parameter.add(propertyValue);
                                    parameter.add(newSourceId);
                                    result = new UpdateCheckResult(node);
                                    result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.RENAME, parameter, source);
                                    builtIn = false;
                                }
                            }
                        } else if (!deletedOrReselect.isEmpty() && connectionId != null) {
                            String source = UpdateRepositoryUtils.getRepositorySourceName(connectionItem);
                            EUpdateResult status = deletedOrReselect.get(propertyValue);
                            if (status != null) {
                                if (status.equals(EUpdateResult.DELETE)) {
                                    parameter = new ArrayList<Object>();
                                    String tableName = propertyValue.split(UpdatesConstants.SEGMENT_LINE)[1];
                                    parameter.add(tableName);
                                    parameter.add(status);
                                    result = new UpdateCheckResult(node);
                                    result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.DELETE, parameter, source);
                                    builtIn = false;
                                } else if (status.equals(EUpdateResult.RELOAD)) {
                                    parameter = new ArrayList<Object>();
                                    String tableName = propertyValue.split(UpdatesConstants.SEGMENT_LINE)[1];
                                    parameter.add(tableName);
                                    parameter.add(status);
                                    result = new UpdateCheckResult(node);
                                    result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.RELOAD, parameter, source);
                                    builtIn = false;
                                }
                            }
                        } else {
                            IMetadataTable table = UpdateRepositoryUtils.getTableByName(connectionItem, schemaName);
                            if (table != null) {
                                String source = UpdateRepositoryUtils.getRepositorySourceName(connectionItem) + UpdatesConstants.SEGMENT_LINE + schemaName;
                                final IMetadataTable copyOfrepositoryMetadata = table.clone();
                                copyOfrepositoryMetadata.setTableName(uniqueName);
                                copyOfrepositoryMetadata.setAttachedConnector(schemaTypeParam.getContext());
                                final IMetadataTable metadataTable = node.getMetadataFromConnector(schemaTypeParam.getContext());
                                if (this.isAddColumn) {
                                    Display.getDefault().syncExec(new Runnable() {
                                        public void run() {
                                            isColumnUsed = MessageDialog.openQuestion(Display.getDefault().getActiveShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
                                            copyUsefulAttribute(copyOfrepositoryMetadata, metadataTable, isColumnUsed);
                                        }
                                    });
                                    this.isAddColumn = false;
                                } else {
                                    copyUsefulAttribute(copyOfrepositoryMetadata, metadataTable, isColumnUsed);
                                }
                                if (onlySimpleShow || !metadataTable.sameMetadataAs(copyOfrepositoryMetadata, IMetadataColumn.OPTIONS_IGNORE_DBTYPE) || connectionItem instanceof GenericSchemaConnectionItem && !metadataTable.sameMetadataAs(copyOfrepositoryMetadata, IMetadataColumn.OPTIONS_NONE)) {
                                    result = new UpdateCheckResult(node);
                                    result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.UPDATE, copyOfrepositoryMetadata, source);
                                    result.setContextModeConnectionItem(connectionItem);
                                }
                                builtIn = false;
                            }
                        }
                    }
                    if (builtIn) {
                        result = new UpdateCheckResult(node);
                        result.setResult(EUpdateItemType.NODE_SCHEMA, EUpdateResult.BUIL_IN, schemaTypeParam.getContext());
                    }
                    if (result != null) {
                        if (!openedProcesses.contains(getProcess())) {
                            result.setFromItem(true);
                        }
                        result.setJob(getProcess());
                        setConfigrationForReadOnlyJob(result);
                        schemaResults.add(result);
                    }
                }
            }
        }
    }
    return schemaResults;
}

Output:
                         } else {
-                            IMetadataTable table = UpdateRepositoryUtils.getTableByName(connectionItem, schemaName);
+                            IMetadataTable table = null;
+                            IGenericWizardService wizardService = null;
+                            if (GlobalServiceRegister.getDefault().isServiceRegistered(IGenericWizardService.class)) {
+                                wizardService = (IGenericWizardService) GlobalServiceRegister.getDefault().getService(IGenericWizardService.class);
+                            }
+                            if (wizardService != null && wizardService.isGenericItem(connectionItem)) {
+                                List<MetadataTable> metadataTables = wizardService.getMetadataTables(connectionItem.getConnection());
+                                for (MetadataTable metadataTable : metadataTables) {
+                                    if (metadataTable.getLabel().equals(schemaName)) {
+                                        if (GlobalServiceRegister.getDefault().isServiceRegistered(IMetadataManagmentService.class)) {
+                                            IMetadataManagmentService mmService = (IMetadataManagmentService) GlobalServiceRegister.getDefault().getService(IMetadataManagmentService.class);
+                                            table = mmService.convertMetadataTable(metadataTable);
+                                        }
+                                    }
+                                }
+                            } else {
+                                table = UpdateRepositoryUtils.getTableByName(connectionItem, schemaName);
+                            }
                             if (table != null) {


Input:
public boolean write(final int msgTypeId, final DirectBuffer srcBuffer, final int srcIndex, final int length) {
    checkMsgTypeId(msgTypeId);
    checkMsgLength(length);
    final AtomicBuffer buffer = this.buffer;
    final int requiredCapacity = align(length + HEADER_LENGTH, ALIGNMENT);
    final int recordIndex = claimCapacity(buffer, requiredCapacity);
    if (INSUFFICIENT_CAPACITY == recordIndex) {
        return false;
    }
    writeMsg(buffer, recordIndex, srcBuffer, srcIndex, length);
    msgType(buffer, recordIndex, msgTypeId);
    msgLengthOrdered(buffer, recordIndex, length);
    return true;
}

Output:
     final int recordIndex = claimCapacity(buffer, requiredCapacity);
-    if (INSUFFICIENT_CAPACITY == recordIndex) {
-        return false;
+    if (INSUFFICIENT_CAPACITY != recordIndex) {
+        buffer.putIntOrdered(msgLengthOffset(recordIndex), -length);
+        buffer.putBytes(encodedMsgOffset(recordIndex), srcBuffer, srcIndex, length);
+        buffer.putInt(msgTypeOffset(recordIndex), msgTypeId);
+        buffer.putIntOrdered(msgLengthOffset(recordIndex), length);
+        isSuccessful = true;
     }


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ((WordPress) getApplication()).component().inject(this);
    setContentView(R.layout.plugin_browser_activity);
    mViewModel = ViewModelProviders.of(this, mViewModelFactory).get(PluginBrowserViewModel.class);
    mSitePluginsRecycler = findViewById(R.id.installed_plugins_recycler);
    mFeaturedPluginsRecycler = findViewById(R.id.featured_plugins_recycler);
    mPopularPluginsRecycler = findViewById(R.id.popular_plugins_recycler);
    mNewPluginsRecycler = findViewById(R.id.new_plugins_recycler);
    Toolbar toolbar = findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);
    ActionBar actionBar = getSupportActionBar();
    if (actionBar != null) {
        actionBar.setHomeButtonEnabled(true);
        actionBar.setDisplayHomeAsUpEnabled(true);
    }
    if (savedInstanceState == null) {
        mViewModel.setSite((SiteModel) getIntent().getSerializableExtra(WordPress.SITE));
    } else {
        mViewModel.readFromBundle(savedInstanceState);
    }
    mViewModel.start();
    if (mViewModel.getSite() == null) {
        ToastUtils.showToast(this, R.string.blog_not_found);
        finish();
        return;
    }
    findViewById(R.id.text_manage).setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            showListFragment(PluginListType.SITE);
        }
    });
    findViewById(R.id.text_all_featured).setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            showListFragment(PluginListType.FEATURED);
        }
    });
    findViewById(R.id.text_all_popular).setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            showListFragment(PluginListType.POPULAR);
        }
    });
    findViewById(R.id.text_all_new).setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            showListFragment(PluginListType.NEW);
        }
    });
    getSupportFragmentManager().addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener() {
        public void onBackStackChanged() {
            if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
                mViewModel.setTitle(getString(R.string.plugins));
            }
        }
    });
    configureRecycler(mSitePluginsRecycler);
    configureRecycler(mFeaturedPluginsRecycler);
    configureRecycler(mPopularPluginsRecycler);
    configureRecycler(mNewPluginsRecycler);
    setupObservers();
}

Output:
     if (savedInstanceState == null) {
-        mViewModel.setSite((SiteModel) getIntent().getSerializableExtra(WordPress.SITE));
+        mViewModel.setSite(siteModel);
     } else {


Input:
public int getItemIndex(String title) {
    if (title == null)
        return -1;
    CTabItem[] items = tabFolder.getItems();
    for (int i = 0; i < items.length; i++) {
        if (items[i].getText().equals(title))
            return i;
    }
    return -1;
}

Output:
     for (int i = 0; i < items.length; i++) {
-        if (items[i].getText().equals(title))
+        if (items[i].getText().equals(itemKey))
             return i;


Input:
public void processConfigFile(File file) throws IOException, BindException {
    PropertiesConfiguration confFile;
    try {
        confFile = new PropertiesConfiguration(file);
    } catch (ConfigurationException e) {
        throw new BindException("String_Node_Str", e);
    }
    Iterator<String> it = confFile.getKeys();
    Map<String, String> shortNames = new HashMap<String, String>();
    while (it.hasNext()) {
        String key = it.next();
        String longName = shortNames.get(key);
        String[] values = confFile.getStringArray(key);
        if (longName != null) {
            key = longName;
        }
        for (String value : values) {
            boolean isSingleton = false;
            if (value.equals(ConfigurationImpl.SINGLETON)) {
                isSingleton = true;
            }
            if (value.equals(ConfigurationImpl.REGISTERED)) {
                try {
                    this.conf.namespace.register(conf.classForName(key));
                } catch (ClassNotFoundException e) {
                    throw new BindException("String_Node_Str" + key + "String_Node_Str", e);
                }
            }
            if (key.equals(ConfigurationImpl.IMPORT)) {
                if (isSingleton) {
                    throw new IllegalArgumentException("String_Node_Str" + ConfigurationImpl.IMPORT + "String_Node_Str" + ConfigurationImpl.SINGLETON + "String_Node_Str");
                }
                try {
                    this.conf.namespace.register(conf.classForName(value));
                    String[] tok = value.split(ReflectionUtilities.regexp);
                    try {
                        this.conf.namespace.getNode(tok[tok.length - 1]);
                        throw new IllegalArgumentException("String_Node_Str" + tok[tok.length - 1]);
                    } catch (NameResolutionException e) {
                        String oldValue = shortNames.put(tok[tok.length - 1], value);
                        if (oldValue != null) {
                            throw new IllegalArgumentException("String_Node_Str" + tok[tok.length - 1] + "String_Node_Str" + oldValue + "String_Node_Str" + value);
                        }
                    }
                } catch (ClassNotFoundException e) {
                    throw new BindException("String_Node_Str" + value + "String_Node_Str", e);
                }
            } else {
                if (isSingleton) {
                    final Class<?> c;
                    try {
                        c = conf.classForName(key);
                    } catch (ClassNotFoundException e) {
                        throw new BindException("String_Node_Str", e);
                    }
                    bindSingleton(c);
                } else {
                    try {
                        bind(key, value);
                    } catch (ClassNotFoundException e) {
                        throw new BindException("String_Node_Str", e);
                    }
                }
            }
        }
    }
}

Output:
                 } else {
-                    try {
-                        bind(key, value);
-                    } catch (ClassNotFoundException e) {
-                        throw new BindException("String_Node_Str", e);
-                    }
+                    bind(key, value);
                 }


Input:
public static void main(String[] args) {
    Map<String, Integer> map = loadOccCountsMap(GraphConfig.config());
    queryContent(map);
}

Output:
 public static void main(String[] args) {
-    Map<String, Integer> map = loadOccCountsMap(GraphConfig.config());
+    Map<String, Integer> map = loadOccCountsMap(GraphConfig.config(), false);
     queryContent(map);