Input:
public final void renderEachAxis() throws ChartException {
    final double dStaggeredLabelOffset = sc.computeStaggeredAxisLabelOffset(xs, la, iOrientation);
    if (!lia.isSetVisible()) {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, "String_Node_Str", Messages.getResourceBundle(getRunTimeContext().getULocale()));
    }
    tre.setLabel(la);
    tre.setTextPosition(iLabelLocation);
    tre.setLocation(lo);
    lre.setLineAttributes(lia);
    lre.setStart(LocationImpl.create(0, 0));
    lre.setEnd(LocationImpl.create(0, 0));
    double dXStart = 0;
    double dXEnd = 0;
    double dZStart = 0;
    double dZEnd = 0;
    if (iDimension == IConstants.THREE_D) {
        AllAxes aax = pwa.getAxes();
        dXEnd = aax.getPrimaryBase().getScale().getEnd();
        dZEnd = aax.getAncillaryBase().getScale().getEnd();
        dXStart = aax.getPrimaryBase().getScale().getStart();
        dZStart = aax.getAncillaryBase().getScale().getStart();
        daEndPoints3D = sc.getEndPoints();
        da3D = sc.getTickCordinates();
        lo3d = Location3DImpl.create(0, 0, 0);
        t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);
        t3dre.setLabel(la);
        t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
        t3dre.setTextPosition(iLabelLocation);
        t3dre.setLocation3D(lo3d);
        l3dre = (Line3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Line3DRenderEvent.class);
        l3dre.setLineAttributes(lia);
        l3dre.setStart3D(Location3DImpl.create(0, 0, 0));
        l3dre.setEnd3D(Location3DImpl.create(0, 0, 0));
    }
    if (iOrientation == IConstants.VERTICAL) {
        final ComputationContext context = new ComputationContext(true);
        context.y3d = 0;
        context.dX = dLocation;
        double dZ = 0;
        if (bRendering3D) {
            Location3D l3d = ax.getAxisCoordinate3D();
            context.dX = l3d.getX();
            dZ = l3d.getZ();
        }
        if (iv != null && iv.getType() == IntersectionValue.MAX && iDimension == IConstants.TWO_5_D) {
            trae.setTransform(TransformationEvent.TRANSLATE);
            trae.setTranslation(dSeriesThickness, -dSeriesThickness);
            ipr.applyTransformation(trae);
        }
        context.dTick1 = ((iMajorTickStyle & IConstants.TICK_LEFT) == IConstants.TICK_LEFT) ? context.dX - pwa.getTickSize() : context.dX;
        context.dTick2 = ((iMajorTickStyle & IConstants.TICK_RIGHT) == IConstants.TICK_RIGHT) ? context.dX + pwa.getTickSize() : context.dX;
        if ((iWhatToDraw & IConstants.AXIS) == IConstants.AXIS && lia.isVisible()) {
            if (bRenderOrthogonal3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(context.dX, dStart, dZ);
                l3dre.setEnd3D(context.dX, dEnd, dZ);
                dc.addLine(l3dre);
                l3dre.setStart3D(context.dX, dStart, dZEnd);
                l3dre.setEnd3D(context.dX, dEnd, dZEnd);
                dc.addLine(l3dre);
                l3dre.setStart3D(dXEnd, dStart, dZ);
                l3dre.setEnd3D(dXEnd, dEnd, dZ);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        ArrayList cachedTriggers = null;
                        Location3D[] loaHotspot = new Location3D[4];
                        Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot[0] = Location3DImpl.create(context.dX - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZ + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(context.dX + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZ - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(context.dX + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZ - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(context.dX - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZ + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            cachedTriggers = new ArrayList();
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                cachedTriggers.add(tg);
                                iev.addTrigger(TriggerImpl.copyInstance(tg));
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                        pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dXStart - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(dXStart + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(dXStart + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(dXStart - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            if (cachedTriggers == null) {
                                cachedTriggers = new ArrayList();
                                for (int t = 0; t < elTriggers.size(); t++) {
                                    tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                    processTrigger(tg, StructureSource.createAxis(axModel));
                                    cachedTriggers.add(tg);
                                    iev.addTrigger(TriggerImpl.copyInstance(tg));
                                }
                            } else {
                                for (int t = 0; t < cachedTriggers.size(); t++) {
                                    iev.addTrigger(TriggerImpl.copyInstance((Trigger) cachedTriggers.get(t)));
                                }
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                        pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dXEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZStart + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[1] = Location3DImpl.create(dXEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart, dZStart - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[2] = Location3DImpl.create(dXEnd + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZStart - IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        loaHotspot[3] = Location3DImpl.create(dXEnd - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd, dZStart + IConstants.LINE_EXPAND_DOUBLE_SIZE);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            if (cachedTriggers == null) {
                                for (int t = 0; t < elTriggers.size(); t++) {
                                    tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                    processTrigger(tg, StructureSource.createAxis(axModel));
                                    iev.addTrigger(tg);
                                }
                            } else {
                                for (int t = 0; t < cachedTriggers.size(); t++) {
                                    iev.addTrigger((Trigger) cachedTriggers.get(t));
                                }
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else {
                double dStart = daEndPoints[0] + insCA.getBottom(), dEnd = daEndPoints[1] - insCA.getTop();
                if (sc.getDirection() == IConstants.FORWARD) {
                    dStart = daEndPoints[1] + insCA.getBottom();
                    dEnd = daEndPoints[0] - insCA.getTop();
                }
                if (iv != null && iv.getType() == IntersectionValue.VALUE && iDimension == IConstants.TWO_5_D) {
                    final Location[] loa = new Location[4];
                    loa[0] = LocationImpl.create(context.dX, dStart);
                    loa[1] = LocationImpl.create(context.dX + dSeriesThickness, dStart - dSeriesThickness);
                    loa[2] = LocationImpl.create(context.dX + dSeriesThickness, dEnd - dSeriesThickness);
                    loa[3] = LocationImpl.create(context.dX, dEnd);
                    final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                    pre.setPoints(loa);
                    pre.setBackground(ColorDefinitionImpl.create(255, 255, 255, 127));
                    pre.setOutline(lia);
                    ipr.fillPolygon(pre);
                }
                lre.setLineAttributes(lia);
                lre.getStart().set(context.dX, dStart);
                lre.getEnd().set(context.dX, dEnd);
                ipr.drawLine(lre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                        for (int t = 0; t < elTriggers.size(); t++) {
                            tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                            processTrigger(tg, StructureSource.createAxis(axModel));
                            iev.addTrigger(tg);
                        }
                        Location[] loaHotspot = new Location[4];
                        loaHotspot[0] = LocationImpl.create(context.dX - IConstants.LINE_EXPAND_SIZE, dStart);
                        loaHotspot[1] = LocationImpl.create(context.dX + IConstants.LINE_EXPAND_SIZE, dStart);
                        loaHotspot[2] = LocationImpl.create(context.dX + IConstants.LINE_EXPAND_SIZE, dEnd);
                        loaHotspot[3] = LocationImpl.create(context.dX - IConstants.LINE_EXPAND_SIZE, dEnd);
                        final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                        pre.setPoints(loaHotspot);
                        iev.setHotSpot(pre);
                        ipr.enableInteraction(iev);
                    }
                }
            }
        }
        renderVerticalAxisByType(context, dXEnd, dZEnd, dZ, dStaggeredLabelOffset);
        la = LabelImpl.copyInstance(ax.getTitle());
        if (la.isVisible() && bRenderAxisTitle) {
            ScriptHandler.callFunction(sh, ScriptHandler.BEFORE_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.BEFORE_DRAW_AXIS_TITLE, la);
            final String sRestoreValue = la.getCaption().getValue();
            la.getCaption().setValue(getRunTimeContext().externalizedMessage(sRestoreValue));
            BoundingBox bb = null;
            boolean bWithinAxis = false;
            final boolean bTitleHorizontal = Math.abs(la.getCaption().getFont().getRotation()) <= 30;
            final double dYAxisHeightPC = ChartUtil.computeHeightOfOrthogonalAxisTitle((ChartWithAxes) this.renderer.cm, xs);
            try {
                if (bTitleHorizontal) {
                    bWithinAxis = true;
                } else {
                    final BoundingBox bbWoWrap = Methods.computeBox(xs, iLabelLocation, la, 0, 0, dYAxisHeightPC);
                    bWithinAxis = bbWoWrap.getHeight() < daEndPoints[0] - daEndPoints[1];
                }
                bb = Methods.computeBox(xs, ax.getTitlePosition(), la, 0, 0, bWithinAxis && !bTitleHorizontal ? daEndPoints[0] - daEndPoints[1] : dYAxisHeightPC);
            } catch (IllegalArgumentException uiex) {
                throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, uiex);
            }
            if (ax.getTitle().isVisible() && la.isVisible()) {
                if (bRendering3D) {
                    double yCenter = daEndPoints3D[0] + ((daEndPoints3D[1] - daEndPoints3D[0]) / 2);
                    final double x = (iLabelLocation == IConstants.LEFT) ? context.dTick1 - 1 : context.dTick2 + 1;
                    double sx = x;
                    double sx2 = dXEnd;
                    if (bAxisLabelStaggered) {
                        if (iLabelLocation == IConstants.LEFT) {
                            sx -= dStaggeredLabelOffset;
                            sx2 += dStaggeredLabelOffset;
                        } else {
                            sx += dStaggeredLabelOffset;
                            sx2 -= dStaggeredLabelOffset;
                        }
                    }
                    Angle3D a3D = (Angle3D) ((ChartWithAxes) renderer.cm).getRotation().getAngles().get(0);
                    double offset = 2;
                    t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);
                    sx = sx - pwa.getHorizontalSpacingInPixels() - bb.getWidth() - bb.getHeight();
                    t3dre.setLocation3D(Location3DImpl.create(sx - offset, yCenter, dZEnd + offset + pwa.getHorizontalSpacingInPixels() + (bb.getWidth() + bb.getHeight()) * Math.sin(a3D.getYAngle() * Math.PI / 180)));
                    t3dre.setLabel(la);
                    t3dre.setTextPosition(Text3DRenderEvent.LEFT);
                    t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
                    dc.addLabel(t3dre);
                    t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);
                    sx2 = sx2 + pwa.getHorizontalSpacingInPixels() + 100;
                    t3dre.setLocation3D(Location3DImpl.create(sx2, yCenter, dZ - pwa.getHorizontalSpacingInPixels() - 100 * Math.sin(a3D.getYAngle() * Math.PI / 180)));
                    t3dre.setLabel(la);
                    t3dre.setTextPosition(Text3DRenderEvent.RIGHT);
                    t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
                    dc.addLabel(t3dre);
                } else {
                    double dTop = computeTopOfOrthogonalAxisTitle();
                    final Bounds bo = BoundsImpl.create(ax.getTitleCoordinate(), bWithinAxis ? daEndPoints[1] : dTop, bb.getWidth(), bWithinAxis ? daEndPoints[0] - daEndPoints[1] : dYAxisHeightPC);
                    tre.setBlockBounds(bo);
                    tre.setLabel(la);
                    if (ax.getModelAxis().getAssociatedAxes().size() != 0) {
                        tre.setBlockAlignment(ChartUtil.transposeAlignment(la.getCaption().getFont().getAlignment()));
                    } else {
                        tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    }
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    if (ax.getTitle().isVisible()) {
                        ipr.drawText(tre);
                    }
                }
            }
            la.getCaption().setValue(sRestoreValue);
            ScriptHandler.callFunction(sh, ScriptHandler.AFTER_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.AFTER_DRAW_AXIS_TITLE, la);
        }
        la = LabelImpl.copyInstance(ax.getLabel());
        if (iv != null && iv.getType() == IntersectionValue.MAX && iDimension == IConstants.TWO_5_D) {
            trae.setTranslation(-dSeriesThickness, dSeriesThickness);
            ipr.applyTransformation(trae);
        }
    } else if (iOrientation == IConstants.HORIZONTAL) {
        final ComputationContext context = new ComputationContext(false);
        context.x3d = 0;
        context.z3d = 0;
        context.dY = dLocation;
        double dX = 0;
        double dZ = 0;
        if (bRendering3D) {
            Location3D l3d = ax.getAxisCoordinate3D();
            dX = l3d.getX();
            context.dY = l3d.getY();
            dZ = l3d.getZ();
        }
        context.dTick1 = ((iMajorTickStyle & IConstants.TICK_ABOVE) == IConstants.TICK_ABOVE) ? (bRendering3D ? context.dY + pwa.getTickSize() : context.dY - pwa.getTickSize()) : context.dY;
        context.dTick2 = ((iMajorTickStyle & IConstants.TICK_BELOW) == IConstants.TICK_BELOW) ? (bRendering3D ? context.dY - pwa.getTickSize() : context.dY + pwa.getTickSize()) : context.dY;
        if (iv != null && iDimension == IConstants.TWO_5_D && ((bTransposed && renderer.isRightToLeft() && iv.getType() == IntersectionValue.MIN) || (!renderer.isRightToLeft() && iv.getType() == IntersectionValue.MAX))) {
            trae.setTransform(TransformationEvent.TRANSLATE);
            trae.setTranslation(dSeriesThickness, -dSeriesThickness);
            ipr.applyTransformation(trae);
        }
        if ((iWhatToDraw & IConstants.AXIS) == IConstants.AXIS && lia.isVisible()) {
            if (bRenderBase3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(dStart, context.dY, dZ);
                l3dre.setEnd3D(dEnd, context.dY, dZ);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        Location3D[] loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dStart, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[1] = Location3DImpl.create(dStart, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[2] = Location3DImpl.create(dEnd, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        loaHotspot[3] = Location3DImpl.create(dEnd, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dZ);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                iev.addTrigger(tg);
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else if (bRenderAncillary3DAxis) {
                final double dStart = daEndPoints3D[0];
                final double dEnd = daEndPoints3D[1];
                l3dre.setLineAttributes(lia);
                l3dre.setStart3D(dX, context.dY, dStart);
                l3dre.setEnd3D(dX, context.dY, dEnd);
                dc.addLine(l3dre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final Polygon3DRenderEvent pre3d = (Polygon3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Polygon3DRenderEvent.class);
                        Location3D[] loaHotspot = new Location3D[4];
                        loaHotspot[0] = Location3DImpl.create(dX, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart);
                        loaHotspot[1] = Location3DImpl.create(dX, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dStart);
                        loaHotspot[2] = Location3DImpl.create(dX, context.dY + IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd);
                        loaHotspot[3] = Location3DImpl.create(dX, context.dY - IConstants.LINE_EXPAND_DOUBLE_SIZE, dEnd);
                        pre3d.setPoints3D(loaHotspot);
                        pre3d.setDoubleSided(true);
                        if (renderer.get3DEngine().processEvent(pre3d, panningOffset.getX(), panningOffset.getY()) != null) {
                            final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                            for (int t = 0; t < elTriggers.size(); t++) {
                                tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                                processTrigger(tg, StructureSource.createAxis(axModel));
                                iev.addTrigger(tg);
                            }
                            iev.setHotSpot(pre3d);
                            ipr.enableInteraction(iev);
                        }
                    }
                }
            } else {
                double dStart = daEndPoints[0] - insCA.getLeft(), dEnd = daEndPoints[1] + insCA.getRight();
                if (sc.getDirection() == IConstants.BACKWARD) {
                    dStart = daEndPoints[1] - insCA.getLeft();
                    dEnd = daEndPoints[0] + insCA.getRight();
                }
                if (iv != null && iv.getType() == IntersectionValue.VALUE && iDimension == IConstants.TWO_5_D) {
                    final Location[] loa = new Location[4];
                    loa[0] = LocationImpl.create(dStart, context.dY);
                    loa[1] = LocationImpl.create(dStart + dSeriesThickness, context.dY - dSeriesThickness);
                    loa[2] = LocationImpl.create(dEnd + dSeriesThickness, context.dY - dSeriesThickness);
                    loa[3] = LocationImpl.create(dEnd, context.dY);
                    final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                    pre.setPoints(loa);
                    pre.setBackground(ColorDefinitionImpl.create(255, 255, 255, 127));
                    pre.setOutline(lia);
                    ipr.fillPolygon(pre);
                }
                lre.setLineAttributes(lia);
                lre.getStart().set(dStart, context.dY);
                lre.getEnd().set(dEnd, context.dY);
                ipr.drawLine(lre);
                if (renderer.isInteractivityEnabled()) {
                    Trigger tg;
                    EList elTriggers = axModel.getTriggers();
                    if (!elTriggers.isEmpty()) {
                        final InteractionEvent iev = (InteractionEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), InteractionEvent.class);
                        for (int t = 0; t < elTriggers.size(); t++) {
                            tg = TriggerImpl.copyInstance((Trigger) elTriggers.get(t));
                            processTrigger(tg, StructureSource.createAxis(axModel));
                            iev.addTrigger(tg);
                        }
                        Location[] loaHotspot = new Location[4];
                        loaHotspot[0] = LocationImpl.create(dStart, context.dY - IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[1] = LocationImpl.create(dEnd, context.dY - IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[2] = LocationImpl.create(dEnd, context.dY + IConstants.LINE_EXPAND_SIZE);
                        loaHotspot[3] = LocationImpl.create(dStart, context.dY + IConstants.LINE_EXPAND_SIZE);
                        final PolygonRenderEvent pre = (PolygonRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), PolygonRenderEvent.class);
                        pre.setPoints(loaHotspot);
                        iev.setHotSpot(pre);
                        ipr.enableInteraction(iev);
                    }
                }
            }
        }
        renderHorizontalAxisByType(context, dXEnd, dZEnd, dZ, dStaggeredLabelOffset);
        la = LabelImpl.copyInstance(ax.getTitle());
        if (la.isVisible() && bRenderAxisTitle) {
            ScriptHandler.callFunction(sh, ScriptHandler.BEFORE_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.BEFORE_DRAW_AXIS_TITLE, la);
            final String sRestoreValue = la.getCaption().getValue();
            la.getCaption().setValue(getRunTimeContext().externalizedMessage(sRestoreValue));
            la.getCaption().getFont().setAlignment(renderer.switchTextAlignment(la.getCaption().getFont().getAlignment()));
            BoundingBox bb = null;
            try {
                bb = Methods.computeBox(xs, ax.getTitlePosition(), la, 0, 0, Math.abs(daEndPoints[1] - daEndPoints[0]));
            } catch (IllegalArgumentException uiex) {
                throw new ChartException(ChartEnginePlugin.ID, ChartException.RENDERING, uiex);
            }
            if (ax.getTitle().isVisible() && la.isVisible()) {
                if (bRendering3D) {
                    Angle3D a3D = (Angle3D) ((ChartWithAxes) renderer.cm).getRotation().getAngles().get(0);
                    if (axisType == IConstants.BASE_AXIS) {
                        t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);
                        IAxisTypeComputation computation = createAxisTypeComputation(context);
                        computation.initialize();
                        final int length = computation instanceof TextAxisTypeComputation ? da.size() - 1 : da.size();
                        int xStart = (int) da3D.getCoordinate(0);
                        int xEnd = (int) da3D.getCoordinate(length - 1);
                        int x = xStart + (xEnd - xStart) / 2;
                        Location3D location = Location3DImpl.create(x, context.dY - bb.getHeight() * 3, dZEnd + pwa.getVerticalSpacingInPixels());
                        t3dre.setLocation3D(location);
                        t3dre.setLabel(la);
                        double angle = (a3D.getZAngle() + a3D.getXAngle()) % 360;
                        if (angle > 0 && angle <= 180) {
                            t3dre.setTextPosition(Text3DRenderEvent.RIGHT);
                        } else {
                            t3dre.setTextPosition(Text3DRenderEvent.LEFT);
                        }
                        t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
                        dc.addLabel(t3dre);
                    } else {
                        Location3D location = Location3DImpl.create(dXEnd, context.dY - bb.getHeight(), dZ + (dZEnd - dZ) / 2);
                        t3dre.setLocation3D(location);
                        t3dre.setLabel(la);
                        double angle = a3D.getZAngle() % 360;
                        if (angle >= 0 && angle < 180) {
                            t3dre.setTextPosition(Text3DRenderEvent.RIGHT);
                        } else {
                            t3dre.setTextPosition(Text3DRenderEvent.LEFT);
                        }
                        t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
                        dc.addLabel(t3dre);
                    }
                } else {
                    final Bounds bo = BoundsImpl.create(daEndPoints[0], ax.getTitleCoordinate(), daEndPoints[1] - daEndPoints[0], bb.getHeight());
                    tre.setBlockBounds(bo);
                    tre.setLabel(la);
                    if (ax.getModelAxis().getAssociatedAxes().size() != 0) {
                        tre.setBlockAlignment(la.getCaption().getFont().getAlignment());
                    } else {
                        tre.setBlockAlignment(ChartUtil.transposeAlignment(la.getCaption().getFont().getAlignment()));
                    }
                    tre.setAction(TextRenderEvent.RENDER_TEXT_IN_BLOCK);
                    ipr.drawText(tre);
                }
            }
            ScriptHandler.callFunction(sh, ScriptHandler.AFTER_DRAW_AXIS_TITLE, axModel, la, getRunTimeContext().getScriptContext());
            getRunTimeContext().notifyStructureChange(IStructureDefinitionListener.AFTER_DRAW_AXIS_TITLE, la);
        }
        la = LabelImpl.copyInstance(ax.getLabel());
        if (iv != null && iDimension == IConstants.TWO_5_D && ((bTransposed && renderer.isRightToLeft() && iv.getType() == IntersectionValue.MIN) || (!renderer.isRightToLeft() && iv.getType() == IntersectionValue.MAX))) {
            trae.setTranslation(-dSeriesThickness, dSeriesThickness);
            ipr.applyTransformation(trae);
        }
    }
}

Output:
                     t3dre.setAction(Text3DRenderEvent.RENDER_TEXT_AT_LOCATION);
-                    dc.addLabel(t3dre);
+                    renderAxisTitleWith3DTextevent(bb);
                     t3dre = (Text3DRenderEvent) ((EventObjectCache) ipr).getEventObject(StructureSource.createAxis(axModel), Text3DRenderEvent.class);


Input:
public ExcerptTailer toStart() throws IOException {
    long firstCycle = queue.firstCycle();
    if (firstCycle > 0) {
        cycle(firstCycle);
        this.toStart = true;
    } else {
        this.toStart = false;
    }
    this.index = -1;
    final Bytes<?> readContext = wire.bytes();
    readContext.readPosition(0);
    readContext.readLimit(readContext.capacity());
    return this;
}

Output:
 public ExcerptTailer toStart() throws IOException {
-    long firstCycle = queue.firstCycle();
-    if (firstCycle > 0) {
-        cycle(firstCycle);
-        this.toStart = true;
-    } else {
-        this.toStart = false;
-    }
-    this.index = -1;
-    final Bytes<?> readContext = wire.bytes();
-    readContext.readPosition(0);
-    readContext.readLimit(readContext.capacity());
+    final long index = queue.firstIndex();
+    if (index == -1)
+        return this;
+    LOG.info("String_Node_Str" + ChronicleQueue.subIndex(index) + "String_Node_Str" + ChronicleQueue.cycle(index));
+    if (!moveToIndex(index))
+        throw new IllegalStateException("String_Node_Str");
     return this;


Input:
public T getById(Language language, int pageId) throws DaoException {
    LiveAPIQuery.LiveAPIQueryBuilder builder = new LiveAPIQuery.LiveAPIQueryBuilder("String_Node_Str", language).setPageid(pageId).setRedirects(followRedirects);
    QueryReply info = builder.build().getValuesFromQueryResult().get(0);
    return (T) info.getLocalPage(language);
}

Output:
 public T getById(Language language, int pageId) throws DaoException {
-    LiveAPIQuery.LiveAPIQueryBuilder builder = new LiveAPIQuery.LiveAPIQueryBuilder("String_Node_Str", language).setPageid(pageId).setRedirects(followRedirects);
+    LiveAPIQuery.LiveAPIQueryBuilder builder = new LiveAPIQuery.LiveAPIQueryBuilder("String_Node_Str", language).addPageid(pageId).setRedirects(followRedirects);
     QueryReply info = builder.build().getValuesFromQueryResult().get(0);


Input:
public SerializableTypeOracle build(TreeLogger logger) throws UnableToCompleteException {
    alreadyCheckedObject = false;
    boolean allSucceeded = true;
    for (Entry<JClassType, TreeLogger> entry : rootTypes.entrySet()) {
        ProblemReport problems = new ProblemReport();
        problems.setContextType(entry.getKey());
        boolean entrySucceeded = checkTypeInstantiable(entry.getValue(), entry.getKey(), TypePaths.createRootPath(entry.getKey()), problems);
        if (!entrySucceeded) {
            problems.report(logger, TreeLogger.ERROR, TreeLogger.INFO);
        } else {
            if (problems.hasFatalProblems()) {
                entrySucceeded = false;
                problems.reportFatalProblems(logger, TreeLogger.ERROR);
            }
            problems.report(logger, TreeLogger.DEBUG, TreeLogger.DEBUG);
        }
        allSucceeded &= entrySucceeded;
    }
    if (!allSucceeded) {
        throw new UnableToCompleteException();
    }
    for (TypeInfoComputed tic : typeToTypeInfoComputed.values()) {
        assert (!tic.isPendingInstantiable());
    }
    pruneUnreachableTypes();
    logReachableTypes(logger);
    Set<JClassType> possiblyEnhancedTypes = new TreeSet<JClassType>(JTYPE_COMPARATOR);
    Set<JClassType> possiblyInstantiatedTypes = new TreeSet<JClassType>(JTYPE_COMPARATOR);
    Set<JClassType> fieldSerializableTypes = new TreeSet<JClassType>(JTYPE_COMPARATOR);
    for (TypeInfoComputed tic : typeToTypeInfoComputed.values()) {
        JClassType type = tic.getType();
        type = type.getErasedType();
        if (tic.isInstantiable()) {
            assert (!type.isAbstract() || type.isEnum() != null);
            possiblyInstantiatedTypes.add(type);
        }
        if (tic.isFieldSerializable()) {
            assert (type.isInterface() == null);
            fieldSerializableTypes.add(type);
        }
        if ((enhancedClasses != null && enhancedClasses.contains(type.getQualifiedSourceName())) || tic.maybeEnhanced()) {
            possiblyEnhancedTypes.add(type);
        }
    }
    logSerializableTypes(logger, fieldSerializableTypes);
    return new SerializableTypeOracleImpl(fieldSerializableTypes, possiblyInstantiatedTypes, possiblyEnhancedTypes);
}

Output:
         problems.setContextType(entry.getKey());
-        boolean entrySucceeded = checkTypeInstantiable(entry.getValue(), entry.getKey(), TypePaths.createRootPath(entry.getKey()), problems);
+        boolean entrySucceeded = computeTypeInstantiability(entry.getValue(), entry.getKey(), TypePaths.createRootPath(entry.getKey()), problems).hasInstantiableSubtypes();
         if (!entrySucceeded) {


Input:
public void getIntegers(int[] array) {
    array = new int[this.getCardinality()];
    int pos = 0;
    final Iterator<Entry<Short, Container>> p1 = this.highlowcontainer.entrySet().iterator();
    Entry<Short, Container> s;
    do {
        s = p1.next();
        if (s.getValue() instanceof ArrayContainer)
            for (int i = 0; i < s.getValue().getCardinality(); i++) array[pos++] = (16 << s.getKey().shortValue()) | ((ArrayContainer) s.getValue()).content[i];
        else if (s.getValue() instanceof BitmapContainer)
            for (int i = ((BitmapContainer) s.getValue()).nextSetBit(0); i >= 0; i = ((BitmapContainer) s.getValue()).nextSetBit(i + 1)) array[pos++] = (16 << s.getKey().shortValue()) | i;
    } while (p1.hasNext());
}

Output:
     Entry<Short, Container> s;
-    do {
+    while (p1.hasNext()) {
         s = p1.next();


Input:
void suspendThisAndResumeOther(Transaction otherTx, SlaveContext txId) {
    try {
        TransactionManager txManager = graphDbConfig.getTxModule().getTxManager();
        txManager.suspend();
        System.out.println(Thread.currentThread() + "String_Node_Str" + txId);
        if (otherTx != null) {
            System.out.println(Thread.currentThread() + "String_Node_Str" + txId);
            txManager.resume(otherTx);
        }
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

Output:
         txManager.suspend();
-        System.out.println(Thread.currentThread() + "String_Node_Str" + txId);
+        System.out.println("String_Node_Str" + txId);
         if (otherTx != null) {


Input:
void invalidateDisplayLists() {
    final ArrayList<DisplayList> displayLists = mDisplayLists;
    final int count = displayLists.size();
    for (int i = 0; i < count; i++) {
        final DisplayList displayList = displayLists.get(i);
        if (displayList.isDirty()) {
            displayList.clear();
        }
    }
    displayLists.clear();
}

Output:
         if (displayList.isDirty()) {
-            displayList.clear();
+            displayList.reset();
         }


Input:
public void configurePipeline(PipelineConfigurer pipelineConfigurer) {
    Preconditions.checkArgument(!(dbSinkConfig.user == null && dbSinkConfig.password != null), "String_Node_Str" + "String_Node_Str");
    Preconditions.checkArgument(!(dbSinkConfig.user != null && dbSinkConfig.password == null), "String_Node_Str" + "String_Node_Str");
    Class<? extends Driver> jdbcDriverClass = pipelineConfigurer.usePluginClass(dbSinkConfig.jdbcPluginType, dbSinkConfig.jdbcPluginName, getJDBCPluginId(), PluginProperties.builder().build());
    Preconditions.checkArgument(jdbcDriverClass != null, "String_Node_Str");
}

Output:
     Class<? extends Driver> jdbcDriverClass = pipelineConfigurer.usePluginClass(dbSinkConfig.jdbcPluginType, dbSinkConfig.jdbcPluginName, getJDBCPluginId(), PluginProperties.builder().build());
-    Preconditions.checkArgument(jdbcDriverClass != null, "String_Node_Str");
+    Preconditions.checkArgument(jdbcDriverClass != null, "String_Node_Str" + "String_Node_Str", dbSinkConfig.jdbcPluginName, dbSinkConfig.jdbcPluginName, dbSinkConfig.jdbcPluginType);
 }


Input:
final int broadcastIntentLocked(ProcessRecord callerApp, String callerPackage, Intent intent, String resolvedType, IIntentReceiver resultTo, int resultCode, String resultData, Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions, boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {
    intent = new Intent(intent);
    intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
    if (!mProcessesReady && (intent.getFlags() & Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) {
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
    }
    if (DEBUG_BROADCAST_LIGHT)
        Slog.v(TAG_BROADCAST, (sticky ? "String_Node_Str" : "String_Node_Str") + intent + "String_Node_Str" + ordered + "String_Node_Str" + userId);
    if ((resultTo != null) && !ordered) {
        Slog.w(TAG, "String_Node_Str" + intent + "String_Node_Str");
    }
    userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, true, ALLOW_NON_FULL, "String_Node_Str", callerPackage);
    if (userId != UserHandle.USER_ALL && !mUserController.isUserRunningLocked(userId, 0)) {
        if ((callingUid != Process.SYSTEM_UID || (intent.getFlags() & Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) && !Intent.ACTION_SHUTDOWN.equals(intent.getAction())) {
            Slog.w(TAG, "String_Node_Str" + intent + "String_Node_Str" + userId + "String_Node_Str");
            return ActivityManager.BROADCAST_FAILED_USER_STOPPED;
        }
    }
    BroadcastOptions brOptions = null;
    if (bOptions != null) {
        brOptions = new BroadcastOptions(bOptions);
        if (brOptions.getTemporaryAppWhitelistDuration() > 0) {
            if (checkComponentPermission(android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST, Binder.getCallingPid(), Binder.getCallingUid(), -1, true) != PackageManager.PERMISSION_GRANTED) {
                String msg = "String_Node_Str" + intent.getAction() + "String_Node_Str" + callerPackage + "String_Node_Str" + callingPid + "String_Node_Str" + callingUid + "String_Node_Str" + "String_Node_Str" + android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST;
                Slog.w(TAG, msg);
                throw new SecurityException(msg);
            }
        }
    }
    final String action = intent.getAction();
    final boolean isProtectedBroadcast;
    try {
        isProtectedBroadcast = AppGlobals.getPackageManager().isProtectedBroadcast(action);
    } catch (RemoteException e) {
        Slog.w(TAG, "String_Node_Str", e);
        return ActivityManager.BROADCAST_SUCCESS;
    }
    final boolean isCallerSystem;
    switch(UserHandle.getAppId(callingUid)) {
        case Process.ROOT_UID:
        case Process.SYSTEM_UID:
        case Process.PHONE_UID:
        case Process.BLUETOOTH_UID:
        case Process.NFC_UID:
            isCallerSystem = true;
            break;
        default:
            isCallerSystem = (callerApp != null) && callerApp.persistent;
            break;
    }
    if (isCallerSystem) {
        if (isProtectedBroadcast || Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(action) || Intent.ACTION_DISMISS_KEYBOARD_SHORTCUTS.equals(action) || Intent.ACTION_MEDIA_BUTTON.equals(action) || Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) || Intent.ACTION_SHOW_KEYBOARD_SHORTCUTS.equals(action) || AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(action) || AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action) || LocationManager.HIGH_POWER_REQUEST_CHANGE_ACTION.equals(action) || TelephonyIntents.ACTION_REQUEST_OMADM_CONFIGURATION_UPDATE.equals(action) || SuggestionSpan.ACTION_SUGGESTION_PICKED.equals(action)) {
        } else {
            if (callerApp != null) {
                Log.wtf(TAG, "String_Node_Str" + action + "String_Node_Str" + callerApp.toShortString() + "String_Node_Str" + callerPackage, new Throwable());
            } else {
                Log.wtf(TAG, "String_Node_Str" + action + "String_Node_Str" + UserHandle.formatUid(callingUid) + "String_Node_Str" + callerPackage, new Throwable());
            }
        }
    } else {
        if (isProtectedBroadcast) {
            String msg = "String_Node_Str" + action + "String_Node_Str" + callingPid + "String_Node_Str" + callingUid;
            Slog.w(TAG, msg);
            throw new SecurityException(msg);
        } else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(action) || AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action)) {
            if (callerPackage == null) {
                String msg = "String_Node_Str" + action + "String_Node_Str";
                Slog.w(TAG, msg);
                throw new SecurityException(msg);
            } else if (intent.getComponent() != null) {
                if (!intent.getComponent().getPackageName().equals(callerPackage)) {
                    String msg = "String_Node_Str" + action + "String_Node_Str" + intent.getComponent().getPackageName() + "String_Node_Str" + callerPackage;
                    Slog.w(TAG, msg);
                    throw new SecurityException(msg);
                }
            } else {
                intent.setPackage(callerPackage);
            }
        }
    }
    if (action != null) {
        switch(action) {
            case Intent.ACTION_UID_REMOVED:
            case Intent.ACTION_PACKAGE_REMOVED:
            case Intent.ACTION_PACKAGE_CHANGED:
            case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE:
            case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE:
            case Intent.ACTION_PACKAGES_SUSPENDED:
            case Intent.ACTION_PACKAGES_UNSUSPENDED:
                if (checkComponentPermission(android.Manifest.permission.BROADCAST_PACKAGE_REMOVED, callingPid, callingUid, -1, true) != PackageManager.PERMISSION_GRANTED) {
                    String msg = "String_Node_Str" + intent.getAction() + "String_Node_Str" + callerPackage + "String_Node_Str" + callingPid + "String_Node_Str" + callingUid + "String_Node_Str" + "String_Node_Str" + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED;
                    Slog.w(TAG, msg);
                    throw new SecurityException(msg);
                }
                switch(action) {
                    case Intent.ACTION_UID_REMOVED:
                        final Bundle intentExtras = intent.getExtras();
                        final int uid = intentExtras != null ? intentExtras.getInt(Intent.EXTRA_UID) : -1;
                        if (uid >= 0) {
                            mBatteryStatsService.removeUid(uid);
                            mAppOpsService.uidRemoved(uid);
                        }
                        break;
                    case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE:
                        String[] list = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
                        if (list != null && list.length > 0) {
                            for (int i = 0; i < list.length; i++) {
                                forceStopPackageLocked(list[i], -1, false, true, true, false, false, userId, "String_Node_Str");
                            }
                            mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
                            sendPackageBroadcastLocked(IApplicationThread.EXTERNAL_STORAGE_UNAVAILABLE, list, userId);
                        }
                        break;
                    case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE:
                        mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
                        break;
                    case Intent.ACTION_PACKAGE_REMOVED:
                    case Intent.ACTION_PACKAGE_CHANGED:
                        Uri data = intent.getData();
                        String ssp;
                        if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {
                            boolean removed = Intent.ACTION_PACKAGE_REMOVED.equals(action);
                            final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
                            final boolean killProcess = !intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP, false);
                            final boolean fullUninstall = removed && !replacing;
                            if (removed) {
                                if (killProcess) {
                                    forceStopPackageLocked(ssp, UserHandle.getAppId(intent.getIntExtra(Intent.EXTRA_UID, -1)), false, true, true, false, fullUninstall, userId, removed ? "String_Node_Str" : "String_Node_Str");
                                }
                                final int cmd = killProcess ? IApplicationThread.PACKAGE_REMOVED : IApplicationThread.PACKAGE_REMOVED_DONT_KILL;
                                sendPackageBroadcastLocked(cmd, new String[] { ssp }, userId);
                                if (fullUninstall) {
                                    mAppOpsService.packageRemoved(intent.getIntExtra(Intent.EXTRA_UID, -1), ssp);
                                    removeUriPermissionsForPackageLocked(ssp, userId, true);
                                    removeTasksByPackageNameLocked(ssp, userId);
                                    if (mUnsupportedDisplaySizeDialog != null && ssp.equals(mUnsupportedDisplaySizeDialog.getPackageName())) {
                                        mUnsupportedDisplaySizeDialog.dismiss();
                                        mUnsupportedDisplaySizeDialog = null;
                                    }
                                    mCompatModePackages.handlePackageUninstalledLocked(ssp);
                                    mBatteryStatsService.notePackageUninstalled(ssp);
                                }
                            } else {
                                if (killProcess) {
                                    killPackageProcessesLocked(ssp, UserHandle.getAppId(intent.getIntExtra(Intent.EXTRA_UID, -1)), userId, ProcessList.INVALID_ADJ, false, true, true, false, "String_Node_Str" + ssp);
                                }
                                cleanupDisabledPackageComponentsLocked(ssp, userId, killProcess, intent.getStringArrayExtra(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST));
                            }
                        }
                        break;
                    case Intent.ACTION_PACKAGES_SUSPENDED:
                    case Intent.ACTION_PACKAGES_UNSUSPENDED:
                        final boolean suspended = Intent.ACTION_PACKAGES_SUSPENDED.equals(intent.getAction());
                        final String[] packageNames = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
                        final int userHandle = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
                        synchronized (ActivityManagerService.this) {
                            mRecentTasks.onPackagesSuspendedChanged(packageNames, suspended, userHandle);
                        }
                        break;
                }
                break;
            case Intent.ACTION_PACKAGE_REPLACED:
                {
                    final Uri data = intent.getData();
                    final String ssp;
                    if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {
                        final ApplicationInfo aInfo = getPackageManagerInternalLocked().getApplicationInfo(ssp, userId);
                        if (aInfo == null) {
                            Slog.w(TAG, "String_Node_Str" + "String_Node_Str" + ssp + "String_Node_Str" + data);
                            return ActivityManager.BROADCAST_SUCCESS;
                        }
                        mStackSupervisor.updateActivityApplicationInfoLocked(aInfo);
                        sendPackageBroadcastLocked(IApplicationThread.PACKAGE_REPLACED, new String[] { ssp }, userId);
                    }
                    break;
                }
            case Intent.ACTION_PACKAGE_ADDED:
                {
                    Uri data = intent.getData();
                    String ssp;
                    if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {
                        final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
                        mCompatModePackages.handlePackageAddedLocked(ssp, replacing);
                        try {
                            ApplicationInfo ai = AppGlobals.getPackageManager().getApplicationInfo(ssp, 0, 0);
                            mBatteryStatsService.notePackageInstalled(ssp, ai != null ? ai.versionCode : 0);
                        } catch (RemoteException e) {
                        }
                    }
                    break;
                }
            case Intent.ACTION_PACKAGE_DATA_CLEARED:
                {
                    Uri data = intent.getData();
                    String ssp;
                    if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {
                        if (mUnsupportedDisplaySizeDialog != null && ssp.equals(mUnsupportedDisplaySizeDialog.getPackageName())) {
                            mUnsupportedDisplaySizeDialog.dismiss();
                            mUnsupportedDisplaySizeDialog = null;
                        }
                        mCompatModePackages.handlePackageDataClearedLocked(ssp);
                    }
                    break;
                }
            case Intent.ACTION_TIMEZONE_CHANGED:
                mHandler.sendEmptyMessage(UPDATE_TIME_ZONE);
                break;
            case Intent.ACTION_TIME_CHANGED:
                final int is24Hour = intent.getBooleanExtra(Intent.EXTRA_TIME_PREF_24_HOUR_FORMAT, false) ? 1 : 0;
                mHandler.sendMessage(mHandler.obtainMessage(UPDATE_TIME, is24Hour, 0));
                BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
                synchronized (stats) {
                    stats.noteCurrentTimeChangedLocked();
                }
                break;
            case Intent.ACTION_CLEAR_DNS_CACHE:
                mHandler.sendEmptyMessage(CLEAR_DNS_CACHE_MSG);
                break;
            case Proxy.PROXY_CHANGE_ACTION:
                ProxyInfo proxy = intent.getParcelableExtra(Proxy.EXTRA_PROXY_INFO);
                mHandler.sendMessage(mHandler.obtainMessage(UPDATE_HTTP_PROXY_MSG, proxy));
                break;
            case android.hardware.Camera.ACTION_NEW_PICTURE:
            case android.hardware.Camera.ACTION_NEW_VIDEO:
                Slog.w(TAG, action + "String_Node_Str" + UserHandle.formatUid(callingUid));
                if (resultTo != null) {
                    final BroadcastQueue queue = broadcastQueueForIntent(intent);
                    try {
                        queue.performReceiveLocked(callerApp, resultTo, intent, Activity.RESULT_CANCELED, null, null, false, false, userId);
                    } catch (RemoteException e) {
                        Slog.w(TAG, "String_Node_Str" + queue.mQueueName + "String_Node_Str" + intent, e);
                    }
                }
                return ActivityManager.BROADCAST_SUCCESS;
        }
    }
    if (sticky) {
        if (checkPermission(android.Manifest.permission.BROADCAST_STICKY, callingPid, callingUid) != PackageManager.PERMISSION_GRANTED) {
            String msg = "String_Node_Str" + callingPid + "String_Node_Str" + callingUid + "String_Node_Str" + android.Manifest.permission.BROADCAST_STICKY;
            Slog.w(TAG, msg);
            throw new SecurityException(msg);
        }
        if (requiredPermissions != null && requiredPermissions.length > 0) {
            Slog.w(TAG, "String_Node_Str" + intent + "String_Node_Str" + Arrays.toString(requiredPermissions));
            return ActivityManager.BROADCAST_STICKY_CANT_HAVE_PERMISSION;
        }
        if (intent.getComponent() != null) {
            throw new SecurityException("String_Node_Str");
        }
        if (userId != UserHandle.USER_ALL) {
            ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(UserHandle.USER_ALL);
            if (stickies != null) {
                ArrayList<Intent> list = stickies.get(intent.getAction());
                if (list != null) {
                    int N = list.size();
                    int i;
                    for (i = 0; i < N; i++) {
                        if (intent.filterEquals(list.get(i))) {
                            throw new IllegalArgumentException("String_Node_Str" + intent + "String_Node_Str" + userId + "String_Node_Str");
                        }
                    }
                }
            }
        }
        ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId);
        if (stickies == null) {
            stickies = new ArrayMap<>();
            mStickyBroadcasts.put(userId, stickies);
        }
        ArrayList<Intent> list = stickies.get(intent.getAction());
        if (list == null) {
            list = new ArrayList<>();
            stickies.put(intent.getAction(), list);
        }
        final int stickiesCount = list.size();
        int i;
        for (i = 0; i < stickiesCount; i++) {
            if (intent.filterEquals(list.get(i))) {
                list.set(i, new Intent(intent));
                break;
            }
        }
        if (i >= stickiesCount) {
            list.add(new Intent(intent));
        }
    }
    int[] users;
    if (userId == UserHandle.USER_ALL) {
        users = mUserController.getStartedUserArrayLocked();
    } else {
        users = new int[] { userId };
    }
    List receivers = null;
    List<BroadcastFilter> registeredReceivers = null;
    if ((intent.getFlags() & Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
        receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
    }
    if (intent.getComponent() == null) {
        if (userId == UserHandle.USER_ALL && callingUid == Process.SHELL_UID) {
            for (int i = 0; i < users.length; i++) {
                if (mUserController.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, users[i])) {
                    continue;
                }
                List<BroadcastFilter> registeredReceiversForUser = mReceiverResolver.queryIntent(intent, resolvedType, false, users[i]);
                if (registeredReceivers == null) {
                    registeredReceivers = registeredReceiversForUser;
                } else if (registeredReceiversForUser != null) {
                    registeredReceivers.addAll(registeredReceiversForUser);
                }
            }
        } else {
            registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false, userId);
        }
    }
    final boolean replacePending = (intent.getFlags() & Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;
    if (DEBUG_BROADCAST)
        Slog.v(TAG_BROADCAST, "String_Node_Str" + intent.getAction() + "String_Node_Str" + replacePending);
    int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
    if (!ordered && NR > 0) {
        final BroadcastQueue queue = broadcastQueueForIntent(intent);
        BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, callerPackage, callingPid, callingUid, resolvedType, requiredPermissions, appOp, brOptions, registeredReceivers, resultTo, resultCode, resultData, resultExtras, ordered, sticky, false, userId);
        if (DEBUG_BROADCAST)
            Slog.v(TAG_BROADCAST, "String_Node_Str" + r);
        final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
        if (!replaced) {
            queue.enqueueParallelBroadcastLocked(r);
            queue.scheduleBroadcastsLocked();
        }
        registeredReceivers = null;
        NR = 0;
    }
    int ir = 0;
    if (receivers != null) {
        String[] skipPackages = null;
        if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction()) || Intent.ACTION_PACKAGE_RESTARTED.equals(intent.getAction()) || Intent.ACTION_PACKAGE_DATA_CLEARED.equals(intent.getAction())) {
            Uri data = intent.getData();
            if (data != null) {
                String pkgName = data.getSchemeSpecificPart();
                if (pkgName != null) {
                    skipPackages = new String[] { pkgName };
                }
            }
        } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(intent.getAction())) {
            skipPackages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
        }
        if (skipPackages != null && (skipPackages.length > 0)) {
            for (String skipPackage : skipPackages) {
                if (skipPackage != null) {
                    int NT = receivers.size();
                    for (int it = 0; it < NT; it++) {
                        ResolveInfo curt = (ResolveInfo) receivers.get(it);
                        if (curt.activityInfo.packageName.equals(skipPackage)) {
                            receivers.remove(it);
                            it--;
                            NT--;
                        }
                    }
                }
            }
        }
        int NT = receivers != null ? receivers.size() : 0;
        int it = 0;
        ResolveInfo curt = null;
        BroadcastFilter curr = null;
        while (it < NT && ir < NR) {
            if (curt == null) {
                curt = (ResolveInfo) receivers.get(it);
            }
            if (curr == null) {
                curr = registeredReceivers.get(ir);
            }
            if (curr.getPriority() >= curt.priority) {
                receivers.add(it, curr);
                ir++;
                curr = null;
                it++;
                NT++;
            } else {
                it++;
                curt = null;
            }
        }
    }
    while (ir < NR) {
        if (receivers == null) {
            receivers = new ArrayList();
        }
        receivers.add(registeredReceivers.get(ir));
        ir++;
    }
    if ((receivers != null && receivers.size() > 0) || resultTo != null) {
        BroadcastQueue queue = broadcastQueueForIntent(intent);
        BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, callerPackage, callingPid, callingUid, resolvedType, requiredPermissions, appOp, brOptions, receivers, resultTo, resultCode, resultData, resultExtras, ordered, sticky, false, userId);
        if (DEBUG_BROADCAST)
            Slog.v(TAG_BROADCAST, "String_Node_Str" + r + "String_Node_Str" + queue.mOrderedBroadcasts.size());
        if (DEBUG_BROADCAST)
            Slog.i(TAG_BROADCAST, "String_Node_Str" + r.intent.getAction());
        boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r);
        if (!replaced) {
            queue.enqueueOrderedBroadcastLocked(r);
            queue.scheduleBroadcastsLocked();
        }
    } else {
        if (intent.getComponent() == null && intent.getPackage() == null && (intent.getFlags() & Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
            addBroadcastStatLocked(intent.getAction(), callerPackage, 0, 0, 0);
        }
    }
    return ActivityManager.BROADCAST_SUCCESS;
}

Output:
     }
-    if (isCallerSystem) {
-        if (isProtectedBroadcast || Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(action) || Intent.ACTION_DISMISS_KEYBOARD_SHORTCUTS.equals(action) || Intent.ACTION_MEDIA_BUTTON.equals(action) || Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) || Intent.ACTION_SHOW_KEYBOARD_SHORTCUTS.equals(action) || AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(action) || AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action) || LocationManager.HIGH_POWER_REQUEST_CHANGE_ACTION.equals(action) || TelephonyIntents.ACTION_REQUEST_OMADM_CONFIGURATION_UPDATE.equals(action) || SuggestionSpan.ACTION_SUGGESTION_PICKED.equals(action)) {
-        } else {
-            if (callerApp != null) {
-                Log.wtf(TAG, "String_Node_Str" + action + "String_Node_Str" + callerApp.toShortString() + "String_Node_Str" + callerPackage, new Throwable());
-            } else {
-                Log.wtf(TAG, "String_Node_Str" + action + "String_Node_Str" + UserHandle.formatUid(callingUid) + "String_Node_Str" + callerPackage, new Throwable());
-            }
-        }
-    } else {
+    if (!isCallerSystem) {
         if (isProtectedBroadcast) {


Input:
public void upgrade() {
    if (!this.upgraded) {
        upgradeName();
        upgradeDamage(UPGRADE_PLUS_DMG);
    }
}

Output:
         upgradeName();
-        upgradeDamage(UPGRADE_PLUS_DMG);
+        upgradeBaseCost(UPGRADED_COST);
     }


Input:
public void render(Pipe<PipeTransportFluids> pipe, double x, double y, double z, float f) {
    PipeTransportFluids trans = pipe.transport;
    boolean needsRender = false;
    FluidRenderData renderData = trans.renderCache;
    for (int i = 0; i < 7; ++i) {
        if (renderData.amount[i] > 0) {
            needsRender = true;
            break;
        }
    }
    if (!needsRender) {
        return;
    }
    if (pipe.container == null)
        return;
    GL11.glPushMatrix();
    GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
    GL11.glEnable(GL11.GL_CULL_FACE);
    GL11.glDisable(GL11.GL_LIGHTING);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glTranslatef((float) x, (float) y, (float) z);
    int skylight = pipe.container.getWorld().getSkyBlockTypeBrightness(EnumSkyBlock.Sky, pipe.container.x(), pipe.container.y(), pipe.container.z());
    int blocklight = pipe.container.getWorld().getSkyBlockTypeBrightness(EnumSkyBlock.Block, pipe.container.x(), pipe.container.y(), pipe.container.z());
    boolean sides = false, above = false;
    for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
        int i = side.ordinal();
        if (renderData.amount[i] <= 0) {
            continue;
        }
        if (!pipe.container.isPipeConnected(side)) {
            continue;
        }
        DisplayFluidList d = getDisplayFluidLists(renderData.fluidID, skylight, blocklight, renderData.flags, pipe.container.getWorldObj());
        if (d == null) {
            continue;
        }
        int stage = (int) ((float) renderData.amount[i] / (float) (trans.getCapacity()) * (LIQUID_STAGES - 1));
        GL11.glPushMatrix();
        int list = 0;
        switch(ForgeDirection.VALID_DIRECTIONS[i]) {
            case UP:
                above = true;
                list = d.sideVertical[stage];
                break;
            case DOWN:
                GL11.glTranslatef(0, -0.75F, 0);
                list = d.sideVertical[stage];
                break;
            case EAST:
            case WEST:
            case SOUTH:
            case NORTH:
                sides = true;
                GL11.glTranslatef(0.5F, 0.0F, 0.5F);
                GL11.glRotatef(angleY[i], 0, 1, 0);
                GL11.glRotatef(angleZ[i], 0, 0, 1);
                GL11.glTranslatef(-0.5F, 0.0F, -0.5F);
                list = d.sideHorizontal[stage];
                break;
            default:
        }
        bindTexture(TextureMap.locationBlocksTexture);
        RenderUtils.setGLColorFromInt(renderData.color);
        GL11.glCallList(list);
        GL11.glPopMatrix();
    }
    if (renderData.amount[6] > 0) {
        DisplayFluidList d = getDisplayFluidLists(renderData.fluidID, skylight, blocklight, renderData.flags, pipe.container.getWorldObj());
        if (d != null) {
            int stage = (int) ((float) renderData.amount[6] / (float) (trans.getCapacity()) * (LIQUID_STAGES - 1));
            bindTexture(TextureMap.locationBlocksTexture);
            RenderUtils.setGLColorFromInt(renderData.color);
            if (above) {
                GL11.glCallList(d.centerVertical[stage]);
            }
            if (!above || sides) {
                GL11.glCallList(d.centerHorizontal[stage]);
            }
        }
    }
    GL11.glPopAttrib();
    GL11.glPopMatrix();
}

Output:
     }
-    if (pipe.container == null)
+    if (pipe.container == null) {
         return;


Input:
public void createContent(Composite parent) {
    parent.setLayout(new GridLayout(2, false));
    dataFilterText = new Text(parent, SWT.BORDER | SWT.MULTI);
    DataFilterDND.installDND(dataFilterText);
    dataFilterText.setToolTipText(DefaultMessagesImpl.getString("String_Node_Str"));
    dataFilterText.setText(stringDataFilter == null ? PluginConstant.EMPTY_STRING : stringDataFilter);
    GridDataFactory.fillDefaults().grab(true, true).applyTo(dataFilterText);
    ((GridData) dataFilterText.getLayoutData()).heightHint = 150;
    dataFilterText.addModifyListener(new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            setDirty(true);
            propertyChangeSupport.firePropertyChange(PluginConstant.DATAFILTER_PROPERTY, null, dataFilterText.getText());
        }
    });
    Composite buttonsComp = new Composite(parent, SWT.None);
    GridDataFactory.fillDefaults().span(1, 1).applyTo(buttonsComp);
    buttonsComp.setLayout(new GridLayout(1, true));
    buttonsComp.setVisible(true);
    Button button = new Button(buttonsComp, SWT.None);
    button.setText(DefaultMessagesImpl.getString("String_Node_Str"));
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.TOP).applyTo(button);
}

Output:
 public void createContent(Composite parent) {
-    parent.setLayout(new GridLayout(2, false));
+    parent.setLayout(new GridLayout());
     dataFilterText = new Text(parent, SWT.BORDER | SWT.MULTI);


Input:
public void transferDefaults() {
    OptionDataset od = datasets.getItemAt(datasets.getSelectedIndex());
    aggregators.setSelectedItem(od.defaultAggregator());
    transferBuilder.configureTo(od.defaultTransfers());
    actionProvider.fireActionListeners();
}

Output:
 public void transferDefaults() {
-    OptionDataset od = datasets.getItemAt(datasets.getSelectedIndex());
+    OptionDataset<?, ?> od = datasets.getItemAt(datasets.getSelectedIndex());
     aggregators.setSelectedItem(od.defaultAggregator());


Input:
public void cmdUser(Context ctx) throws UnsupportedEncodingException {
    User user;
    if (ctx.rawArgs.matches("String_Node_Str"))
        user = ctx.message.getMentionedUsers().get(0);
    else if (ctx.rawArgs.matches("String_Node_Str"))
        user = ctx.jda.retrieveUserById(Long.parseUnsignedLong(ctx.rawArgs)).complete();
    else if (ctx.rawArgs.matches("String_Node_Str")) {
        Collection<User> users;
        switch(ctx.channel.getType()) {
            case TEXT:
                users = ctx.guild.getMembers().stream().map(m -> m.getUser()).collect(Collectors.toList());
                break;
            case PRIVATE:
                users = Arrays.asList(ctx.author, ctx.jda.getSelfUser());
                break;
            case GROUP:
                users = ((Group) ctx.channel).getUsers();
                break;
            default:
                users = Collections.singletonList(ctx.jda.getSelfUser());
                break;
        }
        user = users.stream().filter(u -> getTag(u).contentEquals(ctx.rawArgs)).findFirst().orElse(null);
    } else if (ctx.rawArgs.length() < 1)
        user = ctx.author;
    else
        user = null;
    if (user == null) {
        ctx.send(NO_USER).queue();
        return;
    }
    EmbedBuilder emb = new EmbedBuilder().setColor(randomColor()).setAuthor(getTag(user), user.getEffectiveAvatarUrl(), user.getEffectiveAvatarUrl()).setThumbnail(user.getEffectiveAvatarUrl()).addField("String_Node_Str", user.getId(), true).addField("String_Node_Str", user.getCreationTime().toString(), true).addField("String_Node_Str", user.isBot() ? "String_Node_Str" : "String_Node_Str", true);
    if (ctx.guild != null) {
        Member member = ctx.guild.getMember(user);
        if (member != null) {
            if (member.getNickname() != null)
                emb.addField("String_Node_Str", member.getNickname(), true);
            String status;
            if (member.getGame() == null)
                status = WordUtils.capitalizeFully(member.getOnlineStatus().name().replace('_', ' '));
            else {
                Game game = member.getGame();
                if (game.getType() == Game.GameType.TWITCH) {
                    status = "String_Node_Str" + game.getName() + "String_Node_Str" + game.getUrl() + "String_Node_Str";
                } else {
                    status = "String_Node_Str" + game.getName() + "String_Node_Str" + URLEncoder.encode(game.getName(), "String_Node_Str") + ')';
                }
            }
            emb.setColor(member.getColor()).addField("String_Node_Str", status, true).addField("String_Node_Str", member.getRoles().stream().map(r -> r.getName()).collect(Collectors.joining("String_Node_Str")), true);
        }
    }
    ctx.send(emb.build()).queue();
}

Output:
     }
-    EmbedBuilder emb = new EmbedBuilder().setColor(randomColor()).setAuthor(getTag(user), user.getEffectiveAvatarUrl(), user.getEffectiveAvatarUrl()).setThumbnail(user.getEffectiveAvatarUrl()).addField("String_Node_Str", user.getId(), true).addField("String_Node_Str", user.getCreationTime().toString(), true).addField("String_Node_Str", user.isBot() ? "String_Node_Str" : "String_Node_Str", true);
+    EmbedBuilder emb = new EmbedBuilder().setColor(randomColor()).setAuthor(getTag(user), user.getEffectiveAvatarUrl(), user.getEffectiveAvatarUrl()).setThumbnail(user.getEffectiveAvatarUrl()).addField("String_Node_Str", user.getId(), true).addField("String_Node_Str", Date.from(user.getCreationTime().toInstant()).toString(), true).addField("String_Node_Str", user.isBot() ? "String_Node_Str" : "String_Node_Str", true);
     if (ctx.guild != null) {


Input:
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
    if (s_logger.isInfoEnabled()) {
        s_logger.info("String_Node_Str" + name);
    }
    _name = name;
    ComponentLocator locator = ComponentLocator.getCurrentLocator();
    ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
    if (configDao == null) {
        throw new ConfigurationException("String_Node_Str");
    }
    Map<String, String> configs = configDao.getConfiguration("String_Node_Str", params);
    _proxyRamSize = NumbersUtil.parseInt(configs.get("String_Node_Str"), DEFAULT_PROXY_VM_RAMSIZE);
    String value = configs.get("String_Node_Str");
    _proxyCmdPort = NumbersUtil.parseInt(value, DEFAULT_PROXY_CMD_PORT);
    value = configs.get("String_Node_Str");
    if (value != null && value.equalsIgnoreCase("String_Node_Str")) {
        _sslEnabled = true;
    }
    value = configs.get("String_Node_Str");
    _capacityScanInterval = NumbersUtil.parseLong(value, DEFAULT_CAPACITY_SCAN_INTERVAL);
    _capacityPerProxy = NumbersUtil.parseInt(configs.get("String_Node_Str"), DEFAULT_PROXY_CAPACITY);
    _standbyCapacity = NumbersUtil.parseInt(configs.get("String_Node_Str"), DEFAULT_STANDBY_CAPACITY);
    _proxySessionTimeoutValue = NumbersUtil.parseInt(configs.get("String_Node_Str"), DEFAULT_PROXY_SESSION_TIMEOUT);
    value = configs.get("String_Node_Str");
    if (value != null) {
        _consoleProxyPort = NumbersUtil.parseInt(value, ConsoleProxyManager.DEFAULT_PROXY_VNC_PORT);
    }
    value = configs.get("String_Node_Str");
    if (value != null) {
        _consoleProxyUrlPort = NumbersUtil.parseInt(value, ConsoleProxyManager.DEFAULT_PROXY_URL_PORT);
    }
    value = configs.get(Config.ConsoleProxyDisableRpFilter.key());
    if (value != null && value.equalsIgnoreCase("String_Node_Str")) {
        _disable_rp_filter = true;
    }
    value = configs.get("String_Node_Str");
    if (value != null && value.equalsIgnoreCase("String_Node_Str")) {
        _use_lvm = true;
    }
    value = configs.get("String_Node_Str");
    if (value != null && value.equalsIgnoreCase("String_Node_Str")) {
        _use_storage_vm = true;
    }
    if (s_logger.isInfoEnabled()) {
        s_logger.info("String_Node_Str" + _capacityPerProxy);
        s_logger.info("String_Node_Str" + _standbyCapacity);
    }
    _domain = configs.get("String_Node_Str");
    if (_domain == null) {
        _domain = "String_Node_Str";
    }
    _instance = configs.get("String_Node_Str");
    if (_instance == null) {
        _instance = "String_Node_Str";
    }
    value = (String) params.get("String_Node_Str");
    _ssh_sleep = NumbersUtil.parseInt(value, 5) * 1000;
    value = (String) params.get("String_Node_Str");
    _ssh_retry = NumbersUtil.parseInt(value, 3);
    Map<String, String> agentMgrConfigs = configDao.getConfiguration("String_Node_Str", params);
    _mgmt_host = agentMgrConfigs.get("String_Node_Str");
    if (_mgmt_host == null) {
        s_logger.warn("String_Node_Str");
    }
    value = agentMgrConfigs.get("String_Node_Str");
    _mgmt_port = NumbersUtil.parseInt(value, 8250);
    _consoleProxyAllocators = locator.getAdapters(ConsoleProxyAllocator.class);
    if (_consoleProxyAllocators == null || !_consoleProxyAllocators.isSet()) {
        throw new ConfigurationException("String_Node_Str");
    }
    _listener = new ConsoleProxyListener(this);
    _agentMgr.registerForHostEvents(_listener, true, true, false);
    HighAvailabilityManager haMgr = locator.getManager(HighAvailabilityManager.class);
    if (haMgr != null) {
        haMgr.registerHandler(VirtualMachine.Type.ConsoleProxy, this);
    }
    _itMgr.registerGuru(VirtualMachine.Type.ConsoleProxy, this);
    boolean useLocalStorage = Boolean.parseBoolean(configs.get(Config.SystemVMUseLocalStorage.key()));
    _serviceOffering = new ServiceOfferingVO("String_Node_Str", 1, _proxyRamSize, 0, 0, 0, true, null, NetworkOffering.GuestIpType.Virtual, useLocalStorage, true, null, true);
    _serviceOffering.setUniqueName("String_Node_Str");
    _serviceOffering = _offeringDao.persistSystemServiceOffering(_serviceOffering);
    _template = _templateDao.findConsoleProxyTemplate();
    if (_template == null) {
        throw new ConfigurationException("String_Node_Str");
    }
    _capacityScanScheduler.scheduleAtFixedRate(getCapacityScanTask(), STARTUP_DELAY, _capacityScanInterval, TimeUnit.MILLISECONDS);
    if (s_logger.isInfoEnabled()) {
        s_logger.info("String_Node_Str");
    }
    return true;
}

Output:
     boolean useLocalStorage = Boolean.parseBoolean(configs.get(Config.SystemVMUseLocalStorage.key()));
-    _serviceOffering = new ServiceOfferingVO("String_Node_Str", 1, _proxyRamSize, 0, 0, 0, true, null, NetworkOffering.GuestIpType.Virtual, useLocalStorage, true, null, true);
+    _serviceOffering = new ServiceOfferingVO("String_Node_Str", 1, _proxyRamSize, 0, 0, 0, true, null, Network.GuestIpType.Virtual, useLocalStorage, true, null, true);
     _serviceOffering.setUniqueName("String_Node_Str");


Input:
public static String escapeForResXml(String value) {
    if (value.isEmpty()) {
        return value;
    }
    StringBuilder out = new StringBuilder(value.length() + 10);
    char[] chars = value.toCharArray();
    switch(chars[0]) {
        case '@':
        case '#':
        case '?':
            out.append('\\');
    }
    boolean space = true;
    for (int i = 0; i < chars.length; i++) {
        char c = chars[i];
        if (c == ' ') {
            if (space) {
                out.append("String_Node_Str");
            } else {
                out.append(c);
                space = true;
            }
            continue;
        }
        space = false;
        switch(c) {
            case '\\':
            case '\'':
            case '"':
                out.append('\\');
                break;
            case '\n':
                out.append("String_Node_Str");
                continue;
        }
        out.append(c);
    }
    if (space) {
        out.deleteCharAt(out.length() - 1);
        out.append("String_Node_Str");
    }
    return out.toString();
}

Output:
     }
-    if (space) {
+    if (space && out.charAt(out.length() - 1) == ' ') {
         out.deleteCharAt(out.length() - 1);


Input:
public boolean checkRemoteVersions(Map<String, String> versions, Side side) {
    if (versions.containsKey(MOD_ID)) {
        String clientVer = Loader.instance().getReversedModObjectList().get(this).getVersion();
        if (VersionParser.parseRange("String_Node_Str" + clientVer + "String_Node_Str").containsVersion(new DefaultArtifactVersion(versions.get(MOD_ID)))) {
            logger.warn(String.format("String_Node_Str", side.toString(), clientVer, versions.get(MOD_ID)));
        } else {
            logger.debug(String.format("String_Node_Str", side.toString(), clientVer, versions.get(MOD_ID)));
            hasRemote = true;
        }
    }
    return true;
}

Output:
         String clientVer = Loader.instance().getReversedModObjectList().get(this).getVersion();
-        if (VersionParser.parseRange("String_Node_Str" + clientVer + "String_Node_Str").containsVersion(new DefaultArtifactVersion(versions.get(MOD_ID)))) {
-            logger.warn(String.format("String_Node_Str", side.toString(), clientVer, versions.get(MOD_ID)));
+        if (!VersionParser.parseRange("String_Node_Str" + clientVer + "String_Node_Str").containsVersion(new DefaultArtifactVersion(versions.get(MOD_ID)))) {
+            logger.warn(String.format("String_Node_Str", clientVer, side.toString(), versions.get(MOD_ID)));
         } else {


Input:
public HttpGet createHttpGetRequest(String url, List<NameValuePair> nameValuePairs) {
    String queryString = URLEncodedUtils.format(sanitizeParameters(nameValuePairs), HTTP.UTF_8);
    String fullUrlString = new StringBuilder(url + "String_Node_Str" + queryString).toString();
    HttpGet httpGet = new HttpGet(fullUrlString);
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + httpGet.getURI());
    return httpGet;
}

Output:
     HttpGet httpGet = new HttpGet(fullUrlString);
-    if (DEBUG)
-        Log.d(TAG, "String_Node_Str" + httpGet.getURI());
+    Logger.log("String_Node_Str" + httpGet.getURI());
     return httpGet;


Input:
public void render() {
    if (children.isEmpty()) {
        return;
    }
    Object[] elem = children.toArray();
    for (int i = 0; i < elem.length; i++) {
        NE_GUI_Element __elem = (NE_GUI_Element) elem[i];
        __elem.render();
    }
}

Output:
 public void render() {
-    if (children.isEmpty()) {
-        return;
-    }
-    Object[] elem = children.toArray();
-    for (int i = 0; i < elem.length; i++) {
-        NE_GUI_Element __elem = (NE_GUI_Element) elem[i];
-        __elem.render();
-    }
+    render_children();
 }


Input:
private boolean isColumnChecked(List<Map<String, Object>> columnsCheckInfo, String columnLabel) {
    Map<String, Object> foundLine = null;
    for (Map<String, Object> line : columnsCheckInfo) {
        Object column = line.get(IConnection.TRACE_SCHEMA_COLUMN);
        if (columnLabel.equals(column)) {
            foundLine = line;
            break;
        }
    }
    if (foundLine != null) {
        return Boolean.valueOf(foundLine.get(IConnection.TRACE_SCHEMA_COLUMN_CHECKED).toString());
    }
    return true;
}

Output:
     }
-    return true;
+    return columnsCheckInfo == null || columnsCheckInfo.isEmpty();
 }


Input:
private void readPlacemark(XmlPullParser parser) throws XmlPullParserException, IOException {
    parser.require(XmlPullParser.START_TAG, ns, "String_Node_Str");
    gcp point = null;
    while (parser.next() != XmlPullParser.END_TAG) {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            continue;
        }
        String name = parser.getName();
        if (name.equals("String_Node_Str")) {
            point = readPoint(parser);
            if (point != null) {
                gcpList.add(point);
            }
        } else {
            skip(parser);
        }
    }
}

Output:
     parser.require(XmlPullParser.START_TAG, ns, "String_Node_Str");
-    gcp point = null;
+    Gcp point = null;
     while (parser.next() != XmlPullParser.END_TAG) {


Input:
public static boolean populateComponent(ContentValues values, ICalendar.Component component) {
    long dtstart = -1;
    if (values.containsKey(Calendar.Events.DTSTART)) {
        dtstart = values.getAsLong(Calendar.Events.DTSTART);
    }
    String duration = values.getAsString(Calendar.Events.DURATION);
    String tzid = values.getAsString(Calendar.Events.EVENT_TIMEZONE);
    String rruleStr = values.getAsString(Calendar.Events.RRULE);
    String rdateStr = values.getAsString(Calendar.Events.RDATE);
    String exruleStr = values.getAsString(Calendar.Events.EXRULE);
    String exdateStr = values.getAsString(Calendar.Events.EXDATE);
    boolean allDay = values.getAsInteger(Calendar.Events.ALL_DAY) == 1;
    if ((dtstart == -1) || (TextUtils.isEmpty(duration)) || ((TextUtils.isEmpty(rruleStr)) && (TextUtils.isEmpty(rdateStr)))) {
        return false;
    }
    ICalendar.Property dtstartProp = new ICalendar.Property("String_Node_Str");
    Time dtstartTime = null;
    if (!TextUtils.isEmpty(tzid)) {
        if (!allDay) {
            dtstartProp.addParameter(new ICalendar.Parameter("String_Node_Str", tzid));
        }
        dtstartTime = new Time(tzid);
    } else {
        dtstartTime = new Time(Time.TIMEZONE_UTC);
    }
    dtstartTime.set(dtstart);
    if (allDay) {
        dtstartProp.addParameter(new ICalendar.Parameter("String_Node_Str", "String_Node_Str"));
        dtstartTime.allDay = true;
        dtstartTime.hour = 0;
        dtstartTime.minute = 0;
        dtstartTime.second = 0;
    }
    dtstartProp.setValue(dtstartTime.format2445());
    component.addProperty(dtstartProp);
    ICalendar.Property durationProp = new ICalendar.Property("String_Node_Str");
    durationProp.setValue(duration);
    component.addProperty(durationProp);
    addPropertiesForRuleStr(component, "String_Node_Str", rruleStr);
    addPropertyForDateStr(component, "String_Node_Str", rdateStr);
    addPropertiesForRuleStr(component, "String_Node_Str", exruleStr);
    addPropertyForDateStr(component, "String_Node_Str", exdateStr);
    return true;
}

Output:
     String exdateStr = values.getAsString(Calendar.Events.EXDATE);
-    boolean allDay = values.getAsInteger(Calendar.Events.ALL_DAY) == 1;
+    Integer allDayInteger = values.getAsInteger(Calendar.Events.ALL_DAY);
+    boolean allDay = (null != allDayInteger) ? (allDayInteger == 1) : false;
     if ((dtstart == -1) || (TextUtils.isEmpty(duration)) || ((TextUtils.isEmpty(rruleStr)) && (TextUtils.isEmpty(rdateStr)))) {


Input:
private void refreshBatteryDisplay() {
    if (!mShowingBatteryInfo || !mSimOk) {
        mBatteryInfoGroup.setVisibility(View.GONE);
        mBatteryInfoSpacer.setVisibility(View.GONE);
        return;
    }
    mBatteryInfoGroup.setVisibility(View.VISIBLE);
    mBatteryInfoSpacer.setVisibility(View.VISIBLE);
    if (mPluggedIn) {
        mBatteryInfoIcon.setImageResource(R.drawable.ic_lock_idle_charging);
        mBatteryInfoText.setText(getContext().getString(R.string.lockscreen_plugged_in, mBatteryLevel));
    } else {
        mBatteryInfoIcon.setImageResource(R.drawable.ic_lock_idle_low_battery);
        mBatteryInfoText.setText(R.string.lockscreen_low_battery);
    }
}

Output:
         mBatteryInfoIcon.setImageResource(R.drawable.ic_lock_idle_charging);
-        mBatteryInfoText.setText(getContext().getString(R.string.lockscreen_plugged_in, mBatteryLevel));
+        if (mBatteryLevel >= 100) {
+            mBatteryInfoText.setText(R.string.lockscreen_charged);
+        } else {
+            mBatteryInfoText.setText(getContext().getString(R.string.lockscreen_plugged_in, mBatteryLevel));
+        }
     } else {


Input:
public void fuseInto(RangeLoop o, boolean insertAtTop) {
    Map<Var, Arg> renames = new HashMap<Var, Arg>();
    renames.put(o.loopVar, Arg.createVar(this.loopVar));
    if (countVar != null)
        renames.put(o.countVar, Arg.createVar(this.countVar));
    o.replaceVars(renames, false, true);
    this.fuseIntoAbstract(o, insertAtTop);
}

Output:
     renames.put(o.loopVar, Arg.createVar(this.loopVar));
-    if (countVar != null)
-        renames.put(o.countVar, Arg.createVar(this.countVar));
+    if (loopCounterVar != null)
+        renames.put(o.loopCounterVar, Arg.createVar(this.loopCounterVar));
     o.replaceVars(renames, false, true);


Input:
private void getHealthWithGMS() {
    StringBuilder result = new StringBuilder();
    HealthHistory history = gmsAdapter.getHealthHistory();
    if (history == null) {
        setFail(Strings.get("String_Node_Str"));
        return;
    }
    if (history.getInstances().isEmpty()) {
        report.setMessage(Strings.get("String_Node_Str", clusterName));
        return;
    }
    ActionReport.MessagePart top = report.getTopMessagePart();
    SortedSet<String> names = new TreeSet<String>(history.getInstances());
    for (String name : names) {
        HealthHistory.InstanceHealth ih = history.getHealthByInstance(name);
        if (HealthHistory.NOTIME == ih.time) {
            result.append(Strings.get("String_Node_Str", name, ih.state));
            top.addProperty(name, ih.state.toString());
        } else {
            String status = Strings.get("String_Node_Str", name, ih.state, new Date(ih.time).toString());
            result.append(status);
            top.addProperty(name, status.substring(name.length(), status.length() - 1).trim());
        }
        result.append("String_Node_Str");
    }
    String rawResult = result.toString();
    report.setMessage(rawResult.substring(0, rawResult.lastIndexOf("String_Node_Str")));
}

Output:
             result.append(Strings.get("String_Node_Str", name, ih.state));
-            top.addProperty(name, ih.state.toString());
+            instanceStateAndTime.put("String_Node_Str", "String_Node_Str");
         } else {


Input:
public void buildTableStyle(ITableContent table, StringBuffer styleBuffer) {
    addDefaultTableStyles(styleBuffer);
    IStyle style = table.getStyle();
    CSSValue display = style.getProperty(IStyle.STYLE_DISPLAY);
    if (IStyle.NONE_VALUE == display) {
        styleBuffer.append("String_Node_Str");
    } else if (IStyle.INLINE_VALUE == display || IStyle.INLINE_BLOCK_VALUE == display) {
        styleBuffer.append("String_Node_Str");
    }
    DimensionType height = table.getHeight();
    if (null != height) {
        buildSize(styleBuffer, HTMLTags.ATTR_HEIGHT, height);
    }
    DimensionType width = table.getWidth();
    if (null != width) {
        buildSize(styleBuffer, HTMLTags.ATTR_WIDTH, width);
    } else {
        if (!"String_Node_Str".equalsIgnoreCase(style.getCanShrink())) {
            styleBuffer.append("String_Node_Str");
        }
    }
    if (HTMLRenderOption.LAYOUT_PREFERENCE_FIXED.equals(layoutPreference)) {
        if (!"String_Node_Str".equalsIgnoreCase(style.getCanShrink())) {
            styleBuffer.append("String_Node_Str");
        }
    }
    style = getElementStyle(table);
    if (style == null) {
        return;
    }
    AttributeBuilder.buildFont(styleBuffer, style);
    AttributeBuilder.buildBox(styleBuffer, style);
    AttributeBuilder.buildBackground(styleBuffer, style, reportEmitter);
    AttributeBuilder.buildText(styleBuffer, style);
    AttributeBuilder.buildVisual(styleBuffer, style);
}

Output:
         if (!"String_Node_Str".equalsIgnoreCase(style.getCanShrink())) {
-            styleBuffer.append("String_Node_Str");
+            boolean absoluteWidth = true;
+            for (int i = 0; i < table.getColumnCount(); i++) {
+                IColumn column = table.getColumn(i);
+                DimensionType columnWidth = column.getWidth();
+                if (columnWidth == null) {
+                    absoluteWidth = false;
+                    break;
+                } else {
+                    if ("String_Node_Str".endsWith(columnWidth.getUnits())) {
+                        absoluteWidth = false;
+                        break;
+                    }
+                }
+            }
+            if (!absoluteWidth) {
+                styleBuffer.append("String_Node_Str");
+            }
         }


Input:
private void checkKafkaTopic(Set<String> problemKeys) {
    if (!isValidKafkaTopic(Constants.Logging.KAFKA_TOPIC)) {
        problemKeys.add(Constants.Logging.KAFKA_TOPIC);
    }
}

Output:
 private void checkKafkaTopic(Set<String> problemKeys) {
-    if (!isValidKafkaTopic(Constants.Logging.KAFKA_TOPIC)) {
-        problemKeys.add(Constants.Logging.KAFKA_TOPIC);
-    }
+    validateKafkaTopic(Constants.Logging.KAFKA_TOPIC, problemKeys);
 }


Input:
public static void addDefaultTableForSpecifiedDataPackage(DatabaseConnection dbconn, MetadataTable dbtable) throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
    IMetadataConnection imetadataConnection = ConvertionHelper.convert(dbconn);
    String schema = imetadataConnection.getSchema();
    String catalog = imetadataConnection.getDatabase();
    String databaseType = imetadataConnection.getDbType();
    EDatabaseTypeName currentType = EDatabaseTypeName.getTypeFromDbType(databaseType);
    EDatabaseSchemaOrCatalogMapping curCatalog = currentType.getCatalogMappingField();
    EDatabaseSchemaOrCatalogMapping curSchema = currentType.getSchemaMappingField();
    if (curCatalog != null && curSchema != null) {
        switch(curCatalog) {
            case Login:
                catalog = imetadataConnection.getUsername();
                break;
            case None:
                catalog = "String_Node_Str";
                break;
        }
        switch(curSchema) {
            case Login:
                schema = imetadataConnection.getUsername();
                break;
            case Schema:
                schema = imetadataConnection.getSchema();
                break;
            case None:
                schema = "String_Node_Str";
                break;
            case Default_Name:
                schema = dbconn.getName();
                break;
        }
    }
    boolean isAccess = EDatabaseTypeName.ACCESS.getDisplayName().equals(imetadataConnection.getDbType());
    if (!isAccess) {
        schema = ExtractMetaDataUtils.getMeataConnectionSchema(imetadataConnection);
    }
    boolean isOlap = ExtractMetaDataUtils.isOLAPConnection(dbconn);
    if (isOlap) {
        List<Catalog> catalogs = ConnectionHelper.getCatalogs(dbconn);
        if (!catalogs.isEmpty()) {
            Catalog c = catalogs.get(0);
            catalog = c.getName();
            if (!CatalogHelper.getSchemas(c).isEmpty()) {
                Schema s = CatalogHelper.getSchemas(c).get(0);
                schema = s.getName();
            }
        }
    }
    addTableForTemCatalogOrSchema(catalog, schema, dbconn, dbtable, imetadataConnection);
}

Output:
     if (!isAccess) {
-        schema = ExtractMetaDataUtils.getMeataConnectionSchema(imetadataConnection);
+        schema = extractMeta.getMeataConnectionSchema(imetadataConnection);
     }


Input:
private IgnoreOperation executeIgnore(IPath... paths) throws Exception {
    IgnoreOperation operation = new IgnoreOperation(Arrays.asList(paths));
    operation.execute(new NullProgressMonitor());
    return operation;
}

Output:
 private IgnoreOperation executeIgnore(IPath... paths) throws Exception {
-    IgnoreOperation operation = new IgnoreOperation(Arrays.asList(paths));
-    operation.execute(new NullProgressMonitor());
+    final IgnoreOperation operation = new IgnoreOperation(Arrays.asList(paths));
+    Job job = new Job("String_Node_Str") {
+        protected IStatus run(IProgressMonitor monitor) {
+            try {
+                operation.execute(monitor);
+            } catch (CoreException e) {
+                return e.getStatus();
+            }
+            return Status.OK_STATUS;
+        }
+    };
+    job.setRule(operation.getSchedulingRule());
+    job.schedule();
+    job.join();
+    if (!job.getResult().isOK())
+        fail("String_Node_Str" + job.getResult());
     return operation;


Input:
public ProgressIndicator taskAdd() {
    Spinner p = new Spinner();
    Anim a = new Anim(at -> setScaleXY(p, at * at)).dur(500).intpl(new ElasticInterpolator());
    p.progressProperty().addListener((o, ov, nv) -> {
        if (nv.doubleValue() == -1) {
            leftHeaderBox.getChildren().add(p);
            a.then(null).play();
        }
        if (nv.doubleValue() == 1) {
            a.then(() -> leftHeaderBox.getChildren().remove(p)).playClose();
        }
    });
    return p;
}

Output:
 public ProgressIndicator taskAdd() {
-    Spinner p = new Spinner();
-    Anim a = new Anim(at -> setScaleXY(p, at * at)).dur(500).intpl(new ElasticInterpolator());
-    p.progressProperty().addListener((o, ov, nv) -> {
-        if (nv.doubleValue() == -1) {
-            leftHeaderBox.getChildren().add(p);
-            a.then(null).play();
-        }
-        if (nv.doubleValue() == 1) {
-            a.then(() -> leftHeaderBox.getChildren().remove(p)).playClose();
-        }
-    });
-    return p;
+    return App.Build.appProgressIndicator(pi -> leftHeaderBox.getChildren().add(pi), pi -> leftHeaderBox.getChildren().remove(pi));
 }


Input:
protected String getEscapedStr(String s) {
    StringBuffer result = null;
    int spacePos = 1;
    char[] s2char = s.toCharArray();
    for (int i = 0, max = s2char.length, delta = 0; i < max; i++) {
        char c = s2char[i];
        String replacement = null;
        if (c == ' ') {
            if (spacePos % 2 == 1 || i == max - 1) {
                replacement = "String_Node_Str";
            }
            spacePos++;
        } else {
            spacePos = 0;
        }
        if (!(c == 0x9 || c == 0xA || c == 0xD || (c >= 0x20 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD))) {
            replacement = "String_Node_Str";
        } else if (c == '&') {
            replacement = "String_Node_Str";
        } else if (c == '<') {
            replacement = "String_Node_Str";
        } else if (c == '>') {
            replacement = "String_Node_Str";
        } else if (c == '\t') {
            replacement = "String_Node_Str";
        } else if (c == '=') {
            replacement = "String_Node_Str";
        } else if (c >= 0x80) {
            replacement = "String_Node_Str" + Integer.toHexString(c) + ';';
        }
        if (replacement != null) {
            if (result == null) {
                result = new StringBuffer(s);
            }
            result.replace(i + delta, i + delta + 1, replacement);
            delta += (replacement.length() - 1);
        }
    }
    if (result == null) {
        return s;
    }
    return result.toString();
}

Output:
         if (c == ' ') {
-            if (spacePos % 2 == 1 || i == max - 1) {
+            if (spacePos % 2 != 0 || i == max - 1) {
                 replacement = "String_Node_Str";


Input:
public boolean isRedirect(Language lang, int id) throws DaoException {
    LiveAPIQuery.LiveAPIQueryBuilder builder = new LiveAPIQuery.LiveAPIQueryBuilder("String_Node_Str", lang);
    builder.setPageid(id);
    LiveAPIQuery query = builder.build();
    return query.getValuesFromQueryResult().get(0).isRedirect;
}

Output:
     LiveAPIQuery.LiveAPIQueryBuilder builder = new LiveAPIQuery.LiveAPIQueryBuilder("String_Node_Str", lang);
-    builder.setPageid(id);
+    builder.addPageid(id);
     LiveAPIQuery query = builder.build();