Input:
public static void mergeIndex(String destination, List<String> indexList) {
    LOGGER.debug("String_Node_Str" + destination);
    Index index = new Index();
    index.setCreate(false);
    IndexWriter indexWriter = index.createIndexWriter(destination);
    try {
        LOGGER.info("String_Node_Str");
        FSDirectory[] fsDirs = new FSDirectory[indexList.size()];
        for (int i = 0; i < indexList.size(); i++) {
            fsDirs[i] = FSDirectory.getDirectory(indexList.get(i));
        }
        indexWriter.addIndexesNoOptimize(fsDirs);
        indexWriter.optimize();
        indexWriter.close();
        LOGGER.info("String_Node_Str");
    } catch (Exception e) {
        LOGGER.error("String_Node_Str" + e);
    }
}

Output:
     } catch (Exception e) {
-        LOGGER.error("String_Node_Str" + e);
+        LOGGER.error("String_Node_Str", e);
     }


Input:
public Plan getPlan(final String... args) {
    int noSubtasks = (args.length > 0 ? Integer.parseInt(args[0]) : 1);
    String ordersPath = (args.length > 1 ? args[1] : "String_Node_Str");
    String lineitemsPath = (args.length > 2 ? args[2] : "String_Node_Str");
    String output = (args.length > 3 ? args[3] : "String_Node_Str");
    FileDataSource orders = new FileDataSource(NewTupleInFormat.class, ordersPath, "String_Node_Str");
    orders.setParameter(NewTupleInFormat.RECORD_DELIMITER, "String_Node_Str");
    orders.getCompilerHints().setAvgNumValuesPerKey(1);
    FileDataSource lineitems = new FileDataSource(NewTupleInFormat.class, lineitemsPath, "String_Node_Str");
    lineitems.setParameter(NewTupleInFormat.RECORD_DELIMITER, "String_Node_Str");
    lineitems.getCompilerHints().setAvgNumValuesPerKey(4);
    MapContract filterO = new MapContract(FilterO.class, orders, "String_Node_Str");
    filterO.setParameter("String_Node_Str", 1993);
    filterO.setParameter("String_Node_Str", "String_Node_Str");
    filterO.getCompilerHints().setAvgBytesPerRecord(16);
    filterO.getCompilerHints().setAvgRecordsEmittedPerStubCall(0.05f);
    filterO.getCompilerHints().setAvgNumValuesPerKey(1);
    MapContract projectLi = new MapContract(ProjectLi.class, lineitems, "String_Node_Str");
    projectLi.getCompilerHints().setAvgBytesPerRecord(20);
    projectLi.getCompilerHints().setAvgRecordsEmittedPerStubCall(1.0f);
    projectLi.getCompilerHints().setAvgNumValuesPerKey(4);
    MatchContract joinLiO = new MatchContract(JoinLiO.class, PactLong.class, 0, 0, filterO, projectLi, "String_Node_Str");
    joinLiO.getCompilerHints().setAvgBytesPerRecord(24);
    joinLiO.getCompilerHints().setAvgNumValuesPerKey(4);
    ReduceContract aggLiO = new ReduceContract(AggLiO.class, new Class[] { PactLong.class, PactString.class }, new int[] { 0, 1 }, joinLiO, "String_Node_Str");
    aggLiO.getCompilerHints().setAvgBytesPerRecord(30);
    aggLiO.getCompilerHints().setAvgRecordsEmittedPerStubCall(1.0f);
    aggLiO.getCompilerHints().setAvgNumValuesPerKey(1);
    FileDataSink result = new FileDataSink(RecordOutputFormat.class, output, aggLiO, "String_Node_Str");
    result.getParameters().setString(RecordOutputFormat.RECORD_DELIMITER_PARAMETER, "String_Node_Str");
    result.getParameters().setString(RecordOutputFormat.FIELD_DELIMITER_PARAMETER, "String_Node_Str");
    result.getParameters().setInteger(RecordOutputFormat.NUM_FIELDS_PARAMETER, 3);
    result.getParameters().setClass(RecordOutputFormat.FIELD_TYPE_PARAMETER_PREFIX + 0, PactLong.class);
    result.getParameters().setClass(RecordOutputFormat.FIELD_TYPE_PARAMETER_PREFIX + 1, PactString.class);
    result.getParameters().setClass(RecordOutputFormat.FIELD_TYPE_PARAMETER_PREFIX + 2, PactDouble.class);
    Plan plan = new Plan(result, "String_Node_Str");
    plan.setDefaultParallelism(noSubtasks);
    return plan;
}

Output:
     MapContract filterO = new MapContract(FilterO.class, orders, "String_Node_Str");
-    filterO.setParameter("String_Node_Str", 1993);
-    filterO.setParameter("String_Node_Str", "String_Node_Str");
+    filterO.setParameter(YEAR_FILTER, 1993);
+    filterO.setParameter(PRIO_FILTER, "String_Node_Str");
     filterO.getCompilerHints().setAvgBytesPerRecord(16);


Input:
public void onActionMove(MotionEvent event) {
    final int pointerIndex = event.findPointerIndex(mEditorView.getActivePointerId());
    final int x = (int) event.getX(pointerIndex);
    final int y = (int) event.getY(pointerIndex);
    if (!mEditorView.scaleDetectorActive()) {
        final int offX = x - mEditorView.getLastTouchX();
        final int offY = y - mEditorView.getLastTouchY();
        mTweetFlow.moveTouchElement(offX, offY);
        mEditorView.redraw();
    }
    mEditorView.setLastTouch(x, y);
}

Output:
         final int offY = y - mEditorView.getLastTouchY();
-        mTweetFlow.moveTouchElement(offX, offY);
+        float scale = mEditorView.getmScaleFactor();
+        mTweetFlow.moveTouchElement((int) (offX / scale), (int) (offY / scale));
         mEditorView.redraw();


Input:
public long innerEntrySize(long sizeOfEverythingBeforeValue, long valueSize) {
    if (mh.m().constantlySizedEntry) {
        return alignAddr(sizeOfEverythingBeforeValue + valueSize, mh.m().alignment);
    } else if (mh.m().couldNotDetermineAlignmentBeforeAllocation) {
        return sizeOfEverythingBeforeValue + mh.m().worstAlignment + valueSize;
    } else {
        return alignAddr(sizeOfEverythingBeforeValue, mh.m().alignment) + valueSize;
    }
}

