Input:
protected void prepareHandlers(final Context context) {
    addHandler(Attributes.View.OnClick, new EventProcessor<V>(context) {
        public void setOnEventListener(final V view, final ParserContext parserContext, final JsonElement attributeValue) {
            view.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    fireEvent(view, parserContext, EventType.OnClick, attributeValue);
                }
            });
        }
    });
    addHandler(Attributes.View.Background, new DrawableResourceProcessor<V>(context) {
        public void setDrawable(V view, Drawable drawable) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                view.setBackgroundDrawable(drawable);
            } else {
                view.setBackground(drawable);
            }
        }
    });
    addHandler(Attributes.View.Height, new StringAttributeProcessor<V>() {

        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            layoutParams.height = ParseHelper.parseDimension(attributeValue, context);
            view.setLayoutParams(layoutParams);
        }
    });
    addHandler(Attributes.View.Width, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            layoutParams.width = ParseHelper.parseDimension(attributeValue, context);
            view.setLayoutParams(layoutParams);
        }
    });
    addHandler(Attributes.View.Weight, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            LinearLayout.LayoutParams layoutParams;
            if (view.getLayoutParams() instanceof LinearLayout.LayoutParams) {
                layoutParams = (LinearLayout.LayoutParams) view.getLayoutParams();
                layoutParams.weight = ParseHelper.parseFloat(attributeValue);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error(attributeKey + "String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.LayoutGravity, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
            if (layoutParams instanceof LinearLayout.LayoutParams) {
                LinearLayout.LayoutParams linearLayoutParams = (LinearLayout.LayoutParams) layoutParams;
                linearLayoutParams.gravity = ParseHelper.parseGravity(attributeValue);
                view.setLayoutParams(layoutParams);
            } else if (layoutParams instanceof FrameLayout.LayoutParams) {
                FrameLayout.LayoutParams linearLayoutParams = (FrameLayout.LayoutParams) layoutParams;
                linearLayoutParams.gravity = ParseHelper.parseGravity(attributeValue);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error(attributeKey + "String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.Padding, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(dimension, dimension, dimension, dimension);
        }
    });
    addHandler(Attributes.View.PaddingLeft, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(dimension, view.getPaddingTop(), view.getPaddingRight(), view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingTop, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), dimension, view.getPaddingRight(), view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingRight, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), dimension, view.getPaddingBottom());
        }
    });
    addHandler(Attributes.View.PaddingBottom, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            view.setPadding(view.getPaddingLeft(), view.getPaddingTop(), view.getPaddingRight(), dimension);
        }
    });
    addHandler(Attributes.View.Margin, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int dimension = ParseHelper.parseDimension(attributeValue, context);
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(dimension, dimension, dimension, dimension);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginLeft, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(dimension, layoutParams.topMargin, layoutParams.rightMargin, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginTop, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, dimension, layoutParams.rightMargin, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginRight, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, layoutParams.topMargin, dimension, layoutParams.bottomMargin);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MarginBottom, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
                ViewGroup.MarginLayoutParams layoutParams;
                layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
                layoutParams.setMargins(layoutParams.leftMargin, layoutParams.topMargin, layoutParams.rightMargin, dimension);
                view.setLayoutParams(layoutParams);
            } else {
                if (logger.isErrorEnabled()) {
                    logger.error("String_Node_Str");
                }
            }
        }
    });
    addHandler(Attributes.View.MinHeight, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            view.setMinimumHeight(dimension);
        }
    });
    addHandler(Attributes.View.MinWidth, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            view.setMinimumWidth(dimension);
        }
    });
    addHandler(Attributes.View.Elevation, new DimensionAttributeProcessor<V>() {
        public void setDimension(V view, String attributeKey, int dimension) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                view.setElevation(dimension);
            }
        }
    });
    addHandler(Attributes.View.Alpha, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setAlpha(ParseHelper.parseFloat(attributeValue));
        }
    });
    addHandler(Attributes.View.Visibility, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setVisibility(ParseHelper.parseVisibility(attributeValue));
        }
    });
    addHandler(Attributes.View.Invisibility, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setVisibility(ParseHelper.parseInvisibility(attributeValue));
        }
    });
    addHandler(Attributes.View.Id, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setId(IdGenerator.getInstance().getUnique(attributeValue));
        }
    });
    addHandler(Attributes.View.ContentDescription, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setContentDescription(attributeValue);
        }
    });
    addHandler(Attributes.View.Clickable, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            boolean clickable = ParseHelper.parseBoolean(attributeValue);
            view.setClickable(clickable);
        }
    });
    addHandler(Attributes.View.Tag, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setTag(attributeValue);
        }
    });
    addHandler(Attributes.View.Border, new JsonDataProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, JsonElement attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            Drawable border = Utils.getBorderDrawble(attributeValue, context);
            if (border == null) {
                return;
            }
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                view.setBackgroundDrawable(border);
            } else {
                view.setBackground(border);
            }
        }
    });
    addHandler(Attributes.View.Enabled, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            boolean enabled = ParseHelper.parseBoolean(attributeValue);
            view.setEnabled(enabled);
        }
    });
    addHandler(Attributes.View.Style, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            Styles styles = parserContext.getStyles();
            LayoutHandler handler = parserContext.getLayoutBuilder().getHandler(Utils.getPropertyAsString(layout, ProteusConstants.TYPE));
            if (styles == null) {
                return;
            }
            String[] styleSet = attributeValue.split(ProteusConstants.STYLE_DELIMITER);
            for (String styleName : styleSet) {
                if (styles.contains(styleName)) {
                    process(styles.getStyle(styleName), layout, proteusView, (handler != null ? handler : ViewParser.this), parserContext.getLayoutBuilder(), parserContext, parent, index);
                }
            }
        }
        private void process(Map<String, JsonElement> style, JsonObject layout, ProteusView proteusView, LayoutHandler handler, LayoutBuilder builder, ParserContext parserContext, ProteusView parent, int index) {
            for (Map.Entry<String, JsonElement> attribute : style.entrySet()) {
                if (layout.has(attribute.getKey())) {
                    continue;
                }
                builder.handleAttribute(handler, parserContext, attribute.getKey(), attribute.getValue(), layout, proteusView, parent, index);
            }
        }
    });
    addHandler(Attributes.View.TransitionName, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                view.setTransitionName(attributeValue);
            }
        }
    });
    addHandler(Attributes.View.RequiresFadingEdge, new StringAttributeProcessor<V>() {
        private final String NONE = "String_Node_Str";
        private final String BOTH = "String_Node_Str";
        private final String VERTICAL = "String_Node_Str";
        private final String HORIZONTAL = "String_Node_Str";
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            switch(attributeValue) {
                case NONE:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
                case BOTH:
                    view.setVerticalFadingEdgeEnabled(true);
                    view.setHorizontalFadingEdgeEnabled(true);
                    break;
                case VERTICAL:
                    view.setVerticalFadingEdgeEnabled(true);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
                case HORIZONTAL:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(true);
                    break;
                default:
                    view.setVerticalFadingEdgeEnabled(false);
                    view.setHorizontalFadingEdgeEnabled(false);
                    break;
            }
        }
    });
    addHandler(Attributes.View.FadingEdgeLength, new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            view.setFadingEdgeLength(ParseHelper.parseInt(attributeValue));
        }
    });
    final HashMap<String, Integer> relativeLayoutParams = new HashMap<>();
    relativeLayoutParams.put(Attributes.View.Above.getName(), RelativeLayout.ABOVE);
    relativeLayoutParams.put(Attributes.View.AlignBaseline.getName(), RelativeLayout.ALIGN_BASELINE);
    relativeLayoutParams.put(Attributes.View.AlignBottom.getName(), RelativeLayout.ALIGN_BOTTOM);
    relativeLayoutParams.put(Attributes.View.AlignEnd.getName(), RelativeLayout.ALIGN_END);
    relativeLayoutParams.put(Attributes.View.AlignLeft.getName(), RelativeLayout.ALIGN_LEFT);
    relativeLayoutParams.put(Attributes.View.AlignParentBottom.getName(), RelativeLayout.ALIGN_PARENT_BOTTOM);
    relativeLayoutParams.put(Attributes.View.AlignParentEnd.getName(), RelativeLayout.ALIGN_PARENT_END);
    relativeLayoutParams.put(Attributes.View.AlignParentLeft.getName(), RelativeLayout.ALIGN_PARENT_LEFT);
    relativeLayoutParams.put(Attributes.View.AlignParentRight.getName(), RelativeLayout.ALIGN_PARENT_RIGHT);
    relativeLayoutParams.put(Attributes.View.AlignParentStart.getName(), RelativeLayout.ALIGN_PARENT_START);
    relativeLayoutParams.put(Attributes.View.AlignParentTop.getName(), RelativeLayout.ALIGN_PARENT_TOP);
    relativeLayoutParams.put(Attributes.View.AlignRight.getName(), RelativeLayout.ALIGN_RIGHT);
    relativeLayoutParams.put(Attributes.View.AlignStart.getName(), RelativeLayout.ALIGN_START);
    relativeLayoutParams.put(Attributes.View.AlignTop.getName(), RelativeLayout.ALIGN_TOP);
    relativeLayoutParams.put(Attributes.View.Below.getName(), RelativeLayout.BELOW);
    relativeLayoutParams.put(Attributes.View.CenterHorizontal.getName(), RelativeLayout.CENTER_HORIZONTAL);
    relativeLayoutParams.put(Attributes.View.CenterInParent.getName(), RelativeLayout.CENTER_IN_PARENT);
    relativeLayoutParams.put(Attributes.View.CenterVertical.getName(), RelativeLayout.CENTER_VERTICAL);
    relativeLayoutParams.put(Attributes.View.ToEndOf.getName(), RelativeLayout.END_OF);
    relativeLayoutParams.put(Attributes.View.ToLeftOf.getName(), RelativeLayout.LEFT_OF);
    relativeLayoutParams.put(Attributes.View.ToRightOf.getName(), RelativeLayout.RIGHT_OF);
    relativeLayoutParams.put(Attributes.View.ToStartOf.getName(), RelativeLayout.START_OF);
    StringAttributeProcessor<V> relativeLayoutProcessor = new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int id = IdGenerator.getInstance().getUnique(attributeValue);
            Integer rule = relativeLayoutParams.get(attributeKey);
            ParseHelper.addRelativeLayoutRule(view, rule, id);
        }
    };
    StringAttributeProcessor<V> relativeLayoutBooleanProcessor = new StringAttributeProcessor<V>() {
        public void handle(ParserContext parserContext, String attributeKey, String attributeValue, V view, ProteusView proteusView, ProteusView parent, JsonObject layout, int index) {
            int trueOrFalse = ParseHelper.parseRelativeLayoutBoolean(attributeValue);
            ParseHelper.addRelativeLayoutRule(view, relativeLayoutParams.get(attributeKey), trueOrFalse);
        }
    };
    addHandler(Attributes.View.Above, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignBaseline, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignBottom, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignEnd, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignLeft, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignRight, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignStart, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignTop, relativeLayoutProcessor);
    addHandler(Attributes.View.Below, relativeLayoutProcessor);
    addHandler(Attributes.View.ToEndOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToLeftOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToRightOf, relativeLayoutProcessor);
    addHandler(Attributes.View.ToStartOf, relativeLayoutProcessor);
    addHandler(Attributes.View.AlignParentBottom, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentEnd, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentLeft, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentRight, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentStart, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.AlignParentTop, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterHorizontal, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterInParent, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.CenterVertical, relativeLayoutBooleanProcessor);
    addHandler(Attributes.View.Animation, new TweenAnimationResourceProcessor<V>(context) {
        public void setAnimation(V view, Animation animation) {
            view.setAnimation(animation);
        }
    });
}