Output:
     if (mh.m().constantlySizedEntry) {
-        return alignAddr(sizeOfEverythingBeforeValue + valueSize, mh.m().alignment);
+        sizeWithoutChecksum = alignAddr(sizeOfEverythingBeforeValue + valueSize, mh.m().alignment);
     } else if (mh.m().couldNotDetermineAlignmentBeforeAllocation) {


Input:
protected void onDestroy() {
    tracker.trackEvent(app.getExperiment().getParticipant().getCode(), "String_Node_Str", "String_Node_Str" + System.currentTimeMillis() + "String_Node_Str", (int) System.currentTimeMillis());
    tracker.stop();
    super.onDestroy();
}

Output:
 protected void onDestroy() {
-    tracker.trackEvent(app.getExperiment().getParticipant().getCode(), "String_Node_Str", "String_Node_Str" + System.currentTimeMillis() + "String_Node_Str", (int) System.currentTimeMillis());
-    tracker.stop();
+    try {
+        tracker.trackEvent(app.getExperiment().getParticipant().getCode(), "String_Node_Str", "String_Node_Str" + System.currentTimeMillis() + "String_Node_Str", (int) System.currentTimeMillis());
+        tracker.stop();
+    } catch (Exception e) {
+        Log.e(TAG, "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+    }
     super.onDestroy();


Input:
public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
    MessageMetrics metrics = ctx.attr(ATTR_KEY_METRICS).get();
    m_collector.addMetrics(metrics);
    super.close(ctx, promise);
}

Output:
     MessageMetrics metrics = ctx.attr(ATTR_KEY_METRICS).get();
-    m_collector.addMetrics(metrics);
+    m_collector.sumReadMessages(metrics.messagesRead());
+    m_collector.sumWroteMessages(metrics.messagesWrote());
     super.close(ctx, promise);


Input:
public void checkPointsCopied() {
    fail("String_Node_Str");
}

Output:
 public void checkPointsCopied() {
-    fail("String_Node_Str");
+    List<Point2D_F32> src = createTestPoints();
+    List<Point2D_F32> dst = createTestPoints();
+    PointDeformKeyPoints alg = createAlgorithm();
+    alg.setImageShape(80, 100);
+    alg.setSource(src);
+    alg.setSource(dst);
+    Point2D_F32 expected = new Point2D_F32();
+    alg.compute(12, 19.5f, expected);
+    for (int i = 0; i < src.size(); i++) {
+        src.get(i).x += 2.5;
+        dst.get(i).x += 2.5;
+    }
+    Point2D_F32 found = new Point2D_F32();
+    alg.compute(12, 19.5f, found);
+    assertEquals(expected.x, found.x, GrlConstants.FLOAT_TEST_TOL);
+    assertEquals(expected.y, found.y, GrlConstants.FLOAT_TEST_TOL);
 }


Input:
public Map<String, List<String>> getVirtualAttributeMap() {
    Map<String, List<String>> result = new HashMap<String, List<String>>(virtualAttributes.size());
    for (AttributeTO attributeTO : virtualAttributes) {
        result.put(attributeTO.getSchema(), attributeTO.getValues());
    }
    return result;
}

Output:
     for (AttributeTO attributeTO : virtualAttributes) {
-        result.put(attributeTO.getSchema(), attributeTO.getValues());
+        result.put(attributeTO.getSchema(), attributeTO);
     }


Input:
public boolean onCommand(final CommandCaller caller, final String[] args) {
    PlotPlayer plr = (caller instanceof PlotPlayerCaller) ? (PlotPlayer) caller.getSuperCaller() : null;
    String name;
    if (plr == null) {
        name = "String_Node_Str";
    } else {
        name = plr.getName();
    }
    if (!SetupUtils.setupMap.containsKey(name)) {
        final SetupObject object = new SetupObject();
        SetupUtils.setupMap.put(name, object);
        SetupUtils.manager.updateGenerators();
        sendMessage(plr, C.SETUP_INIT);
        displayGenerators(plr);
        return false;
    }
    if (args.length == 1) {
        if (args[0].equalsIgnoreCase("String_Node_Str")) {
            SetupUtils.setupMap.remove(name);
            MainUtil.sendMessage(plr, "String_Node_Str");
            return false;
        }
        if (args[0].equalsIgnoreCase("String_Node_Str")) {
            final SetupObject object = SetupUtils.setupMap.get(name);
            if (object.setup_index > 0) {
                object.setup_index--;
                final ConfigurationNode node = object.step[object.setup_index];
                sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", node.getDescription(), node.getType().getType(), node.getDefaultValue() + "String_Node_Str");
                return false;
            } else if (object.current > 0) {
                object.current--;
            }
        }
    }
    final SetupObject object = SetupUtils.setupMap.get(name);
    final int index = object.current;
    switch(index) {
        case 0:
            {
                if ((args.length != 1) || !SetupUtils.generators.containsKey(args[0])) {
                    final String prefix = "String_Node_Str";
                    MainUtil.sendMessage(plr, "String_Node_Str" + prefix + StringUtils.join(SetupUtils.generators.keySet(), prefix).replaceAll("String_Node_Str", "String_Node_Str"));
                    sendMessage(plr, C.SETUP_INIT);
                    return false;
                }
                object.setupGenerator = args[0];
                object.current++;
                final String partial = Settings.ENABLE_CLUSTERS ? "String_Node_Str" : "String_Node_Str";
                MainUtil.sendMessage(plr, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + partial);
                break;
            }
        case 1:
            {
                List<String> allTypes = Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" });
                List<String> allDesc = Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" });
                ArrayList<String> types = new ArrayList<>();
                if (SetupUtils.generators.get(object.setupGenerator) instanceof PlotGenerator) {
                    types.add("String_Node_Str");
                }
                types.add("String_Node_Str");
                if (Settings.ENABLE_CLUSTERS) {
                    types.add("String_Node_Str");
                }
                if ((args.length != 1) || !types.contains(args[0].toLowerCase())) {
                    MainUtil.sendMessage(plr, "String_Node_Str");
                    for (String type : types) {
                        int i = allTypes.indexOf(type);
                        if (type.equals("String_Node_Str")) {
                            MainUtil.sendMessage(plr, "String_Node_Str" + type + "String_Node_Str" + allDesc.get(i));
                        } else {
                            MainUtil.sendMessage(plr, "String_Node_Str" + type + "String_Node_Str" + allDesc.get(i));
                        }
                    }
                    return false;
                }
                object.type = allTypes.indexOf(args[0].toLowerCase());
                ChunkGenerator gen = SetupUtils.generators.get(object.setupGenerator);
                if (object.type == 0) {
                    object.current++;
                    if (object.step == null) {
                        object.plotManager = object.setupGenerator;
                        object.step = ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).getNewPlotWorld(null).getSettingNodes();
                        ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).processSetup(object);
                    }
                    if (object.step.length == 0) {
                        object.current = 4;
                        MainUtil.sendMessage(plr, "String_Node_Str");
                        object.setup_index = 0;
                        return true;
                    }
                    final ConfigurationNode step = object.step[object.setup_index];
                    sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", step.getDescription(), step.getType().getType(), step.getDefaultValue() + "String_Node_Str");
                } else {
                    if (gen instanceof PlotGenerator) {
                        object.plotManager = object.setupGenerator;
                        object.setupGenerator = null;
                        object.step = ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).getNewPlotWorld(null).getSettingNodes();
                        ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).processSetup(object);
                    } else {
                        object.plotManager = "String_Node_Str";
                        MainUtil.sendMessage(plr, "String_Node_Str");
                        MainUtil.sendMessage(plr, "String_Node_Str");
                        object.step = ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).getNewPlotWorld(null).getSettingNodes();
                    }
                    MainUtil.sendMessage(plr, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
                }
                object.current++;
                break;
            }
        case 2:
            {
                final List<String> terrain = Arrays.asList(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" });
                if ((args.length != 1) || !terrain.contains(args[0].toLowerCase())) {
                    MainUtil.sendMessage(plr, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
                    return false;
                }
                object.terrain = terrain.indexOf(args[0].toLowerCase());
                object.current++;
                if (object.step == null) {
                    object.step = ((PlotGenerator) SetupUtils.generators.get(object.plotManager)).getNewPlotWorld(null).getSettingNodes();
                }
                final ConfigurationNode step = object.step[object.setup_index];
                sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", step.getDescription(), step.getType().getType(), step.getDefaultValue() + "String_Node_Str");
                break;
            }
        case 3:
            {
                if (object.setup_index == object.step.length) {
                    MainUtil.sendMessage(plr, "String_Node_Str");
                    object.setup_index = 0;
                    object.current++;
                    return true;
                }
                ConfigurationNode step = object.step[object.setup_index];
                if (args.length < 1) {
                    sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", step.getDescription(), step.getType().getType(), step.getDefaultValue() + "String_Node_Str");
                    return false;
                }
                final boolean valid = step.isValid(args[0]);
                if (valid) {
                    sendMessage(plr, C.SETUP_VALID_ARG, step.getConstant(), args[0]);
                    step.setValue(args[0]);
                    object.setup_index++;
                    if (object.setup_index == object.step.length) {
                        onCommand(caller, args);
                        return false;
                    }
                    step = object.step[object.setup_index];
                    sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", step.getDescription(), step.getType().getType(), step.getDefaultValue() + "String_Node_Str");
                    return false;
                } else {
                    sendMessage(plr, C.SETUP_INVALID_ARG, args[0], step.getConstant());
                    sendMessage(plr, C.SETUP_STEP, object.setup_index + 1 + "String_Node_Str", step.getDescription(), step.getType().getType(), step.getDefaultValue() + "String_Node_Str");
                    return false;
                }
            }
        case 4:
            {
                if (args.length != 1) {
                    MainUtil.sendMessage(plr, "String_Node_Str");
                    return false;
                }
                if (BlockManager.manager.isWorld(args[0])) {
                    MainUtil.sendMessage(plr, "String_Node_Str");
                }
                object.world = args[0];
                SetupUtils.setupMap.remove(name);
                final String world;
                if (object.setupManager == null) {
                    world = SetupUtils.manager.setupWorld(object);
                } else {
                    world = object.setupManager.setupWorld(object);
                }
                try {
                    if (plr != null) {
                        plr.teleport(BlockManager.manager.getSpawn(world));
                    }
                } catch (final Exception e) {
                    plr.sendMessage("String_Node_Str");
                    e.printStackTrace();
                }
                sendMessage(plr, C.SETUP_FINISHED, object.world);
                SetupUtils.setupMap.remove(name);
            }
    }
    return false;
}

Output:
                 ArrayList<String> types = new ArrayList<>();
-                if (SetupUtils.generators.get(object.setupGenerator) instanceof PlotGenerator) {
+                if (SetupUtils.generators.get(object.setupGenerator) instanceof BukkitPlotGenerator) {
                     types.add("String_Node_Str");


Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.plugin_list_fragment, container, false);
    mRecycler = view.findViewById(R.id.recycler);
    mRecycler.setLayoutManager(new LinearLayoutManager(getActivity(), LinearLayoutManager.VERTICAL, false));
    mRecycler.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL_LIST));
    mSwipeToRefreshHelper = buildSwipeToRefreshHelper((CustomSwipeRefreshLayout) view.findViewById(R.id.ptr_layout), new SwipeToRefreshHelper.RefreshListener() {
        public void onRefreshStarted() {
            mViewModel.pullToRefresh(mListType);
        }
    });
    return view;
}

Output:
     mRecycler.setLayoutManager(new LinearLayoutManager(getActivity(), LinearLayoutManager.VERTICAL, false));
-    mRecycler.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL_LIST));
+    mRecycler.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL));
     mSwipeToRefreshHelper = buildSwipeToRefreshHelper((CustomSwipeRefreshLayout) view.findViewById(R.id.ptr_layout), new SwipeToRefreshHelper.RefreshListener() {


Input:
protected String toStatement(Object[][] mtrx, String sql) {
    StringBuilder sb = new StringBuilder();
    String[] ss = sql.split("String_Node_Str");
    int i;
    for (i = 0; i < mtrx[0].length; i++) {
        sb.append(ss[i]);
        sb.append(Sqls.formatFieldValue(mtrx[0][i]));
    }
    if (i < ss.length)
        sb.append(ss[i]);
    return sb.toString();
}

Output:
     String[] ss = sql.split("String_Node_Str");
-    int i;
-    for (i = 0; i < mtrx[0].length; i++) {
-        sb.append(ss[i]);
-        sb.append(Sqls.formatFieldValue(mtrx[0][i]));
+    int i = 0;
+    if (mtrx.length > 0) {
+        for (; i < mtrx[0].length; i++) {
+            sb.append(ss[i]);
+            sb.append(Sqls.formatFieldValue(mtrx[0][i]));
+        }
     }


Input:
public boolean start() throws IOException {
    synchronized (PROCESS_LOCK) {
        if (!isStarted) {
            if (!prepare()) {
                Log.e(Aavt.debugTag, "String_Node_Str");
                return false;
            }
            isUserWantToStop = false;
            isVideoExtractorEnd = false;
            isVideoExtractorEnd = false;
            mGLThreadFlag = true;
            mVideoDecoder.start();
            if (!isRenderToWindowSurface) {
                mVideoEncoder.start();
            }
            mGLThread = new Thread(new Runnable() {
                public void run() {
                    glRunnable();
                }
            });
            mGLThread.start();
            mCodecFlag = true;
            mDecodeThread = new Thread(new Runnable() {
                public void run() {
                    if (mVideoDecoderTrack >= 0) {
                        Log.d(Aavt.debugTag, "String_Node_Str");
                        codecNum = 0;
                        while (mCodecFlag && !videoDecodeStep()) {
                        }
                        ;
                        Log.d(Aavt.debugTag, "String_Node_Str" + codecNum);
                        mGLThreadFlag = false;
                        try {
                            mSem.release();
                            mGLThread.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if (mAudioDecoderTrack >= 0 && mVideoEncoderTrack >= 0) {
                        ByteBuffer buffer = ByteBuffer.allocate(1024 * 32);
                        while (mCodecFlag && !audioDecodeStep(buffer)) {
                        }
                        ;
                        buffer.clear();
                    }
                    Log.d(Aavt.debugTag, "String_Node_Str");
                    mCodecFlag = false;
                    avStop();
                    if (mProgressListener != null) {
                        mProgressListener.onComplete(mOutputPath);
                    }
                }
            });
            mDecodeThread.start();
            isStarted = true;
        }
    }
    return true;
}

Output:
             if (!prepare()) {
-                Log.e(Aavt.debugTag, "String_Node_Str");
+                AvLog.d("String_Node_Str");
                 return false;


Input:
public IType getType() {
    return Types.VOID;
}

Output:
 public IType getType() {
-    return Types.VOID;
+    return this.annotation.getType();
 }


Input:
public static PutFileRet putFile(String url, String tblName, String key, String mimeType, String localFile, String customMeta, HashMap<String, String> callbackParams) throws RSException {
    File file = new File(localFile);
    if (!file.exists() || !file.canRead()) {
        return new PutFileRet(new CallRet(400, new Exception("String_Node_Str")));
    }
    if (mimeType == null || mimeType.isEmpty()) {
        mimeType = "String_Node_Str";
    }
    String entryURI = tblName + "String_Node_Str" + key;
    String action = "String_Node_Str" + Base64.encodeBase64String(entryURI.getBytes()) + "String_Node_Str" + Base64.encodeBase64String(mimeType.getBytes());
    if (customMeta != null && !customMeta.isEmpty()) {
        action += "String_Node_Str" + Base64.encodeBase64String(customMeta.getBytes());
    }
    MultipartEntity requestEntity = new MultipartEntity();
    try {
        requestEntity.addPart("String_Node_Str", new StringBody(action));
    } catch (UnsupportedEncodingException e1) {
        e1.printStackTrace();
    }
    FileBody fileBody = new FileBody(new File(localFile));
    requestEntity.addPart("String_Node_Str", fileBody);
    if (callbackParams != null && !callbackParams.isEmpty()) {
        ArrayList<NameValuePair> callbackParamList = new ArrayList<NameValuePair>();
        for (Entry<String, String> entry : callbackParams.entrySet()) {
            callbackParamList.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }
        try {
            requestEntity.addPart("String_Node_Str", new StringBody(URLEncodedUtils.format(callbackParamList, "String_Node_Str")));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
    HttpPost postMethod = new HttpPost(url);
    postMethod.setEntity(requestEntity);
    DefaultHttpClient client = new DefaultHttpClient();
    try {
        HttpResponse response = client.execute(postMethod);
        return handleResult(response);
    } catch (Exception e) {
        e.printStackTrace();
        return new PutFileRet(new CallRet(400, e));
    } finally {
        client.getConnectionManager().shutdown();
    }
}

Output:
     }
-    String entryURI = tblName + "String_Node_Str" + key;
+    String entryURI = bucketName + "String_Node_Str" + key;
     String action = "String_Node_Str" + Base64.encodeBase64String(entryURI.getBytes()) + "String_Node_Str" + Base64.encodeBase64String(mimeType.getBytes());


Input:
public void testEvaluateCommandLineParameters() {
    final String defaultDataDirectory = System.getProperty("String_Node_Str") + "String_Node_Str";
    STDocumentImpl documentImpl = (STDocumentImpl) document;
    document.evaluateCommandLineParameters(null);
    assertEquals(defaultDataDirectory, documentImpl.getDataDirectory());
    document.evaluateCommandLineParameters(new String[] { "String_Node_Str", "String_Node_Str" });
    assertEquals(defaultDataDirectory, documentImpl.getDataDirectory());
    document.evaluateCommandLineParameters(new String[] { "String_Node_Str", "String_Node_Str" });
    assertEquals("String_Node_Str", documentImpl.getDataDirectory());
}

Output:
     STDocumentImpl documentImpl = (STDocumentImpl) document;
-    document.evaluateCommandLineParameters(null);
+    document.evaluateCommandLineParameters(new ArrayList<>());
     assertEquals(defaultDataDirectory, documentImpl.getDataDirectory());


Input:
protected GraphTargetItem checkLoop(LoopItem loopItem, BaseLocalData localData, List<Loop> loops) {
    AVM2LocalData aLocalData = (AVM2LocalData) localData;
    if (loopItem instanceof WhileItem) {
        WhileItem w = (WhileItem) loopItem;
        if ((!w.expression.isEmpty()) && (w.expression.get(w.expression.size() - 1) instanceof HasNextAVM2Item)) {
            if (((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection != null) {
                if (((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection.getNotCoerced().getThroughRegister() instanceof FilteredCheckAVM2Item) {
                    if (w.commands.size() >= 3) {
                        int pos = 0;
                        while (w.commands.get(pos) instanceof SetLocalAVM2Item) {
                            pos++;
                        }
                        GraphTargetItem ft = w.commands.get(pos);
                        if (ft instanceof WithAVM2Item) {
                            ft = w.commands.get(pos + 1);
                            if (ft instanceof IfItem) {
                                IfItem ift = (IfItem) ft;
                                if (ift.onTrue.size() > 0) {
                                    ft = ift.onTrue.get(0);
                                    if (ft instanceof SetPropertyAVM2Item) {
                                        SetPropertyAVM2Item spt = (SetPropertyAVM2Item) ft;
                                        if (spt.object instanceof LocalRegAVM2Item) {
                                            int regIndex = ((LocalRegAVM2Item) spt.object).regIndex;
                                            HasNextAVM2Item iti = (HasNextAVM2Item) w.expression.get(w.expression.size() - 1);
                                            HashMap<Integer, GraphTargetItem> localRegs = aLocalData.localRegs;
                                            localRegs.put(regIndex, new FilterAVM2Item(null, iti.collection.getThroughRegister(), ift.expression));
                                            return null;
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else if (!w.commands.isEmpty()) {
                    if (w.commands.get(0) instanceof SetTypeAVM2Item) {
                        SetTypeAVM2Item sti = (SetTypeAVM2Item) w.commands.remove(0);
                        GraphTargetItem gti = sti.getValue().getNotCoerced();
                        if (gti instanceof NextValueAVM2Item) {
                            return new ForEachInAVM2Item(w.src, w.loop, new InAVM2Item(null, sti.getObject(), ((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection), w.commands);
                        } else if (gti instanceof NextNameAVM2Item) {
                            return new ForInAVM2Item(w.src, w.loop, new InAVM2Item(null, sti.getObject(), ((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection), w.commands);
                        }
                    }
                }
            }
        }
    }
    return loopItem;
}

Output:
                         if (gti instanceof NextValueAVM2Item) {
-                            return new ForEachInAVM2Item(w.src, w.loop, new InAVM2Item(null, sti.getObject(), ((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection), w.commands);
+                            return new ForEachInAVM2Item(w.src, w.loop, new InAVM2Item(hn.instruction, sti.getObject(), ((HasNextAVM2Item) w.expression.get(w.expression.size() - 1)).collection), w.commands);
                         } else if (gti instanceof NextNameAVM2Item) {


Input:
private Function getFunnctionByName(String talendType, String value) {
    Function func = null;
    for (Function fun : functionManager.getFunctionByName(talendType)) {
        String name = fun.getName();
        if (value.contains(name)) {
            if (name.equals(value)) {
                func = (Function) fun.clone();
                break;
            } else {
                if (value.contains(fun.getClassName())) {
                    func = (Function) fun.clone();
                    break;
                }
            }
        }
    }
    return func;
}

Output:
     Function func = null;
-    for (Function fun : functionManager.getFunctionByName(talendType)) {
+    for (Function fun : functionManager.getFunctionsByType(talendType)) {
         String name = fun.getName();


Input:
public int hashCode() {
    return Objects.hash(mTransmissions);
}

Output:
 public int hashCode() {
-    return Objects.hash(mTransmissions);
+    int hash = this.abstractHashCode();
+    hash = 67 * hash + Objects.hash(mTransmissions);
+    return hash;
 }


Input:
public List<Chanson> getTitres() {
    List<Chanson> data = new LinkedList<Chanson>();
    String allTitresQuery = "String_Node_Str";
    Cursor d = myDatabase.rawQuery(allTitresQuery, null);
    if (d.moveToFirst()) {
        while (d.moveToNext()) {
            Chanson c = new Chanson(d.getLong(0), d.getString(1));
            data.add(c);
        }
    }
    return data;
}

Output:
     Cursor d = myDatabase.rawQuery(allTitresQuery, null);
-    if (d.moveToFirst()) {
-        while (d.moveToNext()) {
-            Chanson c = new Chanson(d.getLong(0), d.getString(1));
-            data.add(c);
-        }
+    while (d.moveToNext()) {
+        Chanson c = new Chanson(d.getLong(0), d.getString(1));
+        data.add(c);
     }


Input:
public boolean equals(Object obj) {
    return obj instanceof ApplicationDefaultAuthCredentialsState;
}

Output:
 public boolean equals(Object obj) {
-    return obj instanceof ApplicationDefaultAuthCredentialsState;
+    return obj instanceof NoAuthCredentialsState;
 }


Input:
ContactGroupIcqImpl findGroup(Buddy buddy) {
    Iterator<ContactGroupIcqImpl> iter = rootGroup.subgroups();
    while (iter.hasNext()) {
        ContactGroupIcqImpl elem = iter.next();
        if (!elem.isPersistent() || !elem.isResolved())
            continue;
        Iterator bs = elem.getJoustSimSourceGroup().getBuddiesCopy().iterator();
        while (bs.hasNext()) {
            Buddy b = (Buddy) bs.next();
            if (b == buddy)
                return elem;
        }
    }
    return null;
}

Output:
 ContactGroupIcqImpl findGroup(Buddy buddy) {
-    Iterator<ContactGroupIcqImpl> iter = rootGroup.subgroups();
+    Iterator<ContactGroup> iter = rootGroup.subgroups();
     while (iter.hasNext()) {


Input:
public Response execute() {
    try {
        Thread.sleep(1000);
        if (this.getUsername().equals("String_Node_Str")) {
            return new ErrorResponse(HttpStatusCode.METHOD_NOT_YET_IMPLEMENTED, "String_Node_Str");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return new MinimalResponse(HttpStatusCode.OK);
}

Output:
         if (this.getUsername().equals("String_Node_Str")) {
-            return new ErrorResponse(HttpStatusCode.METHOD_NOT_YET_IMPLEMENTED, "String_Node_Str");
+            return new ErrorResponse(HttpStatusCode.NOT_IMPLEMENTED, "String_Node_Str");
         }


Input:
private static String consistentShuffle(String alphabet, String salt) {
    if (salt.length() <= 0)
        return alphabet;
    int asc_val, j;
    char tmp;
    for (int i = alphabet.length() - 1, v = 0, p = 0; i > 0; i--, v++) {
        v %= salt.length();
        asc_val = (int) salt.charAt(v);
        p += asc_val;
        j = (asc_val + v + p) % i;
        tmp = alphabet.charAt(j);
        alphabet = alphabet.substring(0, j) + alphabet.charAt(i) + alphabet.substring(j + 1);
        alphabet = alphabet.substring(0, i) + tmp + alphabet.substring(i + 1);
    }
    return alphabet;
}

Output:
     int asc_val, j;
-    char tmp;
-    for (int i = alphabet.length() - 1, v = 0, p = 0; i > 0; i--, v++) {
+    char[] tmp_arr = alphabet.toCharArray();
+    for (int i = tmp_arr.length - 1, v = 0, p = 0; i > 0; i--, v++) {
         v %= salt.length();


Input:
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    String[] sentences = ((String) msg).split("String_Node_Str");
    List<Position> positions = new ArrayList<>();
    Map<Integer, BitBuffer> buffers = new HashMap<>();
    for (String sentence : sentences) {
        if (!sentence.isEmpty()) {
            Parser parser = new Parser(PATTERN, sentence);
            if (parser.matches()) {
                int count = parser.nextInt();
                int index = parser.nextInt();
                int id = parser.nextInt();
                Position position = null;
                if (count == 1) {
                    BitBuffer bits = new BitBuffer();
                    bits.writeEncoded(parser.next().getBytes());
                    position = decodePayload(channel, remoteAddress, bits);
                } else {
                    BitBuffer bits = buffers.get(id);
                    if (bits == null) {
                        bits = new BitBuffer();
                        buffers.put(id, bits);
                    }
                    bits.writeEncoded(parser.next().getBytes());
                    if (count == index) {
                        position = decodePayload(channel, remoteAddress, bits);
                        buffers.remove(id);
                    }
                }
                if (position != null) {
                    positions.add(position);
                }
            }
        }
    }
    return positions;
}

Output:
                     BitBuffer bits = new BitBuffer();
-                    bits.writeEncoded(parser.next().getBytes());
+                    bits.writeEncoded(parser.next().getBytes(StandardCharsets.US_ASCII));
                     position = decodePayload(channel, remoteAddress, bits);


Input:
private void addParameter(Map map, String key, String value) {
    String temp = key.substring(ATTR_PARAMRTER.length());
    map.put(temp, value);
}

Output:
     String temp = key.substring(ATTR_PARAMRTER.length());
-    map.put(temp, value);
+    map.put(temp, getParameterObject(temp, value));
 }


Input:
public void startRequest(MRCRequest rq) {
    try {
        Args rqArgs = (Args) rq.getRequestArgs();
        final VolumeManager vMan = master.getVolumeManager();
        final FileAccessManager faMan = master.getFileAccessManager();
        Path p = new Path(rqArgs.path);
        VolumeInfo volume = vMan.getVolumeByName(p.getComp(0));
        StorageManager sMan = vMan.getStorageManager(volume.getId());
        PathResolver res = new PathResolver(sMan, p);
        faMan.checkSearchPermission(sMan, res, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        res.checkIfFileDoesNotExist();
        FileMetadata file = res.getFile();
        String target = sMan.getSoftlinkTarget(file.getId());
        if (target != null) {
            rqArgs.path = target;
            p = new Path(rqArgs.path);
            if (!vMan.hasVolume(p.getComp(0))) {
                finishRequest(rq, new ErrorRecord(ErrorClass.REDIRECT, target));
                return;
            }
            volume = vMan.getVolumeByName(p.getComp(0));
            sMan = vMan.getStorageManager(volume.getId());
            res = new PathResolver(sMan, p);
            file = res.getFile();
        }
        if (file.isDirectory())
            throw new UserException(ErrNo.EISDIR, "String_Node_Str");
        AccessMode mode = null;
        try {
            mode = AccessMode.valueOf(rqArgs.accessMode);
        } catch (IllegalArgumentException exc) {
            throw new UserException(ErrNo.EINVAL, "String_Node_Str" + rqArgs.accessMode);
        }
        if ((mode == AccessMode.w || mode == AccessMode.a || mode == AccessMode.ga || mode == AccessMode.t) && file.isReadOnly())
            throw new UserException(ErrNo.EPERM, "String_Node_Str");
        AtomicDBUpdate update = null;
        if (mode == AccessMode.t) {
            update = sMan.createAtomicDBUpdate(master, rq);
            file.setIssuedEpoch(file.getIssuedEpoch() + 1);
            sMan.setMetadata(file, FileMetadata.RC_METADATA, update);
        }
        faMan.checkPermission(rqArgs.accessMode, sMan, file, res.getParentDirId(), rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        String capability = MRCOpHelper.createCapability(rqArgs.accessMode, volume.getId(), file.getId(), file.getIssuedEpoch(), master.getConfig().getCapabilitySecret()).toString();
        XLocList xLocList = file.getXLocList();
        if (xLocList == null || !xLocList.iterator().hasNext()) {
            xLocList = MRCOpHelper.createXLocList(xLocList, sMan, master.getOSDStatusManager(), res.toString(), file.getId(), res.getParentDirId(), volume, rq.getPinkyRequest().getClientAddress());
            file.setXLocList(xLocList);
            if (update == null)
                update = sMan.createAtomicDBUpdate(master, rq);
            sMan.setMetadata(file, FileMetadata.XLOC_METADATA, update);
        }
        HTTPHeaders headers = MRCOpHelper.createXCapHeaders(capability, xLocList);
        rq.setAdditionalResponseHeaders(headers);
        rq.setData(ReusableBuffer.wrap(JSONParser.writeJSON(null).getBytes()));
        if (update == null)
            update = sMan.createAtomicDBUpdate(master, rq);
        if (!master.getConfig().isNoAtime())
            MRCOpHelper.updateFileTimes(res.getParentsParentId(), res.getParentDir(), true, false, false, sMan, update);
        if (update != null)
            update.execute();
        else
            finishRequest(rq);
    } catch (UserException exc) {
        Logging.logMessage(Logging.LEVEL_TRACE, this, exc);
        finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
    } catch (Exception exc) {
        finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));
    }
}

Output:
         if (xLocList == null || !xLocList.iterator().hasNext()) {
-            xLocList = MRCOpHelper.createXLocList(xLocList, sMan, master.getOSDStatusManager(), res.toString(), file.getId(), res.getParentDirId(), volume, rq.getPinkyRequest().getClientAddress());
+            StripingPolicy sp = sMan.getDefaultStripingPolicy(file.getId());
+            xLocList = MRCOpHelper.createXLocList(sp, xLocList, sMan, master.getOSDStatusManager(), res.toString(), file.getId(), res.getParentDirId(), volume, rq.getPinkyRequest().getClientAddress());
             file.setXLocList(xLocList);


Input:
public void addNote(Note note) {
    elem.add(note);
    notes.add(note);
    fireStructureChange(NEED_UPDATE_JOB, elem);
}

Output:
 public void addNote(Note note) {
-    elem.add(note);
-    notes.add(note);
-    fireStructureChange(NEED_UPDATE_JOB, elem);
+    addNote(note, true);
 }


Input:
public void update(UUID uuid, ChatComponent displayName) {
    PlayOutTabListItem.PlayOutTabListItemUpdateDisplayName.PlayerData data = new PlayOutTabListItem.PlayOutTabListItemUpdateDisplayName.PlayerData(uuid, displayName);
    this.updates.add(data);
}

Output:
 public void update(UUID uuid, ChatComponent displayName) {
-    PlayOutTabListItem.PlayOutTabListItemUpdateDisplayName.PlayerData data = new PlayOutTabListItem.PlayOutTabListItemUpdateDisplayName.PlayerData(uuid, displayName);
+    UpdateDisplayName.PlayerData data = new UpdateDisplayName.PlayerData(uuid, displayName);
     this.updates.add(data);


Input:
private Object readComplexProperty(final JsonReader reader, final EntityComplexPropertyInfo complexPropertyInfo, final Object typeMapping) throws EdmException, EntityProviderException, IOException {
    if (reader.peek().equals(JsonToken.NULL)) {
        reader.nextNull();
        return null;
    }
    reader.beginObject();
    Map<String, Object> data = new HashMap<String, Object>();
    Map<String, Object> mapping;
    if (typeMapping != null) {
        if (typeMapping instanceof Map) {
            mapping = (Map<String, Object>) typeMapping;
        } else {
            throw new EntityProviderException(EntityProviderException.INVALID_MAPPING.addContent(complexPropertyInfo.getName()));
        }
    } else {
        mapping = new HashMap<String, Object>();
    }
    while (reader.hasNext()) {
        String childName = reader.nextName();
        if (FormatJson.METADATA.equals(childName)) {
            reader.beginObject();
            childName = reader.nextName();
            if (!FormatJson.TYPE.equals(childName)) {
                throw new EntityProviderException(EntityProviderException.MISSING_ATTRIBUTE.addContent(FormatJson.TYPE).addContent(FormatJson.METADATA));
            }
            String actualTypeName = reader.nextString();
            String expectedTypeName = complexPropertyInfo.getType().getNamespace() + Edm.DELIMITER + complexPropertyInfo.getType().getName();
            if (!expectedTypeName.equals(actualTypeName)) {
                throw new EntityProviderException(EntityProviderException.INVALID_ENTITYTYPE.addContent(expectedTypeName).addContent(actualTypeName));
            }
            reader.endObject();
        } else {
            EntityPropertyInfo childPropertyInfo = complexPropertyInfo.getPropertyInfo(childName);
            if (childPropertyInfo == null) {
                throw new EntityProviderException(EntityProviderException.ILLEGAL_ARGUMENT.addContent(childName));
            }
            Object childData = readPropertyValue(reader, childPropertyInfo, mapping.get(childName));
            if (data.containsKey(childName)) {
                throw new EntityProviderException(EntityProviderException.DOUBLE_PROPERTY.addContent(childName));
            }
            data.put(childName, childData);
        }
    }
    reader.endObject();
    return data;
}

Output:
             if (childPropertyInfo == null) {
-                throw new EntityProviderException(EntityProviderException.ILLEGAL_ARGUMENT.addContent(childName));
+                throw new EntityProviderException(EntityProviderException.INVALID_PROPERTY.addContent(childName));
             }


Input:
public void importProjects() {
    ImportProjectAsAction.getInstance().run();
    fillUIProjectListWithBusyCursor();
    String newProject = ImportProjectAsAction.getInstance().getProjectName();
    if (newProject != null) {
        resetProjectOperationSelection();
        selectProject(newProject);
    } else if (ImportProjectAsAction.getInstance().isImportedSeveralProjects()) {
        resetProjectOperationSelection();
    }
    validateProject();
}

Output:
     if (newProject != null) {
-        resetProjectOperationSelection();
+        resetProjectOperationSelectionWithBusyCursor();
         selectProject(newProject);


Input:
private List convertParamterBindings(Iterator paramBindingIt) {
    if (paramBindingIt == null)
        return null;
    List parameterBindings = new ArrayList();
    while (paramBindingIt.hasNext()) {
        ParamBindingHandle paramBinding = (ParamBindingHandle) paramBindingIt.next();
        if (paramBinding.getExpression() != null) {
            ScriptExpression paramValueExpr = new ScriptExpression(paramBinding.getExpression());
            InputParameterBinding inputParamBinding = new InputParameterBinding(paramBinding.getParamName(), paramValueExpr);
            parameterBindings.add(inputParamBinding);
        }
    }
    return parameterBindings;
}

Output:
     while (paramBindingIt.hasNext()) {
-        ParamBindingHandle paramBinding = (ParamBindingHandle) paramBindingIt.next();
-        if (paramBinding.getExpression() != null) {
-            ScriptExpression paramValueExpr = new ScriptExpression(paramBinding.getExpression());
-            InputParameterBinding inputParamBinding = new InputParameterBinding(paramBinding.getParamName(), paramValueExpr);
-            parameterBindings.add(inputParamBinding);
+        Object paramObj = paramBindingIt.next();
+        if (paramObj instanceof ParamBindingHandle) {
+            ParamBindingHandle paramBinding = (ParamBindingHandle) paramObj;
+            if (paramBinding.getExpression() != null) {
+                ScriptExpression paramValueExpr = new ScriptExpression(paramBinding.getExpression());
+                InputParameterBinding inputParamBinding = new InputParameterBinding(paramBinding.getParamName(), paramValueExpr);
+                parameterBindings.add(inputParamBinding);
+            }
+        } else if (paramObj instanceof OdaDataSetParameterHandle) {
+            OdaDataSetParameterHandle paramBinding = (OdaDataSetParameterHandle) paramObj;
+            if (paramBinding.getDefaultValue() != null) {
+                ScriptExpression paramValueExpr = new ScriptExpression(paramBinding.getDefaultValue());
+                InputParameterBinding inputParamBinding = new InputParameterBinding(paramBinding.getName(), paramValueExpr);
+                parameterBindings.add(inputParamBinding);
+            }
         }


Input:
public JSType removeType(JSType other) {
    if ((isTop() || isUnknown()) && other.equals(NULL)) {
        return TOP_MINUS_NULL;
    }
    if ((isTop() || isUnknown()) && other.equals(UNDEFINED)) {
        return TOP_MINUS_UNDEF;
    }
    if (other.equals(NULL) || other.equals(UNDEFINED)) {
        return new JSType(mask & ~other.mask, location, objs, typeVar, enums);
    }
    if (objs == null) {
        return this;
    }
    Preconditions.checkState((other.mask & ~NON_SCALAR_MASK) == 0 && other.objs.size() == 1);
    NominalType otherKlass = Iterables.getOnlyElement(other.objs).getNominalType();
    ImmutableSet.Builder<ObjectType> newObjs = ImmutableSet.builder();
    for (ObjectType obj : objs) {
        if (!Objects.equal(obj.getNominalType(), otherKlass)) {
            newObjs.add(obj);
        }
    }
    return new JSType(mask, location, newObjs.build(), typeVar, enums);
}

Output:
 public JSType removeType(JSType other) {
-    if ((isTop() || isUnknown()) && other.equals(NULL)) {
-        return TOP_MINUS_NULL;
+    if (isUnknown()) {
+        return this;
     }


Input:
protected TextFragment execute(Text text, int startIndex, int endIndex, String parameter) {
    boolean addStyle = isExecuted();
    return addStyle ? removeStyle(text, startIndex, endIndex) : addStyle(text, startIndex, endIndex);
}

Output:
     boolean addStyle = isExecuted();
-    return addStyle ? removeStyle(text, startIndex, endIndex) : addStyle(text, startIndex, endIndex);
+    if (DomStyle.this.isRemote()) {
+        return addStyle ? new TextFragment(text, startIndex, endIndex) : addStyle(text, startIndex, endIndex);
+    } else {
+        return addStyle ? removeStyle(text, startIndex, endIndex) : addStyle(text, startIndex, endIndex);
+    }
 }


Input:
public boolean accept(Node node) {
    if (node.getText().startsWith("String_Node_Str") && node.getText().contains("String_Node_Str")) {
        return true;
    } else {
        return false;
    }
}

Output:
 public boolean accept(Node node) {
-    if (node.getText().startsWith("String_Node_Str") && node.getText().contains("String_Node_Str")) {
-        return true;
-    } else {
-        return false;
-    }
+    return node.getText().startsWith("String_Node_Str") && node.getText().contains("String_Node_Str");
 }


Input:
private void postInit(ModuleHandle handle, Map properties) {
    if (properties != null && !properties.isEmpty()) {
        String createInfo = model.getCreatedBy();
        if (createInfo == null || createInfo.length() == 0) {
            try {
                handle.initializeModule(properties);
            } catch (SemanticException e) {
            }
        }
    }
    SimpleMasterPageHandle masterPage = null;
    if (handle.getMasterPages().getCount() == 0) {
        masterPage = handle.getElementFactory().newSimpleMasterPage(null);
        try {
            handle.getMasterPages().add(masterPage);
        } catch (ContentException e) {
            new DesignFileException(handle.getFileName(), e);
        } catch (NameException e) {
            new DesignFileException(handle.getFileName(), e);
        }
    }
}

Output:
     if (properties != null && !properties.isEmpty()) {
-        String createInfo = model.getCreatedBy();
+        String createInfo = handle.getCreatedBy();
         if (createInfo == null || createInfo.length() == 0) {


Input:
public long getStart() {
    return parent != null ? parent.getStart() : centerTime - (long) ((masterDuration.getEnd() - masterDuration.getStart()) / getZoom()) / 2;
}

Output:
 public long getStart() {
-    return parent != null ? parent.getStart() : centerTime - (long) ((masterDuration.getEnd() - masterDuration.getStart()) / getZoom()) / 2;
+    return parent != null ? parent.getStart() : centerTime - (long) (((double) (masterDuration.getEnd() - masterDuration.getStart()) / getZoom()) / 2.0);
 }


Input:
public Address getOurSipAddress(SipURI intendedDestination) {
    SipRegistrarConnection src = getRegistrarConnection();
    if (src != null && !src.isRegistrarless())
        return src.getAddressOfRecord();
    InetAddress destinationAddr = getIntendedDestination(intendedDestination);
    InetAddress localHost = SipActivator.getNetworkAddressManagerService().getLocalHost(destinationAddr);
    String userID = getAccountID().getUserID();
    try {
        SipURI ourSipURI = getAddressFactory().createSipURI(userID, localHost.getHostAddress());
        ListeningPoint lp = getListeningPoint(intendedDestination);
        ourSipURI.setTransportParam(lp.getTransport());
        ourSipURI.setPort(lp.getPort());
        Address ourSipAddress = getAddressFactory().createAddress(getOurDisplayName(), ourSipURI);
        ourSipAddress.setDisplayName(getOurDisplayName());
        return ourSipAddress;
    } catch (ParseException exc) {
        if (logger.isTraceEnabled())
            logger.trace("String_Node_Str", exc);
        throw new IllegalArgumentException("String_Node_Str", exc);
    }
}

Output:
         return src.getAddressOfRecord();
-    InetAddress destinationAddr = getIntendedDestination(intendedDestination);
-    InetAddress localHost = SipActivator.getNetworkAddressManagerService().getLocalHost(destinationAddr);
+    InetSocketAddress destinationAddr = getIntendedDestination(intendedDestination);
+    InetAddress localHost = SipActivator.getNetworkAddressManagerService().getLocalHost(destinationAddr.getAddress());
     String userID = getAccountID().getUserID();


Input:
public int compare(IRow o1, IRow o2) {
    applyPrimitive(o1);
    applyPrimitive(o2);
    CacheRow r1 = getCacheRow(o1);
    CacheRow r2 = getCacheRow(o2);
    if (codeOrder.equalsIgnoreCase(DEFAULT_ORDER_CODE)) {
        return -Float.compare(r1.value, r2.value);
    } else
        return runOrderScript(r1, r2);
}

Output:
     if (codeOrder.equalsIgnoreCase(DEFAULT_ORDER_CODE)) {
-        return -Float.compare(r1.value, r2.value);
+        return Float.compare(r2.value, r1.value);
     } else


Input:
public <T> T put(String key, Entry entry) {
    validate(key, entry);
    T value = entry.getValue();
    Entry oldEntry = map.put(key, entry);
    if (oldEntry != null && (oldEntry.getValue() instanceof ContextLifecycle)) {
        ((ContextLifecycle) oldEntry.value).contextChanged(value);
    }
    if (entry.getValue() instanceof ContextLifecycle) {
        ContextLifecycle ctx = (ContextLifecycle) entry.getValue();
        if (addedContexts == null) {
            ctx.contextAdded();
        } else {
            addedContexts.add(ctx);
        }
    }
    if (logger.isLoggable(Level.DEBUG)) {
        logger.log(Level.DEBUG, MessageID.PUT, key, value, oldEntry == null ? null : oldEntry.value);
    }
    return (T) (oldEntry == null ? null : oldEntry.value);
}

Output:
     validate(key, entry);
-    T value = entry.getValue();
+    T value = (T) entry.getValue();
     Entry oldEntry = map.put(key, entry);


Input:
public final void compute(Bounds bo) throws ChartException, IllegalArgumentException {
    bo = bo.scaledInstance(dPointToPixel);
    dSeriesThickness = (ids.getDpiResolution() / 72d) * cwa.getSeriesThickness();
    dSeriesThickness = cwa.getPlot().getClientArea().isVisible() ? dSeriesThickness : 0;
    double dX = bo.getLeft() + insCA.getLeft();
    double dY = bo.getTop() + insCA.getTop();
    double dW = bo.getWidth() - insCA.getLeft() - insCA.getRight();
    double dH = bo.getHeight() - insCA.getTop() - insCA.getBottom();
    iDimension = getDimension(cwa.getDimension());
    dXAxisPlotSpacing = cwa.getPlot().getHorizontalSpacing() * dPointToPixel;
    dYAxisPlotSpacing = cwa.getPlot().getVerticalSpacing() * dPointToPixel;
    if (iDimension == TWO_5_D) {
        dY += dSeriesThickness;
        dH -= dSeriesThickness;
        dW -= dSeriesThickness;
        bo.setHeight(dH);
        bo.setTop(dY);
        bo.setWidth(dW);
    }
    if (aax.getOverlayCount() > 0) {
        if (aax.areAxesSwapped()) {
            updateOverlayScales(aax, dX, dX + dW, dY, dH);
            dY = aax.getStart();
            dH = aax.getLength();
        } else {
            updateOverlayScales(aax, dY - dH, dY, dX, dW);
            dX = aax.getStart();
            dW = aax.getLength();
        }
    }
    double dStart, dEnd;
    final Axis[] axa = cwa.getPrimaryBaseAxes();
    final Axis axPrimaryBase = axa[0];
    final Axis axPrimaryOrthogonal = cwa.getPrimaryOrthogonalAxis(axPrimaryBase);
    Scale sc = axPrimaryBase.getScale();
    AutoScale scPrimaryBase = null;
    OneAxis oaxPrimaryBase = aax.getPrimaryBase();
    int iAxisType = getAxisType(axPrimaryBase);
    Object oaData = null;
    if (iAxisType == TEXT || oaxPrimaryBase.isCategoryScale()) {
        oaData = getTypedDataSet(axPrimaryBase, iAxisType, 0);
    } else if ((iAxisType & NUMERICAL) == NUMERICAL) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    } else if ((iAxisType & DATE_TIME) == DATE_TIME) {
        oaData = getMinMax(axPrimaryBase, iAxisType);
    }
    DataSetIterator dsi = (oaData instanceof DataSetIterator) ? (DataSetIterator) oaData : new DataSetIterator(oaData, iAxisType);
    oaData = null;
    dStart = (aax.areAxesSwapped()) ? dY + dH : dX;
    dEnd = (aax.areAxesSwapped()) ? dY : dStart + dW;
    int iDirection = AUTO;
    scPrimaryBase = AutoScale.computeScale(ids, oaxPrimaryBase, dsi, iAxisType, dStart, dEnd, sc, axPrimaryBase.getFormatSpecifier(), rtc, iDirection, 1, iMarginPercent);
    oaxPrimaryBase.set(scPrimaryBase);
    AutoScale scPrimaryOrthogonal = null;
    OneAxis oaxPrimaryOrthogonal = aax.getPrimaryOrthogonal();
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = null;
    if ((iAxisType & NUMERICAL) == NUMERICAL || (iAxisType & DATE_TIME) == DATE_TIME) {
        dsi = new DataSetIterator(getMinMax(axPrimaryOrthogonal, iAxisType), iAxisType);
        dsi.reverse(cwa.isReverseCategory());
    } else {
        throw new ChartException(ChartEnginePlugin.ID, ChartException.DATA_FORMAT, "String_Node_Str", Messages.getResourceBundle(rtc.getULocale()));
    }
    dStart = (aax.areAxesSwapped()) ? dX : dY + dH;
    dEnd = (aax.areAxesSwapped()) ? dX + dW : dY;
    sc = axPrimaryOrthogonal.getScale();
    scPrimaryOrthogonal = AutoScale.computeScale(ids, oaxPrimaryOrthogonal, dsi, iAxisType, dStart, dEnd, sc, oaxPrimaryBase.getModelAxis().getOrigin(), axPrimaryOrthogonal.getFormatSpecifier(), rtc, AUTO, 1, iMarginPercent);
    oaxPrimaryOrthogonal.set(scPrimaryOrthogonal);
    double dYAxisLocation = adjustHorizontal(dX, dW, aax);
    double dXAxisLocation = adjustVerticalDueToHorizontal(dY, dH, aax);
    iAxisType = getAxisType(axPrimaryOrthogonal);
    oaData = getTypedDataSet(axPrimaryOrthogonal, iAxisType, 0);
    scPrimaryOrthogonal.setData(dsi);
    iAxisType = getAxisType(axPrimaryBase);
    if (iAxisType != IConstants.TEXT) {
        scPrimaryBase.setData(getTypedDataSet(axPrimaryBase, iAxisType, 0));
    }
    scPrimaryBase.resetShifts();
    scPrimaryOrthogonal.resetShifts();
    updateOverlayAxes(aax);
    growBaseAxis(aax, BoundsImpl.create(dX, dY, dW, dH));
    final OneAxis axPH = aax.areAxesSwapped() ? aax.getPrimaryOrthogonal() : aax.getPrimaryBase();
    final OneAxis axPV = aax.areAxesSwapped() ? aax.getPrimaryBase() : aax.getPrimaryOrthogonal();
    axPH.setAxisCoordinate(dXAxisLocation);
    axPV.setAxisCoordinate(dYAxisLocation);
    double[] daX = axPH.getScale().getEndPoints();
    double[] daY = axPV.getScale().getEndPoints();
    if (axPH.getScale().getDirection() == BACKWARD) {
        boPlotBackground.setLeft(daX[1] - insCA.getLeft());
        boPlotBackground.setWidth(daX[0] - daX[1] + insCA.getLeft() + insCA.getRight() + 1);
    } else {
        boPlotBackground.setLeft(daX[0] - insCA.getLeft());
        boPlotBackground.setWidth(daX[1] - daX[0] + insCA.getLeft() + insCA.getRight() + 1);
    }
    if (axPV.getScale().getDirection() == FORWARD) {
        boPlotBackground.setTop(daY[0] - insCA.getTop());
        boPlotBackground.setHeight(daY[1] - daY[0] + insCA.getTop() + insCA.getBottom() + 1);
    } else {
        boPlotBackground.setTop(daY[1] - insCA.getTop());
        boPlotBackground.setHeight(daY[0] - daY[1] + insCA.getTop() + insCA.getBottom() + 1);
    }
    if (iDimension == TWO_5_D) {
        boPlotBackground.delta(dSeriesThickness, -dSeriesThickness, 0, 0);
    }
    boPlotWithMargin = BoundsImpl.copyInstance(boPlotBackground);
    if (iMarginPercent > 0) {
        AutoScale scale = axPH.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMinWithMargin() != null) {
                    boPlotWithMargin.setLeft(boPlotWithMargin.getLeft() - factor * (asDouble(scale.getMinimum()).doubleValue() - asDouble(scale.getMinWithMargin()).doubleValue()));
                }
                boPlotWithMargin.setWidth(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getLeft() + insCA.getRight() + 1);
            }
        }
        scale = axPV.getScale();
        if (scale.getMaxWithMargin() != null || scale.getMinWithMargin() != null) {
            if ((scale.getType() & LINEAR) == LINEAR) {
                double factor = Math.abs(daX[1] - daX[0]) / (asDouble(scale.getMaximum()).doubleValue() - asDouble(scale.getMinimum()).doubleValue());
                if (scale.getMaxWithMargin() != null) {
                    boPlotWithMargin.setTop(boPlotWithMargin.getTop() - factor * (asDouble(scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMaximum()).doubleValue()));
                }
                boPlotWithMargin.setHeight(factor * (asDouble(scale.getMaxWithMargin() == null ? scale.getMaximum() : scale.getMaxWithMargin()).doubleValue() - asDouble(scale.getMinWithMargin() == null ? scale.getMinimum() : scale.getMinWithMargin()).doubleValue()) + insCA.getTop() + insCA.getBottom() + 1);
            }
        }
    }
}

Output:
     if ((iAxisType & NUMERICAL) == NUMERICAL || (iAxisType & DATE_TIME) == DATE_TIME) {
-        dsi = new DataSetIterator(getMinMax(axPrimaryOrthogonal, iAxisType), iAxisType);
+        if (rtc.getScale() != null && rtc.getState(AutoScale.KEY_SHARED_MINMAX) != null) {
+            dsi = new DataSetIterator(rtc.getState(AutoScale.KEY_SHARED_MINMAX), iAxisType);
+        } else {
+            dsi = new DataSetIterator(getMinMax(axPrimaryOrthogonal, iAxisType), iAxisType);
+        }
         dsi.reverse(cwa.isReverseCategory());


Input:
private void deleteBuyProLinks(boolean lastStartPro) {
    if (OSUtils.isWindows() && (!lastStartPro || applicationServices.isNewInstall())) {
        File pathToLimeWireStartMenuLink = new File(System.getProperty("String_Node_Str") + PATH_TO_BUY_PRO_LINK);
        if (pathToLimeWireStartMenuLink.exists()) {
            pathToLimeWireStartMenuLink.delete();
        }
        File pathToLimeWireAllUsersStartMenuLink = new File(System.getProperty("String_Node_Str") + "String_Node_Str" + PATH_TO_BUY_PRO_LINK);
        if (pathToLimeWireAllUsersStartMenuLink.exists()) {
            pathToLimeWireAllUsersStartMenuLink.delete();
        }
    }
}

Output:
 private void deleteBuyProLinks(boolean lastStartPro) {
-    if (OSUtils.isWindows() && (!lastStartPro || applicationServices.isNewInstall())) {
+    if (OSUtils.isWindows() && (!lastStartPro || activationSettings.isNewInstall())) {
         File pathToLimeWireStartMenuLink = new File(System.getProperty("String_Node_Str") + PATH_TO_BUY_PRO_LINK);


Input:
private void createObjects(TreeItem topItem, String objectType) {
    for (Iterator itor = DEUtil.getMetaDataDictionary().getClasses().iterator(); itor.hasNext(); ) {
        IClassInfo classInfo = (IClassInfo) itor.next();
        if (classInfo.isNative() && OBJECTS_TYPE_BIRT.equals(objectType) || !classInfo.isNative() && OBJECTS_TYPE_NATIVE.equals(objectType)) {
            continue;
        }
        TreeItem subItem = createSubFolderItem(topItem, classInfo);
        Image globalImage = null;
        if (isGlobal(classInfo.getName())) {
            globalImage = IMAGE_GOLBAL;
        }
        for (Iterator iterator = classInfo.getMembers().iterator(); iterator.hasNext(); ) {
            IMemberInfo memberInfo = (IMemberInfo) iterator.next();
            Image image = globalImage;
            if (image == null) {
                if (memberInfo.isStatic()) {
                    image = IMAGE_STATIC_MEMBER;
                } else {
                    image = IMAGE_MEMBER;
                }
            }
            createSubTreeItem(subItem, memberInfo.getDisplayName(), image, getMemberTextData(classInfo.getName(), memberInfo), memberInfo.getToolTip(), true);
        }
        List methodList = new ArrayList();
        methodList.add(classInfo.getConstructor());
        methodList.addAll(classInfo.getMethods());
        for (Iterator iterator = methodList.iterator(); iterator.hasNext(); ) {
            IMethodInfo methodInfo = (IMethodInfo) iterator.next();
            if (methodInfo == null) {
                continue;
            }
            Image image = globalImage;
            if (image == null) {
                if (methodInfo.isStatic()) {
                    image = IMAGE_STATIC_METHOD;
                } else {
                    image = IMAGE_METHOD;
                }
            }
            List displayList = getMethodArgumentsList(classInfo.getName(), methodInfo);
            for (int i = 0; i < displayList.size(); i++) {
                String[] array = (String[]) displayList.get(i);
                createSubTreeItem(subItem, array[0], image, array[1], methodInfo.getToolTip(), true);
            }
        }
    }
}

Output:
 private void createObjects(TreeItem topItem, String objectType) {
-    for (Iterator itor = DEUtil.getMetaDataDictionary().getClasses().iterator(); itor.hasNext(); ) {
+    for (Iterator itor = DEUtil.getClasses().iterator(); itor.hasNext(); ) {
         IClassInfo classInfo = (IClassInfo) itor.next();


Input:
public <E> List<E> executeQuery(Class<E> entityClass, OracleNoSQLQueryInterpreter interpreter) {
    List<E> results = new ArrayList<E>();
    Set<Object> primaryKeys = null;
    if (!interpreter.getClauseQueue().isEmpty()) {
        primaryKeys = ((OracleNoSQLInvertedIndexer) getIndexManager().getIndexer()).executeQuery(interpreter, entityClass);
    } else {
        EntityMetadata m = KunderaMetadataManager.getEntityMetadata(entityClass);
        ArrayList<String> majorComponents = new ArrayList<String>();
        majorComponents.add(m.getTableName());
        Key key = Key.createKey(majorComponents);
        Iterator<KeyValueVersion> iterator = kvStore.storeIterator(Direction.UNORDERED, 0, key, null, null);
        Set<Object> keySet = new HashSet<Object>();
        while (iterator.hasNext()) {
            KeyValueVersion keyValueVersion = iterator.next();
            String majorKeySecondPart = keyValueVersion.getKey().getMajorPath().get(1);
            keySet.add(majorKeySecondPart);
        }
        primaryKeys = keySet;
    }
    results = findAll(entityClass, interpreter.getSelectColumns(), primaryKeys.toArray());
    return results;
}

Output:
     List<E> results = new ArrayList<E>();
-    Set<Object> primaryKeys = null;
+    if (primaryKeys == null) {
+        primaryKeys = new HashSet<Object>();
+    }
     if (!interpreter.getClauseQueue().isEmpty()) {


Input:
public void setCallback(final Checkbox menuItem) {
    if (swingCallback != null) {
        _native.removeActionListener(swingCallback);
    }
    if (menuItem.getCallback() != null) {
        swingCallback = new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                ActionListener cb = menuItem.getCallback();
                if (cb != null) {
                    try {
                        cb.actionPerformed(new ActionEvent(menuItem, ActionEvent.ACTION_PERFORMED, "String_Node_Str"));
                    } catch (Throwable throwable) {
                        SystemTray.logger.error("String_Node_Str", menuItem.getText(), throwable);
                    }
                }
            }
        };
        _native.addActionListener(swingCallback);
    } else {
        swingCallback = null;
    }
}

Output:
     }
-    if (menuItem.getCallback() != null) {
-        swingCallback = new ActionListener() {
+    callback = menuItem.getCallback();
+    if (callback != null) {
+        callback = new ActionListener() {


Input:
protected void pageChange(int newPageIndex) {
    AFormPage page = (AFormPage) formPages.get(0);
    boolean isdirty = page.isDirty();
    super.pageChange(newPageIndex);
    if (xmlEditor != null) {
        xmlEditor.refresh();
        if (xmlEditor.isDirty() || xmlEditor.isModified())
            page.refreshPage();
    }
    linkDirty(page, isdirty);
}

Output:
         xmlEditor.refresh();
-        if (xmlEditor.isDirty() || xmlEditor.isModified())
+        if (xmlEditor.isDirty() || xmlEditor.isModified()) {
             page.refreshPage();


Input:
public void visitMethodInsn(int opcode, String owner, String name, String desc) {
    if (include) {
        adaptee.visitMethodInsn(opcode, owner, name, desc);
    }
}

Output:
     if (include) {
-        adaptee.visitMethodInsn(opcode, owner, name, desc);
+        getAdaptee().visitMethodInsn(opcode, owner, name, desc);
     }


Input:
private boolean addNetwork(CallbackContext callbackContext, JSONArray data) {
    WifiConfiguration wifi = new WifiConfiguration();
    String authType = data.getString(2);
    if (authType.equals("String_Node_Str")) {
    } else if (authType.equals("String_Node_Str")) {
        callbackContext.error("String_Node_Str");
        return false;
    } else {
        log.d(TAG, "String_Node_Str");
        callbackContext.error("String_Node_Str" + authType);
        return false;
    }
    wifi.SSID = data.getString(0);
    wifi.preSharedKey = data.getString(1);
    wifi.status = WifiConfiguration.Status.ENABLED;
    wifi.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    wifi.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    wifi.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    wifi.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
    wifi.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    wifi.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
    wifiManager.addNetwork();
    wifiManager.saveConfiguration();
    return true;
}

Output:
     wifi.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
-    wifiManager.addNetwork();
+    wifiManager.addNetwork(wifi);
     wifiManager.saveConfiguration();


Input:
public boolean isOwningNode(XPathFragment xPathFragment) {
    return (xPathFragment.getNextFragment() == null) || xPathFragment.getNextFragment().isAttribute();
}

Output:
 public boolean isOwningNode(XPathFragment xPathFragment) {
-    return (xPathFragment.getNextFragment() == null) || xPathFragment.getNextFragment().isAttribute();
+    return (xPathFragment.getNextFragment() == null) || xPathFragment.isAttribute();
 }


Input:
private static Map<String, Object> fetchRow(String table, String query, String[] families, String remoteHost) throws IOException, BlurException, TException {
    try {
        Iface client = Config.getClient(remoteHost);
        Selector selector = new Selector();
        String rowid = StringUtils.remove(query, "String_Node_Str");
        selector.setRowId(rowid);
        selector.setColumnFamiliesToFetch(new HashSet<String>(Arrays.asList(families)));
        FetchResult fetchRow = client.fetchRow(table, selector);
        Map<String, Object> results = new HashMap<String, Object>();
        results.put(TOTAL_KEY, fetchRow.getRowResult().getRow() == null ? 0 : 1);
        Map<String, List> rows = new HashMap<String, List>();
        Row row = fetchRow.getRowResult().getRow();
        if (row != null) {
            for (Record record : row.getRecords()) {
                String family = record.getFamily();
                List<ResultRow> fam = (List<ResultRow>) getFam(family, rows, false);
                ResultRow rowData = getRow(row.getId(), fam);
                rowData.getRecords().add(buildRow(record.getColumns(), record.getRecordId()));
            }
        }
        results.put(DATA_KEY, rows);
        results.put(FAMILY_KEY, new HashSet<String>(Arrays.asList(families)));
        return results;
    } finally {
        UserContext.reset();
    }
}

Output:
         Row row = fetchRow.getRowResult().getRow();
-        if (row != null) {
+        if (row != null && row.getRecords() != null) {
             for (Record record : row.getRecords()) {


Input:
public int run(List<XValue> args) throws Exception {
    Options opts = new Options("String_Node_Str", SerializeOpts.getOptionDefs());
    opts.parse(args);
    XValue optIn = opts.getOptValue("String_Node_Str");
    XValue optInXml = opts.getOptValue("String_Node_Str");
    boolean bOutText = opts.hasOpt("String_Node_Str");
    if (optIn != null && optInXml != null) {
        usage("String_Node_Str");
        return -1;
    }
    String comment = opts.getOptString("String_Node_Str", null);
    Properties props = new Properties();
    SerializeOpts serializeOpts = getSerializeOpts(opts);
    if (optInXml != null)
        props.loadFromXML(getInput(optInXml).asInputStream(serializeOpts));
    else if (optIn != null)
        props.load(getInput(optIn).asInputStream(serializeOpts));
    if (opts.hasOpt("String_Node_Str"))
        for (XValue d : opts.getOpt("String_Node_Str").getValues()) props.remove(d.toString());
    List<String> printVars = null;
    if (opts.hasOpt("String_Node_Str")) {
        printVars = new ArrayList<String>();
        for (XValue var : opts.getOpt("String_Node_Str").getValues()) printVars.add(var.toString());
    }
    if (opts.hasOpt("String_Node_Str")) {
        for (XValue add : opts.getOpt("String_Node_Str").getValues()) {
            StringPair pair = new StringPair(add.toString(), '=');
            props.setProperty(pair.getLeft(), pair.getRight());
        }
    }
    if (printVars != null)
        writeVars(props, printVars);
    else if (!bOutText)
        writeXML(props, comment);
    else
        writeText(props, comment);
    return 0;
}

Output:
     if (printVars != null)
-        writeVars(props, printVars);
+        writeVars(props, printVars, serializeOpts);
     else if (!bOutText)


Input:
public void testXmlJavaTypeAdapterOnClass() {
    Class[] classesToProcess = new Class[] { org.eclipse.persistence.testing.jaxb.externalizedmetadata.xmladapter.classlevel.MyClass.class };
    MySchemaOutputResolver outputResolver = new MySchemaOutputResolver();
    JAXBContext jaxbContext = null;
    try {
        jaxbContext = (JAXBContext) JAXBContextFactory.createContext(classesToProcess, null);
        jaxbContext.generateSchema(outputResolver);
    } catch (JAXBException e) {
        e.printStackTrace();
        fail("String_Node_Str");
    }
    String controlSchema = PATH + "String_Node_Str";
    compareSchemas(outputResolver.schemaFiles.get(EMPTY_NAMESPACE), new File(controlSchema));
    String src = PATH + "String_Node_Str";
    String result = validateAgainstSchema(src, EMPTY_NAMESPACE, outputResolver);
    assertTrue("String_Node_Str" + result, result == null);
    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
    Marshaller marshaller = jaxbContext.createMarshaller();
    Object obj;
    try {
        obj = unmarshaller.unmarshal(new StreamSource(new File(src)));
        assertTrue("String_Node_Str", obj.equals(getControlObjectClass()));
        src = tmpdir + "String_Node_Str";
        File outputFile = new File(src);
        marshaller.marshal(obj, outputFile);
        result = validateAgainstSchema(src, EMPTY_NAMESPACE, outputResolver);
        assertTrue("String_Node_Str" + result, result == null);
    } catch (JAXBException e) {
        e.printStackTrace();
        fail("String_Node_Str");
    }
}

Output:
     try {
-        jaxbContext = (JAXBContext) JAXBContextFactory.createContext(classesToProcess, null);
+        jaxbContext = (JAXBContext) JAXBContextFactory.createContext(classesToProcess, properties);
         jaxbContext.generateSchema(outputResolver);


Input:
public static Object buildObjectShell(PersistenceContext context, String entityType, Object id) {
    ClassDescriptor descriptor = context.getDescriptor(entityType);
    List<DatabaseMapping> pkMappings = descriptor.getObjectBuilder().getPrimaryKeyMappings();
    Object entity = null;
    if (descriptor.hasCMPPolicy()) {
        CMP3Policy policy = (CMP3Policy) descriptor.getCMPPolicy();
        entity = policy.createBeanUsingKey(id, context.getJpaSession());
    } else if (entity instanceof DynamicEntity) {
        DynamicEntityImpl dynamicEntity = (DynamicEntityImpl) context.newEntity(entityType);
        if (pkMappings.size() == 1) {
            dynamicEntity.set(pkMappings.get(0).getAttributeName(), id);
        } else {
            List<SortableKey> pkIndices = new ArrayList<SortableKey>();
            int index = 0;
            for (DatabaseMapping mapping : pkMappings) {
                pkIndices.add(new SortableKey(mapping, index));
                index++;
            }
            Collections.sort(pkIndices);
            Object[] keyElements = (Object[]) id;
            for (SortableKey key : pkIndices) {
                dynamicEntity.set(key.getMapping().getAttributeName(), keyElements[key.getIndex()]);
            }
        }
        entity = dynamicEntity;
    } else {
        throw new RuntimeException("String_Node_Str");
    }
    if (entity instanceof PersistenceEntity) {
        ((PersistenceEntity) entity)._persistence_setId(id);
    }
    if (entity instanceof FetchGroupTracker) {
        ((FetchGroupTracker) entity)._persistence_setSession(JpaHelper.getDatabaseSession(context.getEmf()));
    }
    return entity;
}

Output:
         CMP3Policy policy = (CMP3Policy) descriptor.getCMPPolicy();
-        entity = policy.createBeanUsingKey(id, context.getJpaSession());
+        entity = policy.createBeanUsingKey(id, (AbstractSession) context.getJpaSession());
     } else if (entity instanceof DynamicEntity) {


Input:
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    String clientID = NettyUtils.clientID(ctx.channel());
    if (clientID != null && !clientID.isEmpty()) {
        LOG.info("String_Node_Str", clientID);
        m_processor.processConnectionLost(clientID, ctx.channel());
    }
    ctx.close();
}

Output:
     }
-    ctx.close();
+    ctx.close().addListener(CLOSE_ON_FAILURE);
 }


Input:
public void after(StrestController controller) throws StrestException {
    if (controller.isStrest()) {
        return;
    }
    String sessionId = (String) controller.getConnectionStorage().get(SESSION);
    if (sessionId == null && !controller.getSessionStorage().isEmpty()) {
        CookieEncoder cookieEncoder = new CookieEncoder(true);
        sessionId = UUID.randomUUID().toString();
        Cookie cookie = new DefaultCookie(SESSION, sessionId);
        cookie.setMaxAge(this.maxAge);
        cookieEncoder.addCookie(cookie);
        controller.getResponse().setHeader(HttpHeaders.Names.COOKIE, cookieEncoder.encode());
        controller.getSessionStorage().put("String_Node_Str", IsoDateUtil.getIsoDate(new Date(new Date().getTime() + (1000 * this.maxAge))));
    }
    if (sessionId != null) {
        this.getSessionPersistence(controller).saveSession(sessionId, controller.getSessionStorage());
    }
}

Output:
         cookieEncoder.addCookie(cookie);
-        controller.getResponse().setHeader(HttpHeaders.Names.COOKIE, cookieEncoder.encode());
-        controller.getSessionStorage().put("String_Node_Str", IsoDateUtil.getIsoDate(new Date(new Date().getTime() + (1000 * this.maxAge))));
+        controller.getResponse().setHeader(HttpHeaders.Names.SET_COOKIE, cookieEncoder.encode());
     }


Input:
private void generateDoc(ClassModel model, PrintWriter writer) {
    ClassTypeInfo type = model.getType();
    Doc doc = model.getDoc();
    if (doc != null) {
        writer.println("String_Node_Str");
        Token.toHtml(doc.getTokens(), "String_Node_Str", this.renderLinkToHtml(type), "String_Node_Str", writer);
        writer.println("String_Node_Str");
        writer.println("String_Node_Str");
        writer.print("String_Node_Str");
        writer.print(type.getName());
        writer.println("String_Node_Str");
        writer.println("String_Node_Str");
    }
}

Output:
         writer.println("String_Node_Str");
-        Token.toHtml(doc.getTokens(), "String_Node_Str", this.renderLinkToHtml(type), "String_Node_Str", writer);
+        Token.toHtml(doc.getTokens(), "String_Node_Str", this::renderLinkToHtml, "String_Node_Str", writer);
         writer.println("String_Node_Str");


Input:
private AtomicInteger getRuleMatchCountInternal(String ruleId) {
    AtomicInteger count = rulesMatchCount.get(ruleId);
    if (count == null) {
        count = new AtomicInteger();
        rulesMatchCount.put(ruleId, count);
    }
    return count;
}

Output:
 private AtomicInteger getRuleMatchCountInternal(String ruleId) {
-    AtomicInteger count = rulesMatchCount.get(ruleId);
-    if (count == null) {
-        count = new AtomicInteger();
-        rulesMatchCount.put(ruleId, count);
-    }
-    return count;
+    return rulesMatchCount.computeIfAbsent(ruleId, k -> new AtomicInteger());
 }


Input:
public void setConnected(Role dest, Role src, boolean isConnected) {
    addRolePair(dest, src);
    this.map.get(dest).put(src, isConnected);
    addRolePair(src, dest);
    this.map.get(src).put(dest, isConnected);
}

Output:
 public void setConnected(Role dest, Role src, boolean isConnected) {
-    addRolePair(dest, src);
-    this.map.get(dest).put(src, isConnected);
-    addRolePair(src, dest);
-    this.map.get(src).put(dest, isConnected);
+    setConnected(dest, src, convertStatus(isConnected));
 }


Input:
public void onResume() {
    super.onResume();
    Log.d(TAG, "String_Node_Str" + items);
    Intent intent = getIntent();
    version = intent.getStringExtra("String_Node_Str");
    if (version != null) {
        Log.d(TAG, "String_Node_Str" + version);
        bible.checkVersions();
        bible.setVersion(version);
    } else {
        version = bible.getVersion();
    }
    if (items == null) {
        search = intent.getStringExtra("String_Node_Str");
        items = intent.getParcelableArrayListExtra("String_Node_Str");
    }
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    if (items == null && search == null) {
        search = sp.getString("String_Node_Str", "String_Node_Str");
        if (!"String_Node_Str".equals(search)) {
            Log.d(TAG, "String_Node_Str");
            Intent passageIntent = new Intent(getApplicationContext(), Passage.class);
            passageIntent.setAction(Intent.ACTION_VIEW);
            passageIntent.setData(Uri.parse("String_Node_Str" + search));
            startActivity(passageIntent);
            finish();
        }
    }
    index = sp.getInt("String_Node_Str", 0);
    fontsize = sp.getInt("String_Node_Str" + bible.getVersion(), 0);
    if (fontsize == 0) {
        fontsize = sp.getInt("String_Node_Str", 16);
    }
    if (fontsize > 32) {
        fontsize = 32;
    }
    if (!version.equals(bible.getVersion()) && !osis.equals("String_Node_Str")) {
        uri = Provider.CONTENT_URI_CHAPTER.buildUpon().appendEncodedPath(osis).build();
    }
    if (background == null) {
        int color = 0x6633B5E5;
        Integer mHighlightColor = (Integer) getField(findViewById(R.id.version), TextView.class, "String_Node_Str");
        if (mHighlightColor != null) {
            color = mHighlightColor.intValue();
        }
        background = String.format("String_Node_Str", (color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF, (color >>> 24) / 255.0);
        Log.d(TAG, String.format("String_Node_Str", color, background));
    }
    showView(R.id.search, true);
    if (items == null || items.size() == 0) {
        showView(R.id.items, false);
        showView(R.id.book, true);
        showView(R.id.chapter, true);
        showUri(uri);
    } else {
        showView(R.id.items, true);
        showView(R.id.book, false);
        showView(R.id.chapter, false);
        if (this.index > -1 && this.index < items.size()) {
            showItem(this.index);
        } else {
            showItem(0);
        }
    }
}

Output:
     if (items == null && search == null) {
-        search = sp.getString("String_Node_Str", "String_Node_Str");
-        if (!"String_Node_Str".equals(search)) {
+        if (!"String_Node_Str".equals(sp.getString("String_Node_Str", "String_Node_Str"))) {
+            index = sp.getInt("String_Node_Str", 0);
             Log.d(TAG, "String_Node_Str");