Output:
     });
-    addHandler(Attributes.View.Height, new StringAttributeProcessor<V>() {
+    addHandler(Attributes.View.Height, new DimensionAttributeProcessor<V>() {


Input:
public void playPauseToggle() {
    if (currentLyrics == null && trackList.size() > 0 && getCurrentPosition() >= 0) {
        play();
    } else {
        Intent intent = new Intent(application, MusicPlayerService.class);
        Bundle bundle = new Bundle();
        bundle.putString("String_Node_Str", "String_Node_Str");
        intent.putExtras(bundle);
        application.startService(intent);
    }
}

Output:
 public void playPauseToggle() {
-    if (currentLyrics == null && trackList.size() > 0 && getCurrentPosition() >= 0) {
-        play();
-    } else {
+    try {
         Intent intent = new Intent(application, MusicPlayerService.class);


Input:
Object getJsonValue() throws Exception {
    assertJsonable();
    return new Double(getValue());
}

Output:
     assertJsonable();
-    return new Double(getValue());
+    return getValue();
 }


Input:
public RequestCall build() {
    return new GetRequest(mUri, mFolder, mName).build();
}

Output:
 public RequestCall build() {
-    return new GetRequest(mUri, mFolder, mName).build();
+    return new GetRequest(mUri, mFolder, mName, mTag).build();
 }


Input:
public int[] getSortOrder() {
    Vector<Integer> indices = new Vector<Integer>();
    outer: for (int i = 0; i < fields.length; ++i) {
        int order = fields[i].getSortOrder();
        if (order < 1) {
            continue;
        }
        for (int j = 0; j < indices.size(); ++j) {
            if (indices.size() > 0 || order < fields[indices.elementAt(j).intValue()].getSortOrder()) {
                indices.insertElementAt(new Integer(i), j);
                continue outer;
            }
        }
        indices.addElement(new Integer(i));
        continue;
    }
    if (indices.size() == 0) {
        return new int[] {};
    } else {
        int[] ret = new int[indices.size()];
        for (int i = 0; i < ret.length; ++i) {
            ret[i] = indices.elementAt(i).intValue();
        }
        return ret;
    }
}

Output:
         for (int j = 0; j < indices.size(); ++j) {
-            if (indices.size() > 0 || order < fields[indices.elementAt(j).intValue()].getSortOrder()) {
+            if (order < fields[indices.elementAt(j).intValue()].getSortOrder()) {
                 indices.insertElementAt(new Integer(i), j);


Input:
private boolean hasSections(List<StudentAttributes>[] students) {
    for (List<StudentAttributes> studentList : students) {
        for (StudentAttributes student : studentList) {
            if (!student.section.equals("String_Node_Str")) {
                return true;
            }
        }
    }
    return false;
}

Output:
         for (StudentAttributes student : studentList) {
-            if (!student.section.equals("String_Node_Str")) {
+            if (!student.section.equals(Const.DEFAULT_SECTION)) {
                 return true;


Input:
public void run() {
    listener.onRequestPerformed(result);
}

Output:
 public void run() {
-    listener.onRequestPerformed(result);
+    for (final ResultListener<T> listener : resultListeners) {
+        if (listener != null) {
+            if (listener.onRequestPerformed(result)) {
+                return;
+            }
+        }
+    }
 }


Input:
public void setContainer(CompositeEntity container) throws IllegalActionException, NameDuplicationException {
    Nameable previousContainer = getContainer();
    super.setContainer(container);
    if (container != previousContainer) {
        _remove();
    }
}

Output:
     super.setContainer(container);
-    if (container != previousContainer) {
+    if (container != previousContainer && previousContainer != null) {
         _remove();


Input:
protected void onSubmit(final AjaxRequestTarget target, final Form form) {
    ConnInstanceTO connector = (ConnInstanceTO) form.getDefaultModelObject();
    connector.setBundleName(bundle.getModelValue());
    if (!selectedCapabilities.isEmpty()) {
        connector.setCapabilities(EnumSet.copyOf(selectedCapabilities));
    } else {
        connector.setCapabilities(EnumSet.noneOf(ConnectorCapability.class));
    }
    try {
        if (createFlag) {
            restClient.create(connector);
        } else {
            restClient.update(connector);
        }
        basePage.setOperationResult(true);
        window.close(target);
    } catch (SyncopeClientCompositeErrorException e) {
        error(getString("String_Node_Str") + "String_Node_Str" + e.getMessage());
        basePage.setOperationResult(false);
        LOG.error("String_Node_Str" + connector);
    }
}

Output:
     ConnInstanceTO connector = (ConnInstanceTO) form.getDefaultModelObject();
-    connector.setBundleName(bundle.getModelValue());
+    connector.setBundleName(bundle.getModelValue().substring(0, bundle.getModelValue().lastIndexOf('#')));
     if (!selectedCapabilities.isEmpty()) {


Input:
private DBClusterInfo _getDBClusterInfo(String clusterName, Node clusterNode) throws LoadConfigException {
    DBClusterInfo dbClusterInfo = new DBClusterInfo();
    dbClusterInfo.setClusterName(clusterName);
    try {
        String classFullPath = xmlUtil.getAttributeValue(clusterNode, "String_Node_Str");
        if (StringUtil.isBlank(classFullPath)) {
            classFullPath = DEFAULT_CLUSTER_ROUTER_CLASS;
        }
        Class<IClusterRouter> clazz = (Class<IClusterRouter>) Class.forName(classFullPath);
        dbClusterInfo.setRouterClass(clazz);
    } catch (Exception e) {
        throw new LoadConfigException(e);
    }
    Node global = xmlUtil.getFirstChildByName(clusterNode, "String_Node_Str");
    if (global != null) {
        Node masterGlobal = xmlUtil.getFirstChildByName(global, "String_Node_Str");
        String dsId = masterGlobal.getTextContent().trim();
        DBInfo masterGlobalDBInfo = dsBucketMap.get(dsId);
        if (masterGlobalDBInfo == null) {
            throw new LoadConfigException("String_Node_Str" + dsId);
        }
        masterGlobalDBInfo.setClusterName(clusterName);
        masterGlobalDBInfo.setMasterSlave(EnumDBMasterSlave.MASTER);
        Map<String, String> propMap = xmlUtil.getAttributeAsMap(masterGlobal);
        masterGlobalDBInfo.setCustomProperties(propMap);
        masterGlobalDBInfo.check();
        dbClusterInfo.setMasterGlobalDBInfo(masterGlobalDBInfo);
        List<Node> slaveGlobalList = xmlUtil.getChildByName(global, "String_Node_Str");
        if (slaveGlobalList != null && !slaveGlobalList.isEmpty()) {
            List<DBInfo> slaveGlobalConnection = new ArrayList<DBInfo>();
            int slaveIndex = 0;
            for (Node slaveGlobal : slaveGlobalList) {
                dsId = slaveGlobal.getTextContent().trim();
                DBInfo slaveGlobalDBInfo = dsBucketMap.get(dsId);
                if (slaveGlobalDBInfo == null) {
                    throw new LoadConfigException("String_Node_Str" + dsId);
                }
                slaveGlobalDBInfo.setClusterName(clusterName);
                slaveGlobalDBInfo.setMasterSlave(EnumDBMasterSlave.getSlaveEnum(slaveIndex++));
                propMap = xmlUtil.getAttributeAsMap(slaveGlobal);
                slaveGlobalDBInfo.setCustomProperties(propMap);
                slaveGlobalDBInfo.check();
                slaveGlobalConnection.add(slaveGlobalDBInfo);
            }
            dbClusterInfo.setSlaveGlobalDBInfo(slaveGlobalConnection);
        }
    }
    List<DBRegionInfo> dbRegions = new ArrayList<DBRegionInfo>();
    List<Node> regionNodeList = xmlUtil.getChildByName(clusterNode, "String_Node_Str");
    DBRegionInfo regionInfo = null;
    for (Node regionNode : regionNodeList) {
        regionInfo = new DBRegionInfo();
        String regionCapacity = xmlUtil.getAttributeValue(regionNode, "String_Node_Str");
        if (regionCapacity == null) {
            throw new LoadConfigException("String_Node_Str");
        }
        List<Value> values = _parseCapacity(clusterName, regionCapacity);
        regionInfo.setValues(values);
        regionInfo.setCapacity(regionCapacity);
        List<DBInfo> regionMasterConnection = new ArrayList<DBInfo>();
        Node master = xmlUtil.getFirstChildByName(regionNode, "String_Node_Str");
        List<Node> shardingNodeList = xmlUtil.getChildByName(master, "String_Node_Str");
        for (Node shardingNode : shardingNodeList) {
            String dsId = shardingNode.getTextContent().trim();
            DBInfo masterShardingDBInfo = dsBucketMap.get(dsId);
            if (masterShardingDBInfo == null) {
                throw new LoadConfigException("String_Node_Str" + dsId);
            }
            masterShardingDBInfo.setClusterName(clusterName);
            masterShardingDBInfo.setMasterSlave(EnumDBMasterSlave.MASTER);
            Map<String, String> propMap = xmlUtil.getAttributeAsMap(shardingNode);
            masterShardingDBInfo.setCustomProperties(propMap);
            masterShardingDBInfo.check();
            regionMasterConnection.add(masterShardingDBInfo);
        }
        regionInfo.setMasterDBInfos(regionMasterConnection);
        List<List<DBInfo>> regionSlaveConnection = new ArrayList<List<DBInfo>>();
        List<Node> slaveNodeList = xmlUtil.getChildByName(regionNode, "String_Node_Str");
        int slaveIndex = 0;
        for (Node slaveNode : slaveNodeList) {
            shardingNodeList = xmlUtil.getChildByName(slaveNode, "String_Node_Str");
            List<DBInfo> slaveConnections = new ArrayList<DBInfo>();
            for (Node shardingNode : shardingNodeList) {
                String dsId = shardingNode.getTextContent().trim();
                DBInfo slaveShardingDBInfo = dsBucketMap.get(dsId);
                if (slaveShardingDBInfo == null) {
                    throw new LoadConfigException("String_Node_Str" + dsId);
                }
                slaveShardingDBInfo.setClusterName(clusterName);
                slaveShardingDBInfo.setMasterSlave(EnumDBMasterSlave.getSlaveEnum(slaveIndex++));
                Map<String, String> propMap = xmlUtil.getAttributeAsMap(shardingNode);
                slaveShardingDBInfo.setCustomProperties(propMap);
                slaveShardingDBInfo.check();
                slaveConnections.add(slaveShardingDBInfo);
            }
            regionSlaveConnection.add(slaveConnections);
        }
        regionInfo.setSlaveDBInfos(regionSlaveConnection);
        dbRegions.add(regionInfo);
    }
    dbClusterInfo.setDbRegions(dbRegions);
    return dbClusterInfo;
}

Output:
         String dsId = masterGlobal.getTextContent().trim();
-        DBInfo masterGlobalDBInfo = dsBucketMap.get(dsId);
-        if (masterGlobalDBInfo == null) {
+        if (dsBucketMap.get(dsId) == null) {
             throw new LoadConfigException("String_Node_Str" + dsId);


Input:
public void execute(CommandSender sender, String[] args) {
    MessagesConfig messages = Messages.getInstance();
    Player player = (Player) sender;
    User user = User.get(player);
    if (!user.hasGuild()) {
        player.sendMessage(messages.generalHasNoGuild);
        return;
    }
    if (!user.isOwner()) {
        player.sendMessage(messages.generalIsNotOwner);
        return;
    }
    Guild guild = user.getGuild();
    if (guild.getAllies() == null || guild.getAllies().isEmpty()) {
        player.sendMessage(messages.breakHasNotAllies);
        return;
    }
    if (args.length < 1) {
        List<String> list = messages.breakAlliesList;
        String iss = StringUtils.toString(GuildUtils.getNames(guild.getAllies()), true);
        for (String msg : list) {
            player.sendMessage(msg.replace("String_Node_Str", iss));
        }
        return;
    }
    String tag = args[0];
    Guild oppositeGuild = GuildUtils.byTag(tag);
    if (oppositeGuild == null) {
        player.sendMessage(messages.generalGuildNotExists.replace("String_Node_Str", tag));
        return;
    }
    if (!guild.getAllies().contains(oppositeGuild)) {
        player.sendMessage(messages.breakAllyExists.replace("String_Node_Str", oppositeGuild.getName()).replace("String_Node_Str", tag));
    }
    if (!SimpleEventHandler.handle(new GuildBreakAllyEvent(EventCause.USER, user, guild, oppositeGuild))) {
        return;
    }
    guild.removeAlly(oppositeGuild);
    oppositeGuild.removeAlly(guild);
    for (User u : guild.getMembers()) {
        IndependentThread.action(ActionType.PREFIX_UPDATE_GUILD, u, oppositeGuild);
    }
    for (User u : oppositeGuild.getMembers()) {
        IndependentThread.action(ActionType.PREFIX_UPDATE_GUILD, u, guild);
    }
    Player owner = oppositeGuild.getOwner().getPlayer();
    if (owner != null) {
        owner.sendMessage(messages.allyIDone.replace("String_Node_Str", guild.getName()).replace("String_Node_Str", guild.getTag()));
    }
    player.sendMessage(messages.breakDone.replace("String_Node_Str", oppositeGuild.getName()).replace("String_Node_Str", oppositeGuild.getTag()));
}

Output:
     String tag = args[0];
-    Guild oppositeGuild = GuildUtils.byTag(tag);
+    Guild oppositeGuild = GuildUtils.getByTag(tag);
     if (oppositeGuild == null) {


Input:
public void execute() {
    long start = 0;
    if (log.isDebug()) {
        log.debug("String_Node_Str" + ores.getResourceableId());
        start = System.currentTimeMillis();
    }
    Wiki wiki = null;
    VFSContainer folder = getWikiContainer(ores, WIKI_RESOURCE_FOLDER_NAME);
    if (folder == null) {
        createFolders(ores);
        folder = getWikiContainer(ores, WIKI_RESOURCE_FOLDER_NAME);
    }
    wiki = new Wiki(getWikiRootContainer(ores));
    List<VFSItem> wikiLeaves = folder.getItems(new VFSItemSuffixFilter(new String[] { WikiManager.WIKI_PROPERTIES_SUFFIX }));
    for (Iterator<VFSItem> iter = wikiLeaves.iterator(); iter.hasNext(); ) {
        VFSLeaf propertiesFile = (VFSLeaf) iter.next();
        WikiPage page = Wiki.assignPropertiesToPage(propertiesFile);
        if (page == null) {
            String contentFileToBeDeleted = (propertiesFile.getName().substring(0, propertiesFile.getName().length() - WikiManager.WIKI_PROPERTIES_SUFFIX.length()) + WikiManager.WIKI_FILE_SUFFIX);
            folder.resolve(contentFileToBeDeleted).delete();
            propertiesFile.delete();
            continue;
        }
        if (page.getPageName().equals(WikiPage.WIKI_INDEX_PAGE) || page.getPageName().equals(WikiPage.WIKI_MENU_PAGE)) {
            VFSLeaf leaf = (VFSLeaf) folder.resolve(page.getPageId() + "String_Node_Str" + WikiManager.WIKI_FILE_SUFFIX);
            page.setContent(FileUtils.load(leaf.getInputStream(), "String_Node_Str"));
        }
        String idOutOfFileName = propertiesFile.getName().substring(0, propertiesFile.getName().indexOf("String_Node_Str"));
        if (!page.getPageId().equals(idOutOfFileName)) {
            propertiesFile.rename(page.getPageId() + "String_Node_Str" + WikiManager.WIKI_PROPERTIES_SUFFIX);
            VFSLeaf contentFile = (VFSLeaf) folder.resolve(idOutOfFileName + "String_Node_Str" + WikiManager.WIKI_FILE_SUFFIX);
            contentFile.rename(page.getPageId() + "String_Node_Str" + WikiManager.WIKI_FILE_SUFFIX);
        }
        wiki.addPage(page);
    }
    if (wiki.getNumberOfPages() == 0) {
        WikiPage indexPage = new WikiPage(WikiPage.WIKI_INDEX_PAGE);
        WikiPage menuPage = new WikiPage(WikiPage.WIKI_MENU_PAGE);
        indexPage.setCreationTime(System.currentTimeMillis());
        wiki.addPage(indexPage);
        menuPage.setCreationTime(System.currentTimeMillis());
        menuPage.setContent("String_Node_Str");
        wiki.addPage(menuPage);
        saveWikiPage(ores, indexPage, false, wiki);
        saveWikiPage(ores, menuPage, false, wiki);
    }
    WikiPage recentChangesPage = new WikiPage(WikiPage.WIKI_RECENT_CHANGES_PAGE);
    WikiPage a2zPage = new WikiPage(WikiPage.WIKI_A2Z_PAGE);
    wiki.addPage(recentChangesPage);
    wiki.addPage(a2zPage);
    if (log.isDebug()) {
        long stop = System.currentTimeMillis();
        log.debug("String_Node_Str" + (stop - start));
    }
    wikiCache.put(wikiKey, wiki);
}

Output:
     }
-    if (wiki.getNumberOfPages() == 0) {
-        WikiPage indexPage = new WikiPage(WikiPage.WIKI_INDEX_PAGE);
-        WikiPage menuPage = new WikiPage(WikiPage.WIKI_MENU_PAGE);
-        indexPage.setCreationTime(System.currentTimeMillis());
-        wiki.addPage(indexPage);
-        menuPage.setCreationTime(System.currentTimeMillis());
-        menuPage.setContent("String_Node_Str");
-        wiki.addPage(menuPage);
-        saveWikiPage(ores, indexPage, false, wiki);
-        saveWikiPage(ores, menuPage, false, wiki);
+            if (page.getPageName().equals(WikiPage.WIKI_INDEX_PAGE) || page.getPageName().equals(WikiPage.WIKI_MENU_PAGE)) {
+                VFSLeaf leaf = (VFSLeaf) folder.resolve(page.getPageId() + "String_Node_Str" + WikiManager.WIKI_FILE_SUFFIX);
+                page.setContent(FileUtils.load(leaf.getInputStream(), "String_Node_Str"));
     }


Input:
private void initGuidepostDepth() throws IOException, ClassNotFoundException, SQLException {
    if (guidePostPerRegionBytes != null || guidePostWidthBytes != null) {
        int guidepostPerRegion = 0;
        long guidepostWidth = QueryServicesOptions.DEFAULT_STATS_GUIDEPOST_WIDTH_BYTES;
        if (guidePostPerRegionBytes != null) {
            guidepostPerRegion = PInteger.INSTANCE.getCodec().decodeInt(guidePostPerRegionBytes, 0, SortOrder.getDefault());
        }
        if (guidePostWidthBytes != null) {
            guidepostWidth = PLong.INSTANCE.getCodec().decodeInt(guidePostWidthBytes, 0, SortOrder.getDefault());
        }
        this.guidePostDepth = StatisticsUtil.getGuidePostDepth(guidepostPerRegion, guidepostWidth, env.getRegion().getTableDesc());
    } else {
        long guidepostWidth = -1;
        Table htable = null;
        try {
            htable = env.getConnection().getTable(SchemaUtil.getPhysicalTableName(PhoenixDatabaseMetaData.SYSTEM_CATALOG_NAME_BYTES, env.getConfiguration()));
            Get get = new Get(ptableKey);
            get.addColumn(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.GUIDE_POSTS_WIDTH_BYTES);
            Result result = htable.get(get);
            if (!result.isEmpty()) {
                Cell cell = result.listCells().get(0);
                guidepostWidth = PLong.INSTANCE.getCodec().decodeLong(cell.getValueArray(), cell.getValueOffset(), SortOrder.getDefault());
            } else if (!isViewIndexTable) {
                try (Connection conn = QueryUtil.getConnectionOnServer(env.getConfiguration())) {
                    PTable table = PhoenixRuntime.getTable(conn, tableName);
                    if (table.getType() == PTableType.INDEX && table.getIndexType() == IndexType.GLOBAL) {
                        PName parentName = table.getParentName();
                        byte[] parentKey = SchemaUtil.getTableKeyFromFullName(parentName.getString());
                        get = new Get(parentKey);
                        get.addColumn(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES, PhoenixDatabaseMetaData.GUIDE_POSTS_WIDTH_BYTES);
                        result = htable.get(get);
                        if (!result.isEmpty()) {
                            Cell cell = result.listCells().get(0);
                            guidepostWidth = PLong.INSTANCE.getCodec().decodeLong(cell.getValueArray(), cell.getValueOffset(), SortOrder.getDefault());
                        }
                    }
                }
            }
        } finally {
            if (htable != null) {
                try {
                    htable.close();
                } catch (IOException e) {
                    LOG.warn("String_Node_Str" + htable.getName(), e);
                }
            }
        }
        if (guidepostWidth >= 0) {
            this.guidePostDepth = guidepostWidth;
        } else {
            Configuration config = env.getConfiguration();
            this.guidePostDepth = StatisticsUtil.getGuidePostDepth(config.getInt(QueryServices.STATS_GUIDEPOST_PER_REGION_ATTRIB, QueryServicesOptions.DEFAULT_STATS_GUIDEPOST_PER_REGION), config.getLong(QueryServices.STATS_GUIDEPOST_WIDTH_BYTES_ATTRIB, QueryServicesOptions.DEFAULT_STATS_GUIDEPOST_WIDTH_BYTES), env.getRegion().getTableDesc());
        }
    }
}

Output:
         }
-        this.guidePostDepth = StatisticsUtil.getGuidePostDepth(guidepostPerRegion, guidepostWidth, env.getRegion().getTableDesc());
+        this.guidePostDepth = StatisticsUtil.getGuidePostDepth(guidepostPerRegion, guidepostWidth, env.getRegion().getTableDescriptor());
     } else {


Input:
public Structure parsePDBFile(BufferedReader buf) throws IOException {
    loadMaxAtoms = params.getMaxAtoms();
    atomCAThreshold = params.getAtomCaThreshold();
    allModels = new ArrayList<>();
    structure = new StructureImpl();
    currentModel = null;
    currentChain = null;
    currentGroup = null;
    startOfMolecule = true;
    startOfModel = true;
    seqResChains = new ArrayList<Chain>();
    siteMap = new LinkedHashMap<String, Site>();
    pdbHeader = new PDBHeader();
    connects = new ArrayList<Map<String, Integer>>();
    previousContinuationField = "String_Node_Str";
    continuationField = "String_Node_Str";
    continuationString = "String_Node_Str";
    current_compound = null;
    sourceLines.clear();
    compndLines.clear();
    isLastCompndLine = false;
    isLastSourceLine = false;
    prevMolId = -1;
    entities.clear();
    helixList.clear();
    strandList.clear();
    turnList.clear();
    lengthCheck = -1;
    atomCount = 0;
    atomOverflow = false;
    siteToResidueMap.clear();
    parseCAonly = params.isParseCAOnly();
    String line = null;
    while ((line = buf.readLine()) != null) {
        if (line.equals("String_Node_Str") || (line.equals(NEWLINE))) {
            continue;
        }
        if (line.startsWith("String_Node_Str")) {
            continue;
        }
        if (line.length() < 6) {
            logger.info("String_Node_Str" + line + "String_Node_Str");
            continue;
        }
        String recordName = line.substring(0, 6).trim();
        if (recordName.equals("String_Node_Str"))
            pdb_ATOM_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_SEQRES_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_ATOM_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_MODEL_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_TER_Handler();
        else if (recordName.equals("String_Node_Str"))
            pdb_HEADER_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_AUTHOR_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_TITLE_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            sourceLines.add(line);
        else if (recordName.equals("String_Node_Str"))
            compndLines.add(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_JRNL_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_EXPDTA_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_CRYST1_Handler(line);
        else if (recordName.startsWith("String_Node_Str"))
            pdb_MTRIXn_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_REMARK_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_CONECT_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_REVDAT_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_DBREF_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_SITE_Handler(line);
        else if (recordName.equals("String_Node_Str"))
            pdb_SSBOND_Handler(line);
        else if (params.isParseSecStruc()) {
            if (recordName.equals("String_Node_Str"))
                pdb_HELIX_Handler(line);
            else if (recordName.equals("String_Node_Str"))
                pdb_SHEET_Handler(line);
            else if (recordName.equals("String_Node_Str"))
                pdb_TURN_Handler(line);
        } else {
        }
    }
    makeCompounds(compndLines, sourceLines);
    triggerEndFileChecks();
    if (params.shouldCreateAtomBonds()) {
        formBonds();
    }
    if (params.shouldCreateAtomCharges()) {
        addCharges();
    }
    if (params.isParseSecStruc() && !params.isHeaderOnly())
        setSecStruc();
    StructureTools.cleanUpAltLocs(structure);
    return structure;
}

Output:
         }
-        if (line.length() < 6) {
+        if (line.length() < 6 && !line.startsWith("String_Node_Str")) {
             logger.info("String_Node_Str" + line + "String_Node_Str");


Input:
public List<ScriptPack> findScriptPacksByPath(String name) {
    List<ScriptPack> ret = new ArrayList<>();
    List<ScriptPack> allPacks = getScriptPacks(null);
    if (name.endsWith("String_Node_Str") || name.equals("String_Node_Str") || name.endsWith("String_Node_Str") || name.equals("String_Node_Str")) {
        name = name.substring(0, name.length() - 2);
        for (ScriptPack en : allPacks) {
            if (en.getClassPath().toString().startsWith(name)) {
                ret.add(en);
            }
        }
    } else if (name.endsWith("String_Node_Str") || name.equals("String_Node_Str") || name.endsWith("String_Node_Str") || name.equals("String_Node_Str")) {
        name = name.substring(0, name.length() - 1);
        for (ScriptPack en : allPacks) {
            String classPathStr = en.getClassPath().toString();
            if (classPathStr.startsWith(name)) {
                String rem = name.isEmpty() ? classPathStr : classPathStr.substring(name.length());
                if (!rem.contains("String_Node_Str")) {
                    ret.add(en);
                }
            }
        }
    } else {
        ScriptPack p = findScriptPackByPath(name);
        if (p != null) {
            ret.add(p);
        }
    }
    return ret;
}

Output:
     List<ScriptPack> ret = new ArrayList<>();
-    List<ScriptPack> allPacks = getScriptPacks(null);
+    List<ScriptPack> allPacks = getScriptPacks(null, allAbcs);
     if (name.endsWith("String_Node_Str") || name.equals("String_Node_Str") || name.endsWith("String_Node_Str") || name.equals("String_Node_Str")) {


Input:
public void initialise() {
    downloader = new ServerListDownloader(config.getNetwork().getMasterServer());
    CardLayout cards = find("String_Node_Str", CardLayout.class);
    UIList<ServerInfo> customServerList = find("String_Node_Str", UIList.class);
    if (customServerList != null) {
        configureServerList(customServerList, customServers);
    }
    UIList<ServerInfo> onlineServerList = find("String_Node_Str", UIList.class);
    if (onlineServerList != null) {
        configureServerList(onlineServerList, listedServers);
    }
    ActivateEventListener activateCustom = e -> {
        cards.setDisplayedCard("String_Node_Str");
        find("String_Node_Str", UIButton.class).setFamily("String_Node_Str");
        find("String_Node_Str", UIButton.class).setFamily("String_Node_Str");
        visibleList = customServerList;
    };
    WidgetUtil.trySubscribe(this, "String_Node_Str", activateCustom);
    ActivateEventListener activateOnline = e -> {
        cards.setDisplayedCard("String_Node_Str");
        find("String_Node_Str", UIButton.class).setFamily("String_Node_Str");
        find("String_Node_Str", UIButton.class).setFamily("String_Node_Str");
        visibleList = onlineServerList;
    };
    WidgetUtil.trySubscribe(this, "String_Node_Str", activateOnline);
    bindCustomButtons();
    bindInfoLabels();
    WidgetUtil.trySubscribe(this, "String_Node_Str", new ActivateEventListener() {
        public void onActivated(UIWidget button) {
            config.save();
            getManager().popScreen();
        }
    });
    activateOnline.onActivated(null);
}

Output:
     if (customServerList != null) {
-        configureServerList(customServerList, customServers);
+        customServerList.setList(config.getNetwork().getServerInfos());
+        configureServerList(customServerList);
     }


Input:
public void load(TableFactory tf, TableMaps toload) {
    Set<TableId> old = tfs.get(tf);
    if (toload.tfs.get(tf) != null) {
        tfs.put(tf, toload.tfs.get(tf));
    } else {
        tfs.remove(tf);
    }
    if (tfs.containsKey(tf)) {
        for (TableId id : tfs.get(tf)) {
            qf.removeQueries(id);
            if (old != null && old.contains(id)) {
                if (toload.whitelist.containsKey(id)) {
                    if (this.whitelist.containsKey(id)) {
                        log.info(String.format("String_Node_Str", id));
                    } else {
                        log.info(String.format("String_Node_Str", id));
                        this.blacklist.remove(id);
                    }
                    this.whitelist.put(id, toload.whitelist.get(id));
                } else {
                    if (this.blacklist.containsKey(id)) {
                        log.info(String.format("String_Node_Str", id));
                    } else {
                        log.warn(String.format("String_Node_Str", id));
                        this.whitelist.remove(id);
                    }
                    this.blacklist.put(id, toload.blacklist.get(id));
                }
            } else {
                if (toload.whitelist.containsKey(id)) {
                    this.whitelist.put(id, toload.whitelist.get(id));
                    log.info(String.format("String_Node_Str", id));
                } else {
                    this.blacklist.put(id, toload.blacklist.get(id));
                    log.warn(String.format("String_Node_Str", id));
                }
            }
        }
    }
    if (old != null) {
        for (TableId id : old) {
            if (!tfs.containsKey(tf) || !tfs.get(tf).contains(id)) {
                qf.removeQueries(id);
                if (this.whitelist.remove(id) != null) {
                    log.warn(String.format("String_Node_Str", id));
                } else {
                    this.blacklist.remove(id);
                    log.warn(String.format("String_Node_Str", id));
                }
            }
        }
    }
}

Output:
         for (TableId id : tfs.get(tf)) {
-            qf.removeQueries(id);
+            if (old != null) {
+                for (TableId oldid : old) {
+                    if (oldid.equals(id) && tables.whitelist.containsKey(oldid)) {
+                        ServerTable oldTable = tables.whitelist.get(oldid);
+                        ServerTable st = toload.whitelist.get(oldid);
+                        if (st.isSame(oldTable)) {
+                            break;
+                        } else {
+                            qf.removeQueries(id);
+                        }
+                    }
+                }
+            } else {
+                qf.removeQueries(id);
+            }
             if (old != null && old.contains(id)) {


Input:
public void run() {
    try {
        Bundle bundle = Platform.getBundle(pluginId);
        URL resourceURL = bundle.getEntry(zipPath);
        try {
            String demoZipPath = FileLocator.toFileURL(resourceURL).getPath();
            TalendImportUtil.importItems(demoZipPath, new NullProgressMonitor(), false, true, false);
            TalendImportUtil.openJob(jobName);
        } catch (Throwable e) {
            CommonExceptionHandler.process(e);
        }
    } catch (Throwable e) {
        CommonExceptionHandler.process(e);
    }
}

Output:
     try {
-        Bundle bundle = Platform.getBundle(pluginId);
-        URL resourceURL = bundle.getEntry(zipPath);
-        try {
-            String demoZipPath = FileLocator.toFileURL(resourceURL).getPath();
-            TalendImportUtil.importItems(demoZipPath, new NullProgressMonitor(), false, true, false);
-            TalendImportUtil.openJob(jobName);
-        } catch (Throwable e) {
-            CommonExceptionHandler.process(e);
+        boolean alreadyImportDemoJob = OnBoardingResourceUtil.getPreferenceStore().getBoolean(OnBoardingResourceConstants.PREFERENCE_ALREADY_IMPORT_DEMO_JOB);
+        if (!alreadyImportDemoJob) {
+            OnBoardingResourceUtil.getPreferenceStore().setValue(OnBoardingResourceConstants.PREFERENCE_ALREADY_IMPORT_DEMO_JOB, true);
+            OnBoardingResourceUtil.savePreferenceStore();
+            Bundle bundle = Platform.getBundle(pluginId);
+            URL resourceURL = bundle.getEntry(zipPath);
+            try {
+                String demoZipPath = FileLocator.toFileURL(resourceURL).getPath();
+                TalendImportUtil.importItems(demoZipPath, new NullProgressMonitor(), false, true, false);
+            } catch (Throwable e) {
+                CommonExceptionHandler.process(e);
+            }
         }


Input:
public String renderString(String template, Map<String, Object> model, Locale locale, TemplateOutput templateOutput) {
    return render(new ByteArrayResource(template.getBytes()), "String_Node_Str", model, locale, templateOutput, false);
}

Output:
 public String renderString(String template, Map<String, Object> model, Locale locale, TemplateOutput templateOutput) {
-    return render(new ByteArrayResource(template.getBytes()), "String_Node_Str", model, locale, templateOutput, false);
+    return render(new ByteArrayResource(template.getBytes(StandardCharsets.UTF_8)), "String_Node_Str", model, locale, templateOutput, false);
 }


Input:
protected void populateResults(Page page, JSONObject nextJSONPage, LinearLayout resultsLayout, TextView resultsNo) throws JSONException {
    int curPageNum = ((LibraryResultsPage) page).getCurPageNum();
    JSONArray newObjects = nextJSONPage.getJSONArray("String_Node_Str");
    TextView pageNumView = new TextView(page);
    pageNumView.setText("String_Node_Str" + curPageNum);
    pageNumView.setGravity(Gravity.CENTER);
    if (curPageNum > 1) {
        resultsLayout.addView(pageNumView);
    }
    for (int i = 0; i < newObjects.length(); i++) {
        LinearLayout thisResultLayout = new LinearLayout(page);
        thisResultLayout.setOrientation(LinearLayout.VERTICAL);
        JSONObject thisResult = newObjects.getJSONObject(i);
        addTextField(page, thisResult, "String_Node_Str", "String_Node_Str", thisResultLayout, 18);
        addTextField(page, thisResult, "String_Node_Str", "String_Node_Str", thisResultLayout, 16);
        addTextField(page, thisResult, "String_Node_Str", "String_Node_Str", thisResultLayout, 16);
        addTextField(page, thisResult, "String_Node_Str", "String_Node_Str", thisResultLayout, 16);
        thisResultLayout.setBackgroundResource(R.drawable.bg_blue);
        thisResultLayout.setPadding(10, 10, 0, 10);
        thisResultLayout.setLayoutParams(Page.paramsWithLine);
        resultsLayout.addView(thisResultLayout);
    }
    if (nextJSONPage.getString("String_Node_Str").equals("String_Node_Str")) {
        resultsNo.setText("String_Node_Str" + "String_Node_Str");
    } else {
        resultsNo.setText("String_Node_Str" + nextJSONPage.getString("String_Node_Str") + "String_Node_Str" + '\n' + "String_Node_Str" + curPageNum + "String_Node_Str" + nextJSONPage.getString("String_Node_Str") + "String_Node_Str");
    }
}

Output:
     }
-    if (nextJSONPage.getString("String_Node_Str").equals("String_Node_Str")) {
+    if (nextJSONPage.getInt("String_Node_Str") == 0) {
         resultsNo.setText("String_Node_Str" + "String_Node_Str");


Input:
public void paint(Graphics2D g, boolean drawBiomes, boolean drawRivers, boolean drawSites, boolean drawCorners, boolean drawDelaunay, boolean drawVoronoi) {
    final int numSites = centers.size();
    Color[] defaultColors = null;
    if (!drawBiomes) {
        defaultColors = new Color[numSites];
        for (int i = 0; i < defaultColors.length; i++) {
            defaultColors[i] = new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255));
        }
    }
    for (Center c : centers) {
        g.setColor(drawBiomes ? getColor(c.biome) : defaultColors[c.index]);
        Corner edgeCorner1 = null;
        Corner edgeCorner2 = null;
        c.area = 0;
        for (Center n : c.neighbors) {
            Edge e = edgeWithCenters(c, n);
            if (e.v0 == null) {
                continue;
            }
            Corner cornerWithOneAdjacent = e.v0.border ? e.v0 : e.v1;
            if (cornerWithOneAdjacent.border) {
                if (edgeCorner1 == null) {
                    edgeCorner1 = cornerWithOneAdjacent;
                } else {
                    edgeCorner2 = cornerWithOneAdjacent;
                }
            }
            drawTriangle(g, e.v0, e.v1, c);
            c.area += Math.abs(c.loc.getX() * (e.v0.loc.getY() - e.v1.loc.getY()) + e.v0.loc.getX() * (e.v1.loc.getY() - c.loc.getY()) + e.v1.loc.getX() * (c.loc.getY() - e.v0.loc.getY())) / 2;
        }
        if (edgeCorner2 != null) {
            if (closeEnough(edgeCorner1.loc.getX(), edgeCorner2.loc.getX(), 1)) {
                drawTriangle(g, edgeCorner1, edgeCorner2, c);
            } else {
                int[] x = new int[4];
                int[] y = new int[4];
                x[0] = (int) c.loc.getX();
                y[0] = (int) c.loc.getY();
                x[1] = (int) edgeCorner1.loc.getX();
                y[1] = (int) edgeCorner1.loc.getY();
                x[2] = (int) ((closeEnough(edgeCorner1.loc.getX(), bounds.minX(), 1) || closeEnough(edgeCorner2.loc.getX(), bounds.minX(), .5)) ? bounds.minX() : bounds.maxX());
                y[2] = (int) ((closeEnough(edgeCorner1.loc.getY(), bounds.minY(), 1) || closeEnough(edgeCorner2.loc.getY(), bounds.minY(), .5)) ? bounds.minY() : bounds.maxY());
                x[3] = (int) edgeCorner2.loc.getX();
                y[3] = (int) edgeCorner2.loc.getY();
                g.fillPolygon(x, y, 4);
                c.area += 0;
            }
        }
    }
    for (Edge e : edges) {
        if (drawDelaunay) {
            g.setStroke(new BasicStroke(1));
            g.setColor(Color.YELLOW);
            g.drawLine((int) e.d0.loc.getX(), (int) e.d0.loc.getY(), (int) e.d1.loc.getX(), (int) e.d1.loc.getY());
        }
        if (drawRivers && e.river > 0) {
            g.setStroke(new BasicStroke(1 + (int) Math.sqrt(e.river * 2)));
            g.setColor(RIVER);
            g.drawLine((int) e.v0.loc.getX(), (int) e.v0.loc.getY(), (int) e.v1.loc.getX(), (int) e.v1.loc.getY());
        }
    }
    if (drawSites) {
        g.setColor(Color.BLACK);
        for (Center s : centers) {
            g.fillOval((int) (s.loc.getX() - 2), (int) (s.loc.getY() - 2), 4, 4);
        }
    }
    if (drawCorners) {
        g.setColor(Color.WHITE);
        for (Corner c : corners) {
            g.fillOval((int) (c.loc.getX() - 2), (int) (c.loc.getY() - 2), 4, 4);
        }
    }
    g.setColor(Color.WHITE);
    g.drawRect((int) bounds.minX(), (int) bounds.minY(), (int) bounds.width(), (int) bounds.height());
}

Output:
             g.setStroke(new BasicStroke(1 + (int) Math.sqrt(e.river * 2)));
-            g.setColor(RIVER);
+            g.setColor(getRiverColor());
             g.drawLine((int) e.v0.loc.getX(), (int) e.v0.loc.getY(), (int) e.v1.loc.getX(), (int) e.v1.loc.getY());


Input:
public List<String> getTopologyList(String topologyNameMatching) {
    LOG.debug("String_Node_Str" + topologyNameMatching);
    List<String> topologyList = new ArrayList<String>();
    String errMsg = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    if (topologyNameMatching == null || topologyNameMatching.trim().isEmpty()) {
        topologyNameMatching = "String_Node_Str";
    }
    try {
        Client client = null;
        ClientResponse response = null;
        try {
            client = Client.create();
            ;
            client.addFilter(new HTTPBasicAuthFilter(userName, password));
            WebResource webResource = client.resource(knoxUrl);
            response = webResource.accept(EXPECTED_MIME_TYPE).get(ClientResponse.class);
            LOG.debug("String_Node_Str" + response);
            if (response != null) {
                if (response.getStatus() == 200) {
                    String jsonString = response.getEntity(String.class);
                    LOG.debug("String_Node_Str" + jsonString);
                    ObjectMapper objectMapper = new ObjectMapper();
                    JsonNode rootNode = objectMapper.readTree(jsonString);
                    JsonNode topologyNode = rootNode.findValue("String_Node_Str");
                    if (topologyNode == null) {
                        return topologyList;
                    }
                    Iterator<JsonNode> elements = topologyNode.getElements();
                    while (elements.hasNext()) {
                        JsonNode element = elements.next();
                        String topologyName = element.get("String_Node_Str").getValueAsText();
                        LOG.debug("String_Node_Str" + topologyName);
                        if (topologyName.startsWith(topologyNameMatching)) {
                            topologyList.add(topologyName);
                        }
                    }
                } else {
                    LOG.error("String_Node_Str" + knoxUrl + "String_Node_Str" + response.getStatus());
                }
            } else {
                String msgDesc = "String_Node_Str" + "String_Node_Str" + knoxUrl + "String_Node_Str";
                LOG.error(msgDesc);
                HadoopException hdpException = new HadoopException(msgDesc);
                hdpException.generateResponseDataMap(false, msgDesc, msgDesc + errMsg, null, null);
                throw hdpException;
            }
        } finally {
            if (response != null) {
                response.close();
            }
            if (client != null) {
                client.destroy();
            }
        }
    } catch (Throwable t) {
        String msgDesc = "String_Node_Str" + knoxUrl + "String_Node_Str";
        HadoopException hdpException = new HadoopException(msgDesc, t);
        LOG.error(msgDesc, t);
        if (!(t instanceof HadoopException)) {
            hdpException.generateResponseDataMap(false, BaseClient.getMessage(t), msgDesc + errMsg, null, null);
        }
        throw hdpException;
    } finally {
    }
    return topologyList;
}

Output:
         LOG.error(msgDesc, t);
-        if (!(t instanceof HadoopException)) {
-            hdpException.generateResponseDataMap(false, BaseClient.getMessage(t), msgDesc + errMsg, null, null);
-        }
+        hdpException.generateResponseDataMap(false, BaseClient.getMessage(t), msgDesc + errMsg, null, null);
         throw hdpException;


Input:
public synchronized static void close() {
    try {
        LOGGER.info("String_Node_Str");
        if (disconfCoreMgr != null) {
            disconfCoreMgr.release();
        }
        if (timer != null) {
            timer.cancel();
            timer = null;
        }
        isFirstInit = false;
        isSecondeInit = false;
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
    }
}

Output:
         isFirstInit = false;
-        isSecondeInit = false;
+        isSecondInit = false;
     } catch (Exception e) {


Input:
public void setText(String text) {
    final boolean wasBlocking = shouldDisableDependents();
    mText = text;
    persistString(text);
    final boolean isBlocking = shouldDisableDependents();
    if (isBlocking != wasBlocking) {
        notifyDependencyChange(isBlocking);
    }
}

Output:
 public void setText(String text) {
-    final boolean wasBlocking = shouldDisableDependents();
-    mText = text;
-    persistString(text);
-    final boolean isBlocking = shouldDisableDependents();
-    if (isBlocking != wasBlocking) {
-        notifyDependencyChange(isBlocking);
+    final boolean changed = !TextUtils.equals(mText, text);
+    if (changed || !mTextSet) {
+        mText = text;
+        mTextSet = true;
+        persistString(text);
+        if (changed) {
+            notifyDependencyChange(shouldDisableDependents());
+            notifyChanged();
+        }
     }


Input:
public int getCurrentLevel() {
    BlockPos controllerPos = findBottomElevator();
    EnumFacing side = worldObj.getBlockState(getPos()).getValue(GenericBlock.FACING_HORIZ);
    TileEntity te = worldObj.getTileEntity(controllerPos);
    if (te instanceof ElevatorTileEntity) {
        ElevatorTileEntity controller = (ElevatorTileEntity) te;
        if (controller.cachedCurrent == -1) {
            int level = 0;
            for (int y = controllerPos.getY(); y < worldObj.getHeight(); y++) {
                BlockPos pos2 = getPosAtY(controllerPos, y);
                TileEntity te2 = worldObj.getTileEntity(pos2);
                if (te2 instanceof ElevatorTileEntity) {
                    EnumFacing side2 = worldObj.getBlockState(pos2).getValue(GenericBlock.FACING_HORIZ);
                    if (side == side2) {
                        BlockPos frontPos = pos2.offset(side);
                        if (isValidPlatformBlock(frontPos)) {
                            controller.cachedCurrent = level;
                        }
                        level++;
                    }
                }
            }
        }
        return controller.cachedCurrent;
    }
    return 0;
}

Output:
     BlockPos controllerPos = findBottomElevator();
-    EnumFacing side = worldObj.getBlockState(getPos()).getValue(GenericBlock.FACING_HORIZ);
+    IBlockState blockState = worldObj.getBlockState(getPos());
+    if (blockState.getBlock() != ElevatorSetup.elevatorBlock) {
+        return 0;
+    }
+    EnumFacing side = blockState.getValue(GenericBlock.FACING_HORIZ);
     TileEntity te = worldObj.getTileEntity(controllerPos);


Input:
public <T extends Resource> T fetchResourceWithException(Class<T> class_, String uri) throws FHIRException {
    if (class_ == null) {
        if (Utilities.isAbsoluteUrl(uri) || uri.startsWith("String_Node_Str")) {
            Resource res = findTxValueSet(uri);
            if (res != null)
                return (T) res;
        }
        return null;
    }
    if (class_ == StructureDefinition.class && !uri.contains("String_Node_Str"))
        uri = "String_Node_Str" + uri;
    synchronized (lock) {
        if (uri.startsWith("String_Node_Str") || uri.startsWith("String_Node_Str")) {
            String version = null;
            if (uri.contains("String_Node_Str"))
                uri = uri.substring(0, uri.indexOf("String_Node_Str"));
            if (class_ == Resource.class) {
                if (structures.containsKey(uri))
                    return (T) structures.get(uri);
                if (valueSets.containsKey(uri))
                    return (T) valueSets.get(uri);
                if (codeSystems.containsKey(uri))
                    return (T) codeSystems.get(uri);
                if (operations.containsKey(uri))
                    return (T) operations.get(uri);
                if (searchParameters.containsKey(uri))
                    return (T) searchParameters.get(uri);
                if (maps.containsKey(uri))
                    return (T) maps.get(uri);
                if (transforms.containsKey(uri))
                    return (T) transforms.get(uri);
                return null;
            } else if (class_ == StructureDefinition.class) {
                return (T) structures.get(uri);
            } else if (class_ == ValueSet.class) {
                return (T) valueSets.get(uri);
            } else if (class_ == CodeSystem.class) {
                return (T) codeSystems.get(uri);
            } else if (class_ == OperationDefinition.class) {
                OperationDefinition od = operations.get(uri);
                return (T) od;
            } else if (class_ == SearchParameter.class) {
                SearchParameter res = searchParameters.get(uri);
                if (res == null) {
                    StringBuilder b = new StringBuilder();
                    for (String s : searchParameters.keySet()) {
                        b.append(s);
                        b.append("String_Node_Str");
                    }
                }
                return (T) res;
            }
        }
        if (class_ == Questionnaire.class)
            return null;
        throw new FHIRException("String_Node_Str" + uri);
    }
}

Output:
                 uri = uri.substring(0, uri.indexOf("String_Node_Str"));
-            if (class_ == Resource.class) {
+            if (class_ == Resource.class || class_ == null) {
                 if (structures.containsKey(uri))


Input:
public void spaces_available_is_required() {
    givenWithContent(authToken).body(minValidPayload().put(Key.SPACES_AVAILABLE, null).asArray()).when().put(UrlSchema.FACILITY_UTILIZATION, f.id).then().spec(assertResponse(HttpStatus.BAD_REQUEST, ValidationException.class)).body("String_Node_Str", is(Key.SPACES_AVAILABLE)).body("String_Node_Str", is("String_Node_Str"));
}

Output:
 public void spaces_available_is_required() {
-    givenWithContent(authToken).body(minValidPayload().put(Key.SPACES_AVAILABLE, null).asArray()).when().put(UrlSchema.FACILITY_UTILIZATION, f.id).then().spec(assertResponse(HttpStatus.BAD_REQUEST, ValidationException.class)).body("String_Node_Str", is(Key.SPACES_AVAILABLE)).body("String_Node_Str", is("String_Node_Str"));
+    givenWithContent(authToken).body(minValidPayload().put(Key.SPACES_AVAILABLE, null).asArray()).when().put(UrlSchema.FACILITY_UTILIZATION, f.id).then().spec(assertResponse(HttpStatus.BAD_REQUEST, ValidationException.class)).body("String_Node_Str", is("String_Node_Str" + Key.SPACES_AVAILABLE)).body("String_Node_Str", is("String_Node_Str"));
 }


Input:
public void run() throws Exception {
    response = new MapEntrySet();
    final InternalPartitionService partitionService = getNodeEngine().getPartitionService();
    final RecordStore recordStore = mapService.getRecordStore(getPartitionId(), name);
    MapEntrySimple entry;
    for (Data key : keys) {
        if (partitionService.getPartitionId(key) != getPartitionId())
            continue;
        Object objectKey = mapService.toObject(key);
        final Map.Entry<Data, Object> mapEntry = recordStore.getMapEntry(key);
        final Object valueBeforeProcess = mapService.toObject(mapEntry.getValue());
        entry = new MapEntrySimple(objectKey, valueBeforeProcess);
        final Object result = entryProcessor.process(entry);
        final Object valueAfterProcess = entry.getValue();
        Data dataValue = null;
        if (result != null) {
            dataValue = mapService.toData(result);
            response.add(new AbstractMap.SimpleImmutableEntry<Data, Data>(key, dataValue));
        }
        EntryEventType eventType;
        if (valueAfterProcess == null) {
            recordStore.remove(key);
            eventType = EntryEventType.REMOVED;
        } else {
            if (valueBeforeProcess == null) {
                eventType = EntryEventType.ADDED;
            } else if (!entry.isModified()) {
                eventType = __NO_NEED_TO_FIRE_EVENT;
            } else {
                eventType = EntryEventType.UPDATED;
            }
            if (eventType != __NO_NEED_TO_FIRE_EVENT) {
                recordStore.put(new AbstractMap.SimpleImmutableEntry<Data, Object>(key, valueAfterProcess));
            }
        }
        if (eventType != __NO_NEED_TO_FIRE_EVENT) {
            Data dataOldValue = mapService.toData(mapEntry.getValue());
            mapService.publishEvent(getCallerAddress(), name, eventType, key, dataOldValue, dataValue);
            if (mapContainer.isNearCacheEnabled() && mapContainer.getMapConfig().getNearCacheConfig().isInvalidateOnChange()) {
                mapService.invalidateAllNearCaches(name, key);
            }
            if (mapContainer.getWanReplicationPublisher() != null && mapContainer.getWanMergePolicy() != null) {
                if (EntryEventType.REMOVED.equals(eventType)) {
                    mapService.publishWanReplicationRemove(name, key, Clock.currentTimeMillis());
                } else {
                    Record r = recordStore.getRecord(key);
                    Data tempValue = mapService.toData(dataValue);
                    RecordStatistics statistics = r.getStatistics();
                    long cost = r.getCost();
                    long version = r.getVersion();
                    SimpleEntryView entryView = new SimpleEntryView(key, tempValue, statistics, cost, version);
                    mapService.publishWanReplicationUpdate(name, entryView);
                }
            }
        }
    }
}

Output:
             mapService.publishEvent(getCallerAddress(), name, eventType, key, dataOldValue, dataValue);
-            if (mapContainer.isNearCacheEnabled() && mapContainer.getMapConfig().getNearCacheConfig().isInvalidateOnChange()) {
+            if (mapService.isNearCacheAndInvalidationEnabled(name)) {
                 mapService.invalidateAllNearCaches(name, key);


Input:
private int executeInProcess(ExecutionContext context) {
    if (D8.equals(dexTool)) {
        D8DiagnosticsHandler diagnosticsHandler = new D8DiagnosticsHandler();
        try {
            Set<Path> inputs = new HashSet<>();
            for (Path rawFile : filesToDex) {
                Path toDex = filesystem.resolve(rawFile);
                if (Files.isRegularFile(toDex)) {
                    inputs.add(toDex);
                } else {
                    Files.newDirectoryStream(toDex, path -> path.toFile().isFile()).forEach(inputs::add);
                }
            }
            boolean outputToDex = outputDexFile.getFileName().toString().endsWith("String_Node_Str");
            Path output = outputToDex ? Files.createTempDirectory("String_Node_Str") : outputDexFile;
            D8Command.Builder builder = D8Command.builder().addProgramFiles(inputs).setIntermediate(intermediate).setMode(options.contains(Option.NO_OPTIMIZE) ? CompilationMode.DEBUG : CompilationMode.RELEASE).setDiagnosticsHandler(diagnosticsHandler).setOutputPath(output);
            D8Output d8Output = com.android.tools.r8.D8.run(builder.build());
            if (outputToDex) {
                File[] outputs = output.toFile().listFiles();
                if (outputs != null && (outputs.length > 0)) {
                    Files.move(outputs[0].toPath(), outputDexFile, StandardCopyOption.REPLACE_EXISTING);
                }
            }
            resourcesReferencedInCode = d8Output.getReferencedResources();
            return 0;
        } catch (CompilationException | IOException e) {
            context.postEvent(ConsoleEvent.severe(String.join(System.lineSeparator(), diagnosticsHandler.diagnostics.stream().map(Diagnostic::getDiagnosticMessage).collect(MoreCollectors.toImmutableList()))));
            e.printStackTrace(context.getStdErr());
            return 1;
        }
    } else if (DX.equals(dexTool)) {
        ImmutableList<String> argv = getShellCommandInternal(context);
        Preconditions.checkState(argv.get(0).endsWith(File.separator + "String_Node_Str") || argv.get(0).endsWith("String_Node_Str"));
        Preconditions.checkState(argv.get(1).equals("String_Node_Str"));
        ImmutableList<String> args = argv.subList(2, argv.size());
        ByteArrayOutputStream stderr = new ByteArrayOutputStream();
        PrintStream stderrStream = new PrintStream(stderr);
        try {
            com.android.dx.command.dexer.DxContext dxContext = new com.android.dx.command.dexer.DxContext(context.getStdOut(), stderrStream);
            com.android.dx.command.dexer.Main.Arguments arguments = new com.android.dx.command.dexer.Main.Arguments();
            com.android.dx.command.dexer.Main dexer = new com.android.dx.command.dexer.Main(dxContext);
            arguments.parseCommandLine(args.toArray(new String[args.size()]), dxContext);
            int returncode = dexer.run(arguments);
            String stdErrOutput = stderr.toString();
            if (!stdErrOutput.isEmpty()) {
                context.postEvent(ConsoleEvent.warning("String_Node_Str", stdErrOutput));
            }
            if (returncode == 0) {
                resourcesReferencedInCode = dexer.getReferencedResourceNames();
            }
            return returncode;
        } catch (IOException e) {
            e.printStackTrace(context.getStdErr());
            return 1;
        }
    } else {
        return 1;
    }
}

Output:
             Path output = outputToDex ? Files.createTempDirectory("String_Node_Str") : outputDexFile;
-            D8Command.Builder builder = D8Command.builder().addProgramFiles(inputs).setIntermediate(intermediate).setMode(options.contains(Option.NO_OPTIMIZE) ? CompilationMode.DEBUG : CompilationMode.RELEASE).setDiagnosticsHandler(diagnosticsHandler).setOutputPath(output);
+            D8Command.Builder builder = D8Command.builder(diagnosticsHandler).addProgramFiles(inputs).setIntermediate(intermediate).setMode(options.contains(Option.NO_OPTIMIZE) ? CompilationMode.DEBUG : CompilationMode.RELEASE).setOutputPath(output);
             D8Output d8Output = com.android.tools.r8.D8.run(builder.build());


Input:
private void exitApplication() {
    if (tempFiles.size() > 0) {
        long totalFileSize = 0;
        for (File tempFile : tempFiles) totalFileSize += tempFile.length();
        int res = JOptionPane.showConfirmDialog(this, "String_Node_Str" + tempFiles.size() + "String_Node_Str" + totalFileSize + "String_Node_Str" + System.getProperty("String_Node_Str") + "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
        if (res == JOptionPane.YES_OPTION) {
            for (File tempFile : tempFiles) {
                if (!tempFile.exists())
                    continue;
                boolean delRes = tempFile.delete();
                while (!delRes) {
                    int res2 = JOptionPane.showConfirmDialog(this, "String_Node_Str" + tempFile.getAbsolutePath() + "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.ERROR_MESSAGE);
                    if (res2 == JOptionPane.YES_OPTION)
                        delRes = tempFile.delete();
                    else if (res2 == JOptionPane.NO_OPTION)
                        break;
                    else
                        return;
                }
            }
        } else if (res != JOptionPane.NO_OPTION)
            return;
    }
    setVisible(false);
    if (fsHandler != null) {
        fsHandler.close();
    }
    System.exit(0);
}

Output:
 private void exitApplication() {
-    if (tempFiles.size() > 0) {
-        long totalFileSize = 0;
-        for (File tempFile : tempFiles) totalFileSize += tempFile.length();
-        int res = JOptionPane.showConfirmDialog(this, "String_Node_Str" + tempFiles.size() + "String_Node_Str" + totalFileSize + "String_Node_Str" + System.getProperty("String_Node_Str") + "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
-        if (res == JOptionPane.YES_OPTION) {
+    try {
+        if (tempFiles.size() > 0) {
+            long totalFileSize = 0;
             for (File tempFile : tempFiles) {