Input:
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.frag_simple_bar, container, false);
    mChart = new BarChart(getActivity());
    mChart.setDescription("String_Node_Str");
    MyMarkerView mv = new MyMarkerView(getActivity(), R.layout.custom_marker_view);
    mChart.setMarkerView(mv);
    mChart.setHighlightIndicatorEnabled(false);
    mChart.setDrawBorder(false);
    mChart.setDrawGridBackground(false);
    mChart.setDrawXLabels(false);
    mChart.setDrawBarShadow(false);
    Typeface tf = Typeface.createFromAsset(getActivity().getAssets(), "String_Node_Str");
    mChart.setData(generateBarData(1, 20000, 12));
    Legend l = mChart.getLegend();
    l.setTypeface(tf);
    YAxis labels = mChart.getAxisLeft();
    labels.setTypeface(tf);
    XAxis xAxis = mChart.getXAxis();
    xAxis.setDrawGridLines(false);
    FrameLayout parent = (FrameLayout) v.findViewById(R.id.parentLayout);
    parent.addView(mChart);
    return v;
}

Output:
     l.setTypeface(tf);
-    YAxis labels = mChart.getAxisLeft();
-    labels.setTypeface(tf);
+    YAxis leftAxis = mChart.getAxisLeft();
+    leftAxis.setTypeface(tf);
+    mChart.getAxisRight().setEnabled(false);
     XAxis xAxis = mChart.getXAxis();


Input:
public void testRollback() {
    long globalId = 1;
    long shardingId = 1;
    TestGlobalEntity testGlobalEntity = createGlobalEntity();
    testGlobalEntity.setId(globalId);
    TestEntity testEntity = createEntity();
    testEntity.setId(shardingId);
    storageClient.beginTransaction();
    try {
        storageClient.globalSave(testGlobalEntity).longValue();
        storageClient.save(testEntity).longValue();
        throw new RuntimeException();
    } catch (Exception e) {
        storageClient.rollback();
    }
    TestGlobalEntity a = storageClient.findByPk(globalId, TestGlobalEntity.class);
    IShardingKey<Integer> sk = new ShardingKey<Integer>(CLUSTER_KLSTORAGE, testEntity.getTestInt());
    TestEntity b = storageClient.findByPk(shardingId, sk, TestEntity.class);
    Assert.assertNull(a);
    Assert.assertNull(b);
}

Output:
 public void testRollback() {
-    long globalId = 1;
+    int globalId = 1;
     long shardingId = 1;


Input:
public static String encodeBase64String(final byte[] bytes) {
    byte[] data = encodeBase64(bytes);
    return HexUtil.encodeHexString(data);
}

Output:
     byte[] data = encodeBase64(bytes);
-    return HexUtil.encodeHexString(data);
+    return StringUtil.newStringUtf8(data).trim();
 }


Input:
private void setResult(byte[] buffer, int offset, int len) {
    this.currBuffer = buffer;
    this.currOffset = offset;
    this.currLen = len;
}

Output:
     this.currBuffer = buffer;
-    this.currOffset = offset;
+    this.currOffset = resultOffset;
     this.currLen = len;


Input:
public static boolean isValidBuildMetaData(String buildMetaData) {
    if (buildMetaData == null) {
        return false;
    } else if (buildMetaData.isEmpty()) {
        return true;
    }
    return PRE_RELEASE.matcher(buildMetaData).matches();
}

Output:
 public static boolean isValidBuildMetaData(String buildMetaData) {
-    if (buildMetaData == null) {
-        return false;
-    } else if (buildMetaData.isEmpty()) {
-        return true;
-    }
-    return PRE_RELEASE.matcher(buildMetaData).matches();
+    return buildMetaData != null && (buildMetaData.isEmpty() || BUILD_MD.matcher(buildMetaData).matches());
 }


Input:
public void instance(DRectangle rect) {
    if (w.texture == null)
        createInnie(rect, allUV.normalize(rect), to3d, mmb, 0.5f);
    else {
        DRectangle r = new DRectangle(ZERO_ONE_UVS);
        double c = (w.height - w.width) / w.height;
        r.x += c / 2;
        r.width = w.width / w.height;
        createInnie(rect, r, to3d, mbs.get("String_Node_Str" + w.texture, w.texture), 0.5f);
    }
}

Output:
         createInnie(rect, allUV.normalize(rect), to3d, mmb, 0.5f);
-    else {
-        DRectangle r = new DRectangle(ZERO_ONE_UVS);
-        double c = (w.height - w.width) / w.height;
-        r.x += c / 2;
-        r.width = w.width / w.height;
-        createInnie(rect, r, to3d, mbs.get("String_Node_Str" + w.texture, w.texture), 0.5f);
-    }
+    else
+        createInnie(rect, normalizeForInset(w), to3d, mbs.get("String_Node_Str" + w.texture, w.texture), 0.5f);
 }


Input:
public void loadFeedInfo(long feedId, BlogInfoListener blogInfoListener) {
    mBlogInfoListener = blogInfoListener;
    showBlogInfo(ReaderBlogTable.getBlogInfo(feedId), false);
    requestFeedInfo(feedId);
}

Output:
     mBlogInfoListener = blogInfoListener;
-    showBlogInfo(ReaderBlogTable.getBlogInfo(feedId), false);
+    showBlogInfo(ReaderBlogTable.getFeedInfo(feedId), false);
     requestFeedInfo(feedId);


Input:
private List<SyncopeUser> doSearch(final Set<Long> adminRoles, final NodeCond nodeCond, final int page, final int itemsPerPage) {
    Map<Integer, Object> parameters = Collections.synchronizedMap(new HashMap<Integer, Object>());
    StringBuilder queryString = getQuery(nodeCond, parameters);
    queryString.insert(0, "String_Node_Str");
    queryString.append("String_Node_Str");
    queryString.append(getAdminRolesFilter(adminRoles)).append("String_Node_Str");
    Query query = entityManager.createNativeQuery(queryString.toString());
    query.setFirstResult(itemsPerPage * (page <= 0 ? 0 : page - 1));
    if (itemsPerPage >= 0) {
        query.setMaxResults(itemsPerPage);
    }
    fillWithParameters(query, parameters);
    LOG.debug("String_Node_Str", queryString.toString(), parameters);
    Set<Number> userIds = new HashSet<Number>();
    List resultList = query.getResultList();
    if (resultList != null) {
        for (Object userId : resultList) {
            if (userId instanceof Object[]) {
                userIds.add((Number) ((Object[]) userId)[0]);
            } else {
                userIds.add((Number) userId);
            }
        }
    }
    List<SyncopeUser> result = new ArrayList<SyncopeUser>(userIds.size());
    SyncopeUser user;
    for (Object userId : userIds) {
        user = userDAO.find(((Number) userId).longValue());
        if (user == null) {
            LOG.error("String_Node_Str" + "String_Node_Str", userId);
        } else {
            result.add(user);
        }
    }
    return result;
}

Output:
     Map<Integer, Object> parameters = Collections.synchronizedMap(new HashMap<Integer, Object>());
-    StringBuilder queryString = getQuery(nodeCond, parameters);
+    final StringBuilder queryString = getQuery(nodeCond, parameters);
     queryString.insert(0, "String_Node_Str");


Input:
private boolean encapsulateInRtxAndTransmit(RawPacket pkt, long rtxSsrc) {
    byte[] buf = pkt.getBuffer();
    int len = pkt.getLength();
    int off = pkt.getOffset();
    byte[] newBuf = buf;
    if (buf.length < len + 2) {
        newBuf = new byte[len + 2];
    }
    int osn = pkt.getSequenceNumber();
    int headerLength = pkt.getHeaderLength();
    int payloadLength = len - headerLength;
    System.arraycopy(buf, off, newBuf, 0, headerLength);
    newBuf[headerLength] = (byte) ((osn >> 8) & 0xff);
    newBuf[headerLength + 1] = (byte) (osn & 0xff);
    System.arraycopy(buf, off + headerLength, newBuf, headerLength + 2, payloadLength);
    MediaStream mediaStream = channel.getStream();
    if (mediaStream != null) {
        pkt.setSSRC((int) rtxSsrc);
        pkt.setSequenceNumber(getNextRtxSequenceNumber(rtxSsrc));
        try {
            mediaStream.injectPacket(pkt, true, null);
        } catch (TransmissionFailedException tfe) {
            logger.warn("String_Node_Str");
            return false;
        }
    }
    return true;
}

Output:
     int off = pkt.getOffset();
-    byte[] newBuf = buf;
-    if (buf.length < len + 2) {
-        newBuf = new byte[len + 2];
-    }
+    byte[] newBuf = new byte[len + 2];
+    RawPacket rtxPkt = new RawPacket(newBuf, 0, len + 2);
     int osn = pkt.getSequenceNumber();


Input:
JUnitTaskMirror.JUnitResultFormatterMirror createFormatter(ClassLoader loader) throws BuildException {
    if (classname == null) {
        throw new BuildException("String_Node_Str");
    }
    Class f = null;
    try {
        if (loader == null) {
            f = Class.forName(classname);
        } else {
            f = Class.forName(classname, true, loader);
        }
    } catch (ClassNotFoundException e) {
        throw new BuildException("String_Node_Str" + loader + "String_Node_Str" + classname + "String_Node_Str" + e, e);
    } catch (NoClassDefFoundError e) {
        throw new BuildException("String_Node_Str" + loader + "String_Node_Str" + classname + "String_Node_Str" + e, e);
    }
    Object o = null;
    try {
        o = f.newInstance();
    } catch (InstantiationException e) {
        throw new BuildException(e);
    } catch (IllegalAccessException e) {
        throw new BuildException(e);
    }
    if (!(o instanceof JUnitTaskMirror.JUnitResultFormatterMirror)) {
        throw new BuildException(classname + "String_Node_Str");
    }
    JUnitTaskMirror.JUnitResultFormatterMirror r = (JUnitTaskMirror.JUnitResultFormatterMirror) o;
    if (useFile && outFile != null) {
        try {
            out = new BufferedOutputStream(new FileOutputStream(outFile));
        } catch (java.io.IOException e) {
            throw new BuildException("String_Node_Str" + outFile, e);
        }
    }
    r.setOutput(out);
    boolean needToSetProjectReference = true;
    try {
        Field field = r.getClass().getField("String_Node_Str");
        Object value = field.get(r);
        if (value instanceof Project) {
            needToSetProjectReference = false;
        }
    } catch (Exception e) {
    }
    if (needToSetProjectReference) {
        Method setter;
        try {
            setter = r.getClass().getMethod("String_Node_Str", new Class[] { Project.class });
            setter.invoke(r, new Object[] { project });
        } catch (Exception e) {
        }
    }
    return r;
}

Output:
         }
-    } catch (Exception e) {
+    } catch (NoSuchFieldException e) {
+    } catch (IllegalAccessException e) {
+        throw new BuildException(e);
     }


Input:
private Set<Mod> loadMods(Path path, ModManager mm) {
    Set<Mod> mods = new HashSet<>();
    try (FileReader reader = new FileReader(path.toFile())) {
        Set<Mod> newMods = gson.fromJson(reader, modsType);
        for (Mod newMod : newMods) {
            if (newMod.isUpdateable() || isDownloaded(newMod) || trySatisfyLocalFiles(newMod, mm)) {
                mods.add(newMod);
            }
        }
    } catch (FileNotFoundException e) {
    } catch (IOException e1) {
        e1.printStackTrace();
    }
    DefaultMods.ensureDefaults(mods);
    return mods;
}

Output:
     try (FileReader reader = new FileReader(path.toFile())) {
-        Set<Mod> newMods = gson.fromJson(reader, modsType);
+        Set<Mod> newMods = gson.fromJson(reader, MODS_TYPE);
         for (Mod newMod : newMods) {


Input:
private <T> List<DataInstance<Vector>> shuffledInstances(Map<DataInstance<Vector>, Map<Label, T>> map) {
    List<DataInstance<Vector>> instances = new ArrayList<>(map.keySet());
    Collections.shuffle(instances);
    return instances;
}

Output:
     List<DataInstance<Vector>> instances = new ArrayList<>(map.keySet());
-    Collections.shuffle(instances);
+    Collections.shuffle(instances, new Random(9999));
     return instances;


Input:
public static WherigoService create() {
    GeocachingApiConfiguration apiConfiguration = new DefaultProductionGeocachingApiConfiguration();
    JsonDownloader jsonDownloader = new OkHttpClientJsonDownloader(apiConfiguration, new OkHttpClient());
    return new WherigoServiceImpl(jsonDownloader);
}

Output:
 public static WherigoService create() {
-    GeocachingApiConfiguration apiConfiguration = new DefaultProductionGeocachingApiConfiguration();
-    JsonDownloader jsonDownloader = new OkHttpClientJsonDownloader(apiConfiguration, new OkHttpClient());
-    return new WherigoServiceImpl(jsonDownloader);
+    return new WherigoServiceImpl(GeocachingApiFactory.createJsonDownloader());
 }


Input:
private String getMatchingRowsStatement() {
    double value = Double.valueOf(entity.getValue());
    String whereClause = dbmsLanguage.where() + this.columnName + dbmsLanguage.equal() + value;
    TdColumn column = (TdColumn) indicator.getAnalyzedElement();
    return SELECT_ALL + dbmsLanguage.from() + getFullyQualifiedTableName(column) + whereClause;
}

Output:
     String whereClause = dbmsLanguage.where() + this.columnName + dbmsLanguage.equal() + value;
-    TdColumn column = (TdColumn) indicator.getAnalyzedElement();
-    return SELECT_ALL + dbmsLanguage.from() + getFullyQualifiedTableName(column) + whereClause;
+    return SELECT_ALL + dbmsLanguage.from() + getFullyQualifiedTableName(indicator.getAnalyzedElement()) + whereClause;
 }


Input:
public Cursor runQuery(CharSequence constraint) {
    if (mItemsCursor != null) {
        Log.d(TAG, "String_Node_Str");
        stopManagingCursor(mItemsCursor);
    }
    mItemsCursor = managedQuery(Items.CONTENT_URI, new String[] { Items._ID, Items.NAME }, "String_Node_Str" + (constraint == null ? "String_Node_Str" : constraint.toString().toUpperCase()) + "String_Node_Str", null, "String_Node_Str");
    return mItemsCursor;
}

Output:
     }
-    mItemsCursor = managedQuery(Items.CONTENT_URI, new String[] { Items._ID, Items.NAME }, "String_Node_Str" + (constraint == null ? "String_Node_Str" : constraint.toString().toUpperCase()) + "String_Node_Str", null, "String_Node_Str");
+    mItemsCursor = managedQuery(Items.CONTENT_URI, new String[] { Items._ID, Items.NAME }, "String_Node_Str", new String[] { "String_Node_Str" + (constraint == null ? "String_Node_Str" : constraint.toString().toUpperCase()) + "String_Node_Str" }, "String_Node_Str");
     return mItemsCursor;


Input:
public void update(DataAccess data, String[] fieldNames, Object[] fieldValues) throws DatabaseWriteException {
    if (!this.doesEntryExist(data)) {
        return;
    }
    Connection conn = pool.getConnectionFromPool();
    ResultSet rs = null;
    try {
        rs = this.getResultSet(conn, data, fieldNames, fieldValues, true);
        if (rs != null) {
            if (rs.next()) {
                HashMap<Column, Object> columns = data.toDatabaseEntryList();
                Iterator<Column> it = columns.keySet().iterator();
                Column column = null;
                while (it.hasNext()) {
                    column = it.next();
                    if (column.isList()) {
                        rs.updateObject(column.columnName(), this.getString((List<?>) columns.get(column)));
                    } else {
                        rs.updateObject(column.columnName(), columns.get(column));
                    }
                }
                rs.updateRow();
            } else {
                throw new DatabaseWriteException("String_Node_Str" + data.toString());
            }
        }
    } catch (SQLException ex) {
        Canary.logStacktrace(ex.getMessage(), ex);
    } catch (DatabaseTableInconsistencyException dtie) {
        Canary.logStacktrace(dtie.getMessage(), dtie);
    } catch (DatabaseReadException ex) {
        Logger.getLogger(MySQLDatabase.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
        try {
            PreparedStatement st = rs.getStatement() instanceof PreparedStatement ? (PreparedStatement) rs.getStatement() : null;
            this.closeRS(rs);
            this.closePS(st);
            pool.returnConnectionToPool(conn);
        } catch (SQLException ex) {
            Canary.logStacktrace(ex.getMessage(), ex);
        }
    }
}

Output:
                 Iterator<Column> it = columns.keySet().iterator();
-                Column column = null;
+                Column column;
                 while (it.hasNext()) {


Input:
public Spatial load(BulletAppState bulletAppState, AssetManager assetManager, KwdFile kwdFile) {
    CreatureLoader creatureLoader = new CreatureLoader(kwdFile, worldState);
    List<Node> result = new ArrayList<>();
    for (toniarts.openkeeper.tools.convert.map.Thing obj : kwdFile.getThings()) {
        try {
            if (obj instanceof Thing.Object) {
                Thing.Creature cr = (Thing.Creature) obj;
                nodeCreatures.attachChild(creatureLoader.load(assetManager, cr));
            }
        } catch (Exception ex) {
            System.err.println(ex);
        }
    }
    return result;
}

Output:
     CreatureLoader creatureLoader = new CreatureLoader(kwdFile, worldState);
-    List<Node> result = new ArrayList<>();
+    Node root = new Node("String_Node_Str");
+    Node nodeCreatures = new Node("String_Node_Str");
+    Node nodeObjects = new Node("String_Node_Str");
     for (toniarts.openkeeper.tools.convert.map.Thing obj : kwdFile.getThings()) {


Input:
public void reset(ScPointer feature, int contour, int repetition) {
    super.reset(feature, contour, repetition);
    this.source = feature;
    this.pressed = feature.getPressed();
    this.distance = feature.getValue();
    this.height = feature.getHeight(this.distance);
    this.width = feature.getWidth(this.distance);
    this.tangent = feature.getPointAndAngle(this.distance, this.mGenericPoint);
    this.color = feature.getGradientColor(this.distance);
}

Output:
     this.pressed = feature.getPressed();
-    this.distance = feature.getValue();
-    this.height = feature.getHeight(this.distance);
-    this.width = feature.getWidth(this.distance);
-    this.tangent = feature.getPointAndAngle(this.distance, this.mGenericPoint);
-    this.color = feature.getGradientColor(this.distance);
+    this.distance = distance;
+    this.height = feature.getHeight(distance);
+    this.width = feature.getWidth(distance);
+    this.tangent = feature.getPointAndAngle(distance, this.mGenericPoint);
+    this.color = feature.getGradientColor(distance);
+    this.point[0] = this.mGenericPoint[0];
+    this.point[1] = this.mGenericPoint[1];
 }


Input:
protected void recordDisconnect(CommunicationsProtocol protocol, ClientSession session) {
    ProtocolClientMap pcm = getProtocolClientMap();
    DataManager dm = AppContext.getDataManager();
    dm.markForUpdate(pcm);
    pcm.remove(protocol, session);
}

Output:
     dm.markForUpdate(pcm);
-    pcm.remove(protocol, session);
+    pcm.remove(protocol, sessionRef);
 }


Input:
protected void visitPage(PageArea page) {
    scale = page.getScale();
    if (page.isExtendToMultiplePages()) {
        int pageBodyHeight = getActualPageBodyHeight(page);
        int pageBodyWidth = getActualPageBodyWidth(page);
        int definedBodyHeight = page.getBody().getHeight();
        int definedBodyWidth = page.getBody().getWidth();
        if (pageBodyHeight > definedBodyHeight) {
            addExtendDirection(EXTEND_ON_VERTICAL);
        }
        if (pageBodyWidth > definedBodyWidth) {
            addExtendDirection(EXTEND_ON_HORIZONTAL);
        }
        offsetX = 0;
        offsetY = 0;
        if (extendDirection == EXTEND_NONE) {
            addPage(page);
        } else if (extendDirection == EXTEND_ON_HORIZONTAL) {
            do {
                addPage(page);
                offsetX += definedBodyWidth;
            } while (offsetX < pageBodyWidth - ignoredOverflow);
        } else if (extendDirection == EXTEND_ON_VERTICAL) {
            do {
                addPage(page);
                offsetY += definedBodyHeight;
            } while (offsetY < pageBodyHeight - ignoredOverflow);
        } else if (extendDirection == EXTEND_ON_HORIZONTAL_AND_VERTICAL) {
            do {
                do {
                    addPage(page);
                    offsetX += definedBodyWidth;
                } while (offsetX < pageBodyWidth - ignoredOverflow);
                offsetX = 0;
                offsetY += definedBodyHeight;
            } while (offsetY < pageBodyHeight - ignoredOverflow);
        }
        setExtendDirection(EXTEND_NONE);
    } else {
        addPage(page);
    }
}

Output:
         int pageBodyWidth = getActualPageBodyWidth(page);
-        int definedBodyHeight = page.getBody().getHeight();
-        int definedBodyWidth = page.getBody().getWidth();
+        IContainerArea pageBody = page.getBody();
+        int definedBodyHeight = 0;
+        int definedBodyWidth = 0;
+        if (pageBody != null) {
+            definedBodyHeight = pageBody.getHeight();
+            definedBodyWidth = pageBody.getWidth();
+        }
         if (pageBodyHeight > definedBodyHeight) {


Input:
public static boolean hasRemoteRuleHead(Rule r) {
    Predicate h = r.getHead();
    if (r.isSimpleArrayInit())
        return false;
    if (r.getBodyP().size() == 0)
        return true;
    List<Predicate> body = r.getBodyP();
    Predicate p = body.get(body.size() - 1);
    if (p.first().equals(h.first()))
        return false;
    else
        return true;
}

Output:
     Predicate p = body.get(body.size() - 1);
-    if (p.first().equals(h.first()))
-        return false;
-    else
-        return true;
+    return requireTransfer(p, h, tableMap);
 }


Input:
protected AsyncTaskResult<String> doInBackground(Object... arg0) {
    try {
        if (!mAccountData.containsKey(accountName)) {
            AccountData newAccountData = new AccountData();
            newAccountData.drive = createDriveService(accountName, activity);
            mAccountData.put(accountName, newAccountData);
            logDebug("String_Node_Str" + accountName);
            newAccountData.mFolderCache = buildFoldersCache(accountName);
            About about = newAccountData.drive.about().get().execute();
            newAccountData.mRootFolderId = about.getRootFolderId();
        }
        if (setupAct.getProcessName().equals(PROCESS_NAME_SELECTFILE))
            setupAct.getState().putString(EXTRA_PATH, getRootPathForAccount(accountName));
        return new AsyncTaskResult<String>("String_Node_Str");
    } catch (Exception anyError) {
        return new AsyncTaskResult<String>(anyError);
    }
}

Output:
             logDebug("String_Node_Str" + accountName);
-            newAccountData.mFolderCache = buildFoldersCache(accountName);
-            About about = newAccountData.drive.about().get().execute();
-            newAccountData.mRootFolderId = about.getRootFolderId();
+            finishInitialization(newAccountData, accountName);
         }


Input:
public void commitEvent(Event event) {
    MouseButtonEvent3D buttonEvent = (MouseButtonEvent3D) event;
    if (!buttonEvent.isPressed()) {
        return;
    }
    Entity entity = event.getEntity();
    if (entity.getComponent(SpinProcessor.class) != null) {
        entity.removeComponent(SpinProcessor.class);
    } else {
        try {
            entity.addComponent(SpinProcessor.class, new SpinProcessor(entity));
        } catch (InstantiationException ex) {
        }
    }
}

Output:
 public void commitEvent(Event event) {
-    MouseButtonEvent3D buttonEvent = (MouseButtonEvent3D) event;
-    if (!buttonEvent.isPressed()) {
+    if (!((MouseButtonEvent3D) event).isPressed()) {
         return;


Input:
public int[] getAction(TorusAgent me, TorusWorld world, TorusAgent[] preds, TorusAgent[] prey) {
    double[] inputs = inputs(me, world, preds, prey);
    double[] outputs = nn.process(inputs);
    return actions[StatisticsUtilities.argmax(outputs)];
}

Output:
     double[] outputs = nn.process(inputs);
-    return actions[StatisticsUtilities.argmax(outputs)];
+    return isPredator ? PREDATOR_ACTIONS[StatisticsUtilities.argmax(outputs)] : PREY_ACTIONS[StatisticsUtilities.argmax(outputs)];
 }


Input:
public Set<Ref> getDependents(Ref precedent) {
    Set<Ref> result = new HashSet<Ref>();
    Queue<Ref> queue = new LinkedList<Ref>();
    queue.add(precedent);
    while (!queue.isEmpty()) {
        Ref p = queue.remove();
        for (Entry<Ref, Set<Ref>> entry : map.entrySet()) {
            Ref target = entry.getKey();
            if (!result.contains(target)) {
                for (Ref pre : entry.getValue()) {
                    if (isMatched(pre, p)) {
                        result.add(target);
                        queue.add(target);
                        break;
                    }
                }
            }
        }
    }
    return result;
}

Output:
 public Set<Ref> getDependents(Ref precedent) {
-    Set<Ref> result = new HashSet<Ref>();
+    Set<Ref> result = new LinkedHashSet<Ref>();
     Queue<Ref> queue = new LinkedList<Ref>();


Input:
public boolean onUpdate(Type newData, Type oldData) {
    DataStore datastore = DefaultDataRepos.this.loadDataStore(newData.getName(), oldData);
    this.put(datastore);
    return false;
}

Output:
 public boolean onUpdate(Type newData, Type oldData) {
-    DataStore datastore = DefaultDataRepos.this.loadDataStore(newData.getName(), oldData);
+    DataStore datastore = DefaultDataRepos.this.loadDataStore(newData.getName(), newData);
     this.put(datastore);


Input:
public BgpValidityResource validity(final Asn origin, final IpRange prefix) {
    final List<Pair<RoaPrefix, Validity>> roaPrefixes = this.roaPrefixes.findExactAndAllLessSpecific(prefix).stream().flatMap(x -> x.stream()).map(r -> {
        final BgpPreviewEntry bgpPreviewEntry = BgpPreviewEntry.of(origin, prefix, Validity.UNKNOWN);
        final Validity validity = validateBgpRisEntry(Collections.singletonList(r), bgpPreviewEntry);
        return Pair.of(r, validity);
    }).sorted(Comparator.comparingInt(p -> {
        switch(p.getRight()) {
            case VALID:
                return 0;
            case INVALID_LENGTH:
                return 1;
            case INVALID_ASN:
                return 2;
        }
        return 10;
    })).collect(Collectors.toList());
    final Validity validity = roaPrefixes.stream().findFirst().map(p -> p.getRight()).orElse(Validity.UNKNOWN);
    final List<ValidatingRoa> validatingRoaStream = roaPrefixes.stream().flatMap(p -> {
        final RoaPrefix r = p.getLeft();
        if (r.getTrustAnchor() != null) {
            return r.getLocations().stream().map(loc -> ValidatingRoa.of(r.getAsn().toString(), r.getPrefix().toString(), p.getRight().toString(), r.getMaximumLength(), r.getTrustAnchor() == null ? null : r.getTrustAnchor().getName(), loc, null, null));
        } else if (r.getRoaPrefixAssertionId() != null) {
            return Stream.of(ValidatingRoa.of(r.getAsn().toString(), r.getPrefix().toString(), p.getRight().toString(), r.getMaximumLength(), null, null, r.getRoaPrefixAssertionId(), r.getComment()));
        } else {
            return Stream.empty();
        }
    }).distinct().collect(Collectors.toList());
    return BgpValidityResource.of(origin.toString(), prefix.toString(), validity.toString(), validatingRoaStream);
}

Output:
         } else if (r.getRoaPrefixAssertionId() != null) {
-            return Stream.of(ValidatingRoa.of(r.getAsn().toString(), r.getPrefix().toString(), p.getRight().toString(), r.getMaximumLength(), null, null, r.getRoaPrefixAssertionId(), r.getComment()));
+            return Stream.of(ValidatingRoa.of(r.getAsn().toString(), r.getPrefix().toString(), p.getRight().toString(), r.getMaximumLength(), "String_Node_Str", null, r.getRoaPrefixAssertionId(), r.getComment()));
         } else {


Input:
private void upgradeFeatureSGID(Feature feature) {
    FSGID fsgid = new FSGID(feature.getSGID(), feature, this);
    processTimestamp(fsgid);
    feature.impersonate(fsgid, feature.getPrecedingSGID());
    if (getManager() != null) {
        getManager().atomStateChange(feature, CreateUpdateManager.State.NEW_CREATION);
    }
}

Output:
     feature.impersonate(fsgid, feature.getPrecedingSGID());
-    if (getManager() != null) {
-        getManager().atomStateChange(feature, CreateUpdateManager.State.NEW_CREATION);
+    if (feature.getManager() != null) {
+        feature.getManager().atomStateChange(feature, CreateUpdateManager.State.NEW_CREATION);
     }


Input:
public void timeout(UUID userId) {
    if (userPlayerMap.containsKey(userId)) {
        StringBuilder sb = new StringBuilder(game.getPlayer(userPlayerMap.get(userId)).getName()).append("String_Node_Str").append(ConfigSettings.getInstance().getMaxSecondsIdle()).append("String_Node_Str");
        ChatManager.getInstance().broadcast(chatId, "String_Node_Str", sb.toString(), MessageColor.BLACK, true, MessageType.STATUS);
        game.idleTimeout(getPlayerId(userId));
    }
}

Output:
     if (userPlayerMap.containsKey(userId)) {
-        StringBuilder sb = new StringBuilder(game.getPlayer(userPlayerMap.get(userId)).getName()).append("String_Node_Str").append(ConfigSettings.getInstance().getMaxSecondsIdle()).append("String_Node_Str");
-        ChatManager.getInstance().broadcast(chatId, "String_Node_Str", sb.toString(), MessageColor.BLACK, true, MessageType.STATUS);
+        String sb = game.getPlayer(userPlayerMap.get(userId)).getName() + "String_Node_Str" + ConfigSettings.getInstance().getMaxSecondsIdle() + "String_Node_Str";
+        ChatManager.getInstance().broadcast(chatId, "String_Node_Str", sb, MessageColor.BLACK, true, MessageType.STATUS);
         game.idleTimeout(getPlayerId(userId));


Input:
private DatasetMeta getFromMds(DatasetId instance) throws Exception {
    DatasetSpecification spec = instanceManager.get(instance);
    if (spec == null) {
        throw new NotFoundException(instance);
    }
    spec = DatasetsUtil.fixOriginalProperties(spec);
    DatasetTypeId datasetTypeId = instance.getParent().datasetType(spec.getType());
    DatasetTypeMeta typeMeta = getTypeInfo(instance.getParent(), spec.getType());
    if (typeMeta == null) {
        throw new NotFoundException(datasetTypeId);
    }
    String ownerPrincipal = null;
    if (!NamespaceId.SYSTEM.equals(instance.getNamespaceId())) {
        ownerPrincipal = ownerAdmin.getOwnerPrincipal(instance);
    }
    return new DatasetMeta(spec, typeMeta, null, ownerPrincipal);
}

Output:
     if (!NamespaceId.SYSTEM.equals(instance.getNamespaceId())) {
-        ownerPrincipal = ownerAdmin.getOwnerPrincipal(instance);
+        ownerPrincipal = ownerAdmin.getImpersonationPrincipal(instance);
     }


Input:
private void _connectWebsocket(String host, int port, HttpClient client) {
    String address = "String_Node_Str" + host + "String_Node_Str" + port;
    client.connectWebsocket(address, new Handler<WebSocket>() {

        public void handle(WebSocket websocket) {
            synchronized (_actor) {
                if (_numberOfTries < 0) {
                    websocket.close();
                    return;
                }
                if (!_actor.isExecuting()) {
                    websocket.close();
                    return;
                }
                _wsIsOpen = true;
                _webSocket = websocket;
                _webSocket.dataHandler(new DataHandler());
                _webSocket.endHandler(new EndHandler());
                _webSocket.exceptionHandler(new WebSocketExceptionHandler());
                _webSocket.closeHandler(new WebSocketCloseHandler());
                _currentObj.callMember("String_Node_Str", "String_Node_Str");
                _currentObj.callMember("String_Node_Str", "String_Node_Str");
                if (_pendingOutputs != null && _pendingOutputs.size() > 0) {
                    for (Object message : _pendingOutputs) {
                        _sendMessageOverSocket(message);
                    }
                    _pendingOutputs.clear();
                }
            }
        }
    });
}

Output:
 private void _connectWebsocket(String host, int port, HttpClient client) {
-    String address = "String_Node_Str" + host + "String_Node_Str" + port;
-    client.connectWebsocket(address, new Handler<WebSocket>() {
+    client.websocket(port, host, "String_Node_Str", new Handler<WebSocket>() {


Input:
private void activateSessionCloser() {
    if (lastTask != null) {
        lastTask.cancel(false);
    }
    lastTask = taskScheduler.schedule(closeSessionTask, new Date(System.currentTimeMillis() + (NUM_NO_PINGS_TO_CLOSE * pingInterval)));
}

Output:
 private void activateSessionCloser() {
-    if (lastTask != null) {
-        lastTask.cancel(false);
-    }
+    disablePingWatchdog();
     lastTask = taskScheduler.schedule(closeSessionTask, new Date(System.currentTimeMillis() + (NUM_NO_PINGS_TO_CLOSE * pingInterval)));


Input:
public void checkTypes(MarkerList markers, IContext context) {
    this.context = context;
    if (this.method != null) {
        if (this.method.hasTypeVariables()) {
            for (int i = 0; i < this.parameterCount; i++) {
                IParameter param = this.parameters[i];
                param.setType(param.getType().getConcreteType(this.type));
            }
            this.returnType = this.method.getType().getConcreteType(this.type);
        } else {
            this.returnType = this.method.getType();
        }
        this.value = this.value.resolve(markers, this);
        IValue value1 = this.value.withType(this.returnType);
        if (value1 == null) {
            Marker marker = markers.create(this.value.getPosition(), "String_Node_Str");
            marker.addInfo("String_Node_Str" + this.returnType);
            marker.addInfo("String_Node_Str" + this.value.getType());
        } else {
            this.value = value1;
        }
    } else {
        markers.add(this.position, "String_Node_Str");
    }
    this.value.checkTypes(markers, this);
    this.context = null;
}

Output:
                 IParameter param = this.parameters[i];
-                param.setType(param.getType().getConcreteType(this.type));
+                IType type = param.getType();
+                if (type == null) {
+                    type = this.method.getParameter(i).getType();
+                }
+                param.setType(type.getConcreteType(this.type));
             }


Input:
private void substituteVariable(boolean exceptionIfNotResolved) throws UnresolvedVariableException {
    int endIndex = location + 1;
    char c = input.charAt(endIndex);
    if (endIndex >= input.length() || !(Character.isJavaIdentifierStart(c) && c != '$')) {
        return;
    }
    while (++endIndex < input.length()) {
        c = input.charAt(endIndex);
        if (!(Character.isJavaIdentifierPart(c) && c != '$')) {
            break;
        }
    }
    final String name = input.substring(location + 1, endIndex);
    final String value = cmdCtx == null ? null : cmdCtx.getVariable(name);
    if (value == null) {
        if (exceptionIfNotResolved) {
            throw new UnresolvedVariableException(name, "String_Node_Str" + name);
        }
    } else {
        substitued.add("String_Node_Str" + name, value, location);
        StringBuilder buf = new StringBuilder(input.length() - name.length() + value.length());
        buf.append(input.substring(0, location)).append(value);
        if (endIndex < input.length()) {
            buf.append(input.substring(endIndex));
        }
        input = buf.toString();
        ch = input.charAt(location);
    }
}

Output:
     if (value == null) {
-        if (exceptionIfNotResolved) {
+        if (exceptionIfNotResolved && !disableResolutionException) {
             throw new UnresolvedVariableException(name, "String_Node_Str" + name);


Input:
public Mail runMailStandard(ReminderMethodLine reminderMethodLine, Partner partner, Company company) throws AxelorException {
    LOG.debug("String_Node_Str");
    if (reminderMethodLine.getReminderMailModel() != null) {
        MailModel reminderMailModel = reminderMethodLine.getReminderMailModel();
        Mail reminderMail = this.createGenericMail(reminderMailModel, null, today.plusDays(reminderMethodLine.getStandardDeadline()), partner.getMainInvoicingAddress(), company);
        LinkedList<ReminderHistory> reminderHistoryList = new LinkedList<ReminderHistory>();
        reminderHistoryList.addAll(partner.getReminder().getReminderHistoryList());
        reminderMail.setReminderHistory(reminderHistoryList.getLast());
        return this.replaceTag(reminderMail);
    } else {
        throw new AxelorException(String.format("String_Node_Str", GeneralService.getExceptionReminderMsg(), partner.getName(), reminderMethodLine.getReminderMethod().getName(), reminderMethodLine.getReminderLevel().getName()), IException.CONFIGURATION_ERROR);
    }
}

Output:
         Mail reminderMail = this.createGenericMail(reminderMailModel, null, today.plusDays(reminderMethodLine.getStandardDeadline()), partner.getMainInvoicingAddress(), company);
-        LinkedList<ReminderHistory> reminderHistoryList = new LinkedList<ReminderHistory>();
-        reminderHistoryList.addAll(partner.getReminder().getReminderHistoryList());
-        reminderMail.setReminderHistory(reminderHistoryList.getLast());
+        reminderMail.setReminderHistory(this.getReminderHistory(partner, company));
         return this.replaceTag(reminderMail);


Input:
public static List<ConnectionPart> getConnectionParts(ProcessPart processPart, Point point, Node node) {
    List<ConnectionPart> connectionParts = new ArrayList<ConnectionPart>();
    for (Object child : processPart.getChildren()) {
        if (child instanceof SubjobContainerPart) {
            SubjobContainerPart subJobPart = (SubjobContainerPart) child;
            for (Object sChilde : subJobPart.getChildren()) {
                if (sChilde instanceof NodeContainerPart) {
                    NodeContainerPart nodeCPart = (NodeContainerPart) sChilde;
                    for (Object nChild : nodeCPart.getChildren()) {
                        if (nChild instanceof NodePart) {
                            for (Object conn : ((NodePart) nChild).getTargetConnections()) {
                                if (conn instanceof ConnectionPart && canCreateNodeOnLink((Connection) ((ConnectionPart) conn).getModel(), node)) {
                                    ConnectionPart connPart = (ConnectionPart) conn;
                                    if (connPart.getFigure() != null && connPart.getFigure().getBounds().contains(point)) {
                                        connectionParts.add((ConnectionPart) conn);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return connectionParts;
}

Output:
                                     ConnectionPart connPart = (ConnectionPart) conn;
-                                    if (connPart.getFigure() != null && connPart.getFigure().getBounds().contains(point)) {
-                                        connectionParts.add((ConnectionPart) conn);
-                                    }
+                                    connectionParts.add((ConnectionPart) conn);
                                 }


Input:
public void triggerInterrupts() {
    boolean trigger = false;
    int tIndex = 0;
    for (int i = 0, n = noCompare; i < n; i++) {
        boolean newTrigger = (tcctl[i] & CC_TRIGGER_INT) == CC_TRIGGER_INT;
        trigger = trigger | newTrigger;
        if (i == 0) {
            core.flagInterrupt(type == TIMER_A ? TACCR0_VECTOR : TBCCR0_VECTOR, this, trigger);
            if (trigger) {
                lastTIV = memory[type == TIMER_A ? TAIV : TBIV] = 0;
                return;
            }
        } else {
            if (newTrigger) {
                if (DEBUG) {
                    System.out.println(getName() + "String_Node_Str" + (i * 2));
                }
                tIndex = i;
            }
        }
        if (trigger) {
            lastTIV = memory[type == TIMER_A ? TAIV : TBIV] = tIndex * 2;
        }
    }
    if (!trigger) {
        if (interruptEnable && interruptPending) {
            trigger = true;
            lastTIV = memory[type == TIMER_A ? TAIV : TBIV] = timerOverflow;
        }
    }
    core.flagInterrupt(type == TIMER_A ? TACCR1_VECTOR : TBCCR1_VECTOR, this, trigger);
}

Output:
         if (i == 0) {
-            core.flagInterrupt(type == TIMER_A ? TACCR0_VECTOR : TBCCR0_VECTOR, this, trigger);
+            core.flagInterrupt(ccr0Vector, this, trigger);
             if (trigger) {


Input:
private static void appendApplicationInfo(final Appendable report, final WalletApplication application) throws IOException {
    final PackageInfo pi = application.packageInfo();
    final Configuration configuration = application.getConfiguration();
    final Calendar calendar = new GregorianCalendar(UTC);
    report.append("String_Node_Str" + pi.versionName + "String_Node_Str" + pi.versionCode + "String_Node_Str");
    report.append("String_Node_Str" + pi.packageName + "String_Node_Str");
    report.append("String_Node_Str" + application.getPackageManager().getInstallerPackageName(pi.packageName) + "String_Node_Str");
    report.append("String_Node_Str" + (Constants.TEST ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    report.append("String_Node_Str" + TimeZone.getDefault().getID() + "String_Node_Str");
    calendar.setTimeInMillis(System.currentTimeMillis());
    report.append("String_Node_Str" + String.format(Locale.US, "String_Node_Str", calendar, calendar, calendar) + "String_Node_Str");
    calendar.setTimeInMillis(WalletApplication.TIME_CREATE_APPLICATION);
    report.append("String_Node_Str" + String.format(Locale.US, "String_Node_Str", calendar, calendar, calendar) + "String_Node_Str");
    calendar.setTimeInMillis(pi.lastUpdateTime);
    report.append("String_Node_Str" + String.format(Locale.US, "String_Node_Str", calendar, calendar, calendar) + "String_Node_Str");
    calendar.setTimeInMillis(pi.firstInstallTime);
    report.append("String_Node_Str" + String.format(Locale.US, "String_Node_Str", calendar, calendar, calendar) + "String_Node_Str");
    final long lastBackupTime = configuration.getLastBackupTime();
    calendar.setTimeInMillis(lastBackupTime);
    report.append("String_Node_Str" + (lastBackupTime > 0 ? String.format(Locale.US, "String_Node_Str", calendar, calendar, calendar) : "String_Node_Str") + "String_Node_Str");
    report.append("String_Node_Str" + Constants.NETWORK_PARAMETERS.getId() + "String_Node_Str");
    final Wallet wallet = application.getWallet();
    report.append("String_Node_Str" + wallet.isEncrypted() + "String_Node_Str");
    report.append("String_Node_Str" + wallet.getKeyChainGroupSize() + "String_Node_Str");
    final Set<Transaction> transactions = wallet.getTransactions(true);
    int numInputs = 0;
    int numOutputs = 0;
    int numSpentOutputs = 0;
    for (final Transaction tx : transactions) {
        numInputs += tx.getInputs().size();
        final List<TransactionOutput> outputs = tx.getOutputs();
        numOutputs += outputs.size();
        for (final TransactionOutput txout : outputs) {
            if (!txout.isAvailableForSpending())
                numSpentOutputs++;
        }
    }
    report.append("String_Node_Str" + transactions.size() + "String_Node_Str");
    report.append("String_Node_Str" + numInputs + "String_Node_Str");
    report.append("String_Node_Str" + numOutputs + "String_Node_Str" + numSpentOutputs + "String_Node_Str");
    report.append("String_Node_Str" + wallet.getLastBlockSeenHeight() + "String_Node_Str" + wallet.getLastBlockSeenHash() + "String_Node_Str");
    report.append("String_Node_Str");
    for (final String db : application.databaseList()) report.append("String_Node_Str" + db);
    report.append("String_Node_Str");
    final File filesDir = application.getFilesDir();
    report.append("String_Node_Str" + filesDir + "String_Node_Str");
    appendDir(report, filesDir, 0);
}

Output:
     report.append("String_Node_Str" + Constants.NETWORK_PARAMETERS.getId() + "String_Node_Str");
-    final Wallet wallet = application.getWallet();
+    final Wallet wallet = viewModel.wallet.getValue();
     report.append("String_Node_Str" + wallet.isEncrypted() + "String_Node_Str");


Input:
private boolean evaluate_client_conformance_ssl(EjbIORConfigurationDescriptor iordesc, boolean ssl_used, X509Certificate[] certchain) {
    try {
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str");
        }
        boolean ssl_required = false;
        boolean ssl_supported = false;
        int ssl_target_requires = 0;
        int ssl_target_supports = 0;
        ssl_target_requires = this.getCtc().getTargetRequires(iordesc);
        ssl_target_supports = this.getCtc().getTargetSupports(iordesc);
        if (isSet(ssl_target_requires, Integrity.value) || isSet(ssl_target_requires, Confidentiality.value) || isSet(ssl_target_requires, EstablishTrustInClient.value))
            ssl_required = true;
        else
            ssl_required = false;
        if (ssl_target_supports != 0)
            ssl_supported = true;
        else
            ssl_supported = false;
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + isSet(ssl_target_requires, Integrity.value) + "String_Node_Str" + isSet(ssl_target_requires, Confidentiality.value) + "String_Node_Str" + isSet(ssl_target_requires, EstablishTrustInClient.value) + "String_Node_Str" + ssl_required + "String_Node_Str" + ssl_supported + "String_Node_Str" + ssl_used);
        }
        if (ssl_used) {
            if (!(ssl_required || ssl_supported))
                return false;
        } else {
            if (ssl_required)
                return false;
        }
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + certchain + "String_Node_Str" + isSet(ssl_target_requires, EstablishTrustInClient.value) + "String_Node_Str" + isSet(ssl_target_supports, EstablishTrustInClient.value));
        }
        if (certchain != null) {
            if (!(isSet(ssl_target_requires, EstablishTrustInClient.value) || isSet(ssl_target_supports, EstablishTrustInClient.value)))
                return false;
        } else {
            if (isSet(ssl_target_requires, EstablishTrustInClient.value))
                return false;
        }
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str");
        }
        return true;
    } finally {
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, "String_Node_Str");
        }
    }
}

Output:
         if (_logger.isLoggable(Level.FINE)) {
-            _logger.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + certchain + "String_Node_Str" + isSet(ssl_target_requires, EstablishTrustInClient.value) + "String_Node_Str" + isSet(ssl_target_supports, EstablishTrustInClient.value));
+            _logger.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + isSet(ssl_target_requires, EstablishTrustInClient.value) + "String_Node_Str" + isSet(ssl_target_supports, EstablishTrustInClient.value));
         }


Input:
public Please onEvent(BluetoothEnablerEvent e) {
    if (e.nextStage() == Stage.BLUETOOTH) {
        return Please.doNext().withImplicitActivityResultHandling();
    } else if (e.nextStage() == Stage.LOCATION_PERMISSION) {
        if (e.status() == Status.ALREADY_ENABLED || e.status() == Status.ENABLED) {
            if (!m_bleMngr.isLocationEnabledForScanning_byRuntimePermissions() && !m_bleMngr.isLocationEnabledForScanning_byOsServices()) {
                return Please.doNext().withImplicitActivityResultHandling().withDialog("String_Node_Str");
            } else if (!m_bleMngr.isLocationEnabledForScanning_byRuntimePermissions()) {
                return Please.doNext().withImplicitActivityResultHandling().withDialog("String_Node_Str");
            } else if (!m_bleMngr.isLocationEnabledForScanning_byOsServices()) {
                return Please.doNext().withImplicitActivityResultHandling().withDialog("String_Node_Str");
            } else {
                return Please.stop();
            }
        } else if (e.status() == Status.CANCELLED_BY_DIALOG || e.status() == Status.CANCELLED_BY_INTENT) {
            return Please.stop();
        }
    } else if (e.nextStage() == Stage.LOCATION_SERVICES && e.stage() != Stage.LOCATION_SERVICES) {
        if (e.status() == Status.ALREADY_ENABLED || e.status() == Status.ENABLED) {
            return Please.doNext().withImplicitActivityResultHandling();
        } else if (e.status() == Status.CANCELLED_BY_DIALOG || e.status() == Status.CANCELLED_BY_INTENT) {
            return Please.stop();
        }
    } else if (e.stage() == Stage.LOCATION_SERVICES) {
        return Please.stop();
    }
    return Please.doNext();
}

Output:
         if (e.status() == Status.ALREADY_ENABLED || e.status() == Status.ENABLED) {
-            if (!m_bleMngr.isLocationEnabledForScanning_byRuntimePermissions() && !m_bleMngr.isLocationEnabledForScanning_byOsServices()) {
+            if (!e.isEnabled(Stage.LOCATION_SERVICES) && !e.isEnabled(Stage.LOCATION_PERMISSION)) {
                 return Please.doNext().withImplicitActivityResultHandling().withDialog("String_Node_Str");


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == Constants.REQUEST_CODE_PATCH_CAMERA || requestCode == Constants.REQUEST_CODE_VIEW_CAMERA) {
        if (resultCode == Constants.RESULT_TRUE) {
            new Handler().postDelayed(new Runnable() {
                public void run() {
                    CustomSnackbar.showLong(VideoActivity.this, R.string.patch_success);
                }
            }, 1000);
            startPlay();
        } else if (resultCode == Constants.RESULT_FALSE) {
            startPlay();
        }
    } else {
        if (resultCode == Constants.RESULT_DELETED) {
            setResult(Constants.RESULT_TRUE);
            finish();
        } else if (resultCode == Constants.RESULT_TRANSFERRED) {
            setResult(Constants.RESULT_TRANSFERRED);
            finish();
        } else if (resultCode == Constants.RESULT_ACCESS_REMOVED) {
            setResult(Constants.RESULT_ACCESS_REMOVED);
            finish();
        } else if (resultCode == Constants.RESULT_NO_ACCESS) {
            setResult(Constants.RESULT_NO_ACCESS);
            finish();
        } else {
            startPlay();
        }
    }
}

Output:
             startPlay();
-        }
-    } else {
-        if (resultCode == Constants.RESULT_DELETED) {
+        } else if (resultCode == Constants.RESULT_DELETED) {
             setResult(Constants.RESULT_TRUE);


Input:
private boolean doMongoUpload(SharedPreferences prefs, List<BgReading> glucoseDataSets, List<Calibration> meterRecords, List<Calibration> calRecords) {
    SimpleDateFormat format = new SimpleDateFormat("String_Node_Str");
    format.setTimeZone(TimeZone.getDefault());
    String dbURI = prefs.getString("String_Node_Str", null);
    String collectionName = prefs.getString("String_Node_Str", null);
    String dsCollectionName = prefs.getString("String_Node_Str", "String_Node_Str");
    if (dbURI != null && collectionName != null) {
        try {
            MongoClientURI uri = new MongoClientURI(dbURI.trim());
            MongoClient client = new MongoClient(uri);
            DB db = client.getDB(uri.getDatabase());
            DBCollection dexcomData = db.getCollection(collectionName.trim());
            Log.i(TAG, "String_Node_Str" + glucoseDataSets.size());
            for (BgReading record : glucoseDataSets) {
                BasicDBObject testData = new BasicDBObject();
                testData.put("String_Node_Str", "String_Node_Str");
                testData.put("String_Node_Str", record.timestamp);
                testData.put("String_Node_Str", format.format(record.timestamp));
                testData.put("String_Node_Str", (int) record.calculated_value);
                testData.put("String_Node_Str", record.slopeName());
                testData.put("String_Node_Str", "String_Node_Str");
                testData.put("String_Node_Str", record.age_adjusted_raw_value);
                testData.put("String_Node_Str", record.age_adjusted_raw_value);
                testData.put("String_Node_Str", "String_Node_Str");
                dexcomData.update(testData, testData, true, false, WriteConcern.UNACKNOWLEDGED);
            }
            Log.i(TAG, "String_Node_Str" + meterRecords.size());
            for (Calibration meterRecord : meterRecords) {
                BasicDBObject testData = new BasicDBObject();
                testData.put("String_Node_Str", "String_Node_Str");
                testData.put("String_Node_Str", "String_Node_Str");
                testData.put("String_Node_Str", meterRecord.timestamp);
                testData.put("String_Node_Str", format.format(meterRecord.timestamp));
                testData.put("String_Node_Str", meterRecord.bg);
                dexcomData.update(testData, testData, true, false, WriteConcern.UNACKNOWLEDGED);
            }
            for (Calibration calRecord : calRecords) {
                BasicDBObject testData = new BasicDBObject();
                testData.put("String_Node_Str", "String_Node_Str");
                testData.put("String_Node_Str", calRecord.timestamp);
                testData.put("String_Node_Str", format.format(calRecord.timestamp));
                testData.put("String_Node_Str", (int) (calRecord.slope * 1000));
                testData.put("String_Node_Str", (int) calRecord.intercept);
                testData.put("String_Node_Str", 1000);
                testData.put("String_Node_Str", "String_Node_Str");
                dexcomData.update(testData, testData, true, false, WriteConcern.UNACKNOWLEDGED);
            }
            DBCollection dsCollection = db.getCollection(dsCollectionName);
            BasicDBObject devicestatus = new BasicDBObject();
            devicestatus.put("String_Node_Str", getBatteryLevel());
            devicestatus.put("String_Node_Str", new Date());
            dsCollection.insert(devicestatus, WriteConcern.UNACKNOWLEDGED);
            client.close();
            return true;
        } catch (Exception e) {
            Log.e(TAG, "String_Node_Str", e);
        }
    }
    return false;
}

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


Input:
public void disconnect() {
    ID groupID = getConnectedID();
    debug("String_Node_Str" + groupID + "String_Node_Str");
    fireContainerEvent(new ContainerDisconnectingEvent(this.getID(), groupID));
    synchronized (connectLock) {
        if (isConnected()) {
            synchronized (connection) {
                try {
                    connection.sendSynch(groupID, serializeObject(ContainerMessage.createLeaveGroupMessage(getID(), groupID, getNextSequenceNumber(), getLeaveData(groupID))));
                } catch (Exception e) {
                }
                synchronized (getGroupMembershipLock()) {
                    memberLeave(groupID, connection);
                }
            }
        }
        connectionState = UNCONNECTED;
        connection = null;
        remoteServerID = null;
    }
    fireContainerEvent(new ContainerDisconnectedEvent(this.getID(), groupID));
}

Output:
     fireContainerEvent(new ContainerDisconnectingEvent(this.getID(), groupID));
-    synchronized (connectLock) {
+    synchronized (getConnectLock()) {
         if (isConnected()) {


Input:
private void checkLogPartitionKey(Set<String> problemKeys) {
    if (!isValidPartitionKey(cConf.get(Constants.Logging.LOG_PUBLISH_PARTITION_KEY).toUpperCase())) {
        problemKeys.add(Constants.Logging.LOG_PUBLISH_PARTITION_KEY);
    }
}

Output:
 private void checkLogPartitionKey(Set<String> problemKeys) {
-    if (!isValidPartitionKey(cConf.get(Constants.Logging.LOG_PUBLISH_PARTITION_KEY).toUpperCase())) {
+    if (!isValidPartitionKey(cConf.get(Constants.Logging.LOG_PUBLISH_PARTITION_KEY))) {
         problemKeys.add(Constants.Logging.LOG_PUBLISH_PARTITION_KEY);


Input:
private void logFragmentLoaded(int fragment) {
    String logGroup = (fragment == leftoversFragment()) ? LwmLabels.LEFTOVERS_DOWNLOAD : LwmLabels.downloadGroup(fragment);
    logEventProgress(logGroup, LwmLabels.END, fragment, null);
}

Output:
 private void logFragmentLoaded(int fragment) {
-    String logGroup = (fragment == leftoversFragment()) ? LwmLabels.LEFTOVERS_DOWNLOAD : LwmLabels.downloadGroup(fragment);
+    String logGroup = downloadGroup(fragment);
     logEventProgress(logGroup, LwmLabels.END, fragment, null);


Input:
public void unpair() {
    synchronized (workQueue) {
        boolean processNow = false;
        Iterator<BluetoothJob> it = workQueue.iterator();
        while (it.hasNext()) {
            BluetoothJob job = it.next();
            if (job.cachedDevice.mDevice.equals(this.mDevice)) {
                it.remove();
                if (job.timeSent != 0) {
                    processNow = true;
                }
            }
        }
        if (processNow) {
            processCommands();
        }
    }
    switch(getBondState()) {
        case BluetoothDevice.BOND_BONDED:
            mDevice.removeBond();
            break;
        case BluetoothDevice.BOND_BONDING:
            mDevice.cancelBondProcess();
            break;
    }
}

Output:
 public void unpair() {
-    synchronized (workQueue) {
-        boolean processNow = false;
-        Iterator<BluetoothJob> it = workQueue.iterator();
-        while (it.hasNext()) {
-            BluetoothJob job = it.next();
-            if (job.cachedDevice.mDevice.equals(this.mDevice)) {
-                it.remove();
-                if (job.timeSent != 0) {
-                    processNow = true;
-                }
-            }
-        }
-        if (processNow) {
-            processCommands();
-        }
+    disconnect();
+    int state = getBondState();
+    if (state == BluetoothDevice.BOND_BONDING) {
+        mDevice.cancelBondProcess();
     }


Input:
public long getFieldLong() {
    return fieldLong;
}

Output:
 public long getFieldLong() {
-    return fieldLong;
+    return realmGetter$fieldLong();
 }


Input:
public static void transformTask(TaskLink tLink, Memory memory) {
    CompoundTerm content = (CompoundTerm) memory.getCurrentTask().getContent().clone();
    short[] indices = tLink.getIndices();
    Term inh = null;
    if ((indices.length == 2) || (content instanceof Inheritance)) {
        inh = content;
    } else if (indices.length == 3) {
        inh = content.componentAt(indices[0]);
    } else if (indices.length == 4) {
        Term component = content.componentAt(indices[0]);
        if ((component instanceof Conjunction) && (((content instanceof Implication) && (indices[0] == 0)) || (content instanceof Equivalence))) {
            inh = ((CompoundTerm) component).componentAt(indices[1]);
        } else {
            return;
        }
    }
    if (inh instanceof Inheritance) {
        StructuralRules.transformProductImage((Inheritance) inh, content, indices, memory);
    }
}

Output:
     CompoundTerm content = (CompoundTerm) memory.getCurrentTask().getContent().clone();
-    short[] indices = tLink.getIndices();
+    short[] indices = tLink.index;
     Term inh = null;


Input:
public void configure(ActionsManager manager, PresentationElement... elements) {
    ActionsCategory category = (ActionsCategory) manager.getActionFor(MDKPlugin.MAIN_TOOLBAR_CATEGORY_NAME);
    if (category == null) {
        category = new MDActionsCategory(MDKPlugin.MAIN_TOOLBAR_CATEGORY_NAME, MDKPlugin.MAIN_TOOLBAR_CATEGORY_NAME, null, ActionsGroups.APPLICATION_RELATED);
        category.setNested(true);
    }
    manager.addCategory(category);
    category.addAction(new OclQueryAction());
    category.addAction(new ValidateConstraintsAction());
}

Output:
 public void configure(ActionsManager manager, PresentationElement... elements) {
-    ActionsCategory category = (ActionsCategory) manager.getActionFor(MDKPlugin.MAIN_TOOLBAR_CATEGORY_NAME);
+    ActionsCategory category = manager.getCategory(MDKPlugin.MAIN_TOOLBAR_CATEGORY_NAME);
     if (category == null) {


Input:
public boolean useItem(int slot) {
    if (fakePlayer == null) {
        fakePlayer = new EntityFakePlayer(worldObj, this, xCoord, yCoord, zCoord, worldObj.getBlockMetadata(xCoord, yCoord, zCoord));
    }
    Item item = this.getStackInSlot(slot).getItem();
    int i = xCoord, j = yCoord, k = zCoord, meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
    i = AdvancedDispensersLib.INSTANCE.getI(meta, i);
    j = AdvancedDispensersLib.INSTANCE.getJ(meta, j);
    k = AdvancedDispensersLib.INSTANCE.getK(meta, k);
    Block user = worldObj.getBlock(xCoord, yCoord, zCoord);
    int userMeta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
    AxisAlignedBB rect = null;
    int deltaX = xCoord - i, deltaY = yCoord - j, deltaZ = zCoord - k;
    if (deltaX > 0 || deltaY > 0 || deltaZ > 0) {
        rect = AxisAlignedBB.getBoundingBox(xCoord - deltaX * 4 - 0.1, yCoord - deltaY * 4 - 0.1, zCoord - deltaZ * 4 - 0.1, xCoord + 0.1, yCoord + 0.1, zCoord + 0.1);
    } else {
        rect = AxisAlignedBB.getBoundingBox(xCoord - 0.1, yCoord - 0.1, zCoord - 0.1, xCoord + deltaX * 4 + 0.1, yCoord + deltaY * 4 + 0.1, zCoord + deltaZ * 4 + 0.1);
    }
    List<EntityLivingBase> near = worldObj.getEntitiesWithinAABB(EntitySheep.class, rect);
    for (EntityLivingBase base : near) {
        if (item.itemInteractionForEntity(this.getStackInSlot(slot), fakePlayer, base)) {
            return true;
        }
    }
    if (item.onItemUseFirst(this.getStackInSlot(slot), fakePlayer, worldObj, i, j - 1, k, 1, 0.5f, 0.5f, 0.5f)) {
    } else if (item.onItemUse(this.getStackInSlot(slot), fakePlayer, worldObj, i, j - 1, k, 1, 0.5f, 0.5f, 0.5f)) {
    } else {
        this.setInventorySlotContents(slot, item.onItemRightClick(this.getStackInSlot(slot), worldObj, fakePlayer));
    }
    AdvancedDispensersLib.INSTANCE.deleteEmptyStacks(this);
    return true;
}

Output:
     if (deltaX > 0 || deltaY > 0 || deltaZ > 0) {
-        rect = AxisAlignedBB.getBoundingBox(xCoord - deltaX * 4 - 0.1, yCoord - deltaY * 4 - 0.1, zCoord - deltaZ * 4 - 0.1, xCoord + 0.1, yCoord + 0.1, zCoord + 0.1);
+        rect = AxisAlignedBB.getBoundingBox(xCoord - deltaX * 4 - 0.5, yCoord - deltaY * 4 - 0.5, zCoord - deltaZ * 4 - 0.5, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5);
     } else {


Input:
public void testFailOnSecondErrorXMLEventWriter() throws Exception {
    CustomErrorValidationEventHandler eventHandler = new CustomErrorValidationEventHandler();
    marshaller.setEventHandler(eventHandler);
    try {
        XMLOutputFactory xof = XMLOutputFactory.newInstance();
        XMLEventWriter xmlEventWriter = xof.createXMLEventWriter(new ByteArrayOutputStream());
        marshaller.marshal(employee, xmlEventWriter);
    } catch (MarshalException ex) {
        assertEquals(2, eventHandler.getErrorCount());
        return;
    } catch (XMLStreamException e) {
        return;
    } catch (Exception e) {
        throw e;
    }
    fail("String_Node_Str");
}

Output:
     try {
-        XMLOutputFactory xof = XMLOutputFactory.newInstance();
-        XMLEventWriter xmlEventWriter = xof.createXMLEventWriter(new ByteArrayOutputStream());
+        if (null == XML_OUTPUT_FACTORY) {
+            return;
+        }
+        XMLEventWriter xmlEventWriter = XML_OUTPUT_FACTORY.createXMLEventWriter(new ByteArrayOutputStream());
         marshaller.marshal(employee, xmlEventWriter);


Input:
static ImageInputStream checkURL(final URL url) throws FileNotFoundException, UnsupportedEncodingException, IOException {
    ensureNotNull("String_Node_Str", url);
    final String protocol = url.getProtocol();
    if (protocol.equalsIgnoreCase("String_Node_Str"))
        return new FileImageInputStream(new File(URLDecoder.decode(url.getFile(), "String_Node_Str")));
    else if (protocol.equalsIgnoreCase("String_Node_Str"))
        return new MemoryCacheImageInputStream(url.openStream());
    return null;
}

Output:
     if (protocol.equalsIgnoreCase("String_Node_Str"))
-        return new FileImageInputStream(new File(URLDecoder.decode(url.getFile(), "String_Node_Str")));
+        return new FileImageInputStream(Utilities.urlToFile(url));
     else if (protocol.equalsIgnoreCase("String_Node_Str"))


Input:
private void ghostMode() {
    if (ghostTime++ > Config.GHOST_TIME) {
        ghostTime = 0;
        snake.reset();
        ghostMode = false;
    } else {
        snake.setGhostMode();
    }
}

Output:
         snake.reset();
-        ghostMode = false;
+        isGhostMode = false;
     } else {


Input:
private static boolean walkChildrenImpl(final PsiScopeProcessor processor, final PsiElement entrance, boolean walkParent, PsiElement maxScope, ResolveState state, Set<String> typeVisited) {
    ProgressIndicatorProvider.checkCanceled();
    if (entrance instanceof DotNetTypeDeclaration) {
        DotNetGenericExtractor extractor = state.get(CSharpResolveUtil.EXTRACTOR_KEY);
        val typeDeclaration = (DotNetTypeDeclaration) entrance;
        val superTypes = new SmartList<DotNetTypeRef>();
        if (typeDeclaration.hasModifier(CSharpModifier.PARTIAL)) {
            val types = DotNetPsiFacade.getInstance(entrance.getProject()).findTypes(typeDeclaration.getPresentableQName(), entrance.getResolveScope(), typeDeclaration.getGenericParametersCount());
            for (val type : types) {
                if (!type.hasModifier(CSharpModifier.PARTIAL)) {
                    continue;
                }
                if (!processTypeDeclaration(processor, type, state, superTypes, extractor, typeVisited)) {
                    return false;
                }
            }
        } else {
            if (!processTypeDeclaration(processor, typeDeclaration, state, superTypes, extractor, typeVisited)) {
                return false;
            }
        }
        for (DotNetTypeRef dotNetTypeRef : superTypes) {
            PsiElement resolve = dotNetTypeRef.resolve(entrance);
            if (resolve != null && !resolve.isEquivalentTo(entrance)) {
                DotNetGenericExtractor genericExtractor = dotNetTypeRef.getGenericExtractor(resolve, entrance);
                ResolveState newState = ResolveState.initial().put(EXTRACTOR_KEY, genericExtractor);
                if (!walkChildrenImpl(processor, resolve, false, maxScope, newState, typeVisited)) {
                    return false;
                }
            }
        }
        if (walkParent) {
            if (!walkChildrenImpl(processor, entrance.getParent(), walkParent, maxScope, state, typeVisited)) {
                return false;
            }
        }
    } else if (entrance instanceof DotNetGenericParameter) {
        DotNetGenericParameterList parameterList = (DotNetGenericParameterList) entrance.getParent();
        PsiElement parent = parameterList.getParent();
        if (!(parent instanceof CSharpGenericConstraintOwner)) {
            return true;
        }
        val constraint = CSharpGenericConstraintOwnerUtil.forParameter((CSharpGenericConstraintOwner) parent, (DotNetGenericParameter) entrance);
        if (constraint == null) {
            return true;
        }
        val superTypes = new SmartList<DotNetTypeRef>();
        for (CSharpGenericConstraintValue value : constraint.getGenericConstraintValues()) {
            if (value instanceof CSharpGenericConstraintTypeValue) {
                DotNetTypeRef typeRef = ((CSharpGenericConstraintTypeValue) value).toTypeRef();
                superTypes.add(typeRef);
            } else if (value instanceof CSharpGenericConstraintKeywordValue) {
                if (((CSharpGenericConstraintKeywordValue) value).getKeywordElementType() == CSharpTokens.STRUCT_KEYWORD) {
                    superTypes.add(new DotNetTypeRefByQName(DotNetTypes.System_ValueType, CSharpTransform.INSTANCE));
                } else if (((CSharpGenericConstraintKeywordValue) value).getKeywordElementType() == CSharpTokens.CLASS_KEYWORD) {
                    superTypes.add(CSharpNativeTypeRef.OBJECT);
                }
            }
        }
        for (DotNetTypeRef dotNetTypeRef : superTypes) {
            PsiElement resolve = dotNetTypeRef.resolve(entrance);
            if (resolve != null && resolve != entrance) {
                DotNetGenericExtractor genericExtractor = dotNetTypeRef.getGenericExtractor(resolve, entrance);
                ResolveState newState = ResolveState.initial().put(EXTRACTOR_KEY, genericExtractor);
                if (!walkChildrenImpl(processor, resolve, false, maxScope, newState, typeVisited)) {
                    return false;
                }
            }
        }
    } else if (entrance instanceof CSharpNamespaceAsElement) {
        if (!entrance.processDeclarations(processor, state, maxScope, entrance)) {
            return false;
        }
        String pQName = CSharpNamespaceHelper.getNamespaceForIndexing(((CSharpNamespaceAsElement) entrance).getPresentableParentQName());
        if (Comparing.equal(pQName, CSharpNamespaceHelper.ROOT)) {
            return true;
        }
        if (walkParent) {
            CSharpNamespaceAsElement parentNamespace = new CSharpNamespaceAsElement(entrance.getProject(), pQName, entrance.getResolveScope());
            if (!walkChildrenImpl(processor, parentNamespace, walkParent, maxScope, state, typeVisited)) {
                return false;
            }
        }
    } else if (entrance instanceof DotNetNamespaceDeclaration) {
        String presentableQName = ((DotNetNamespaceDeclaration) entrance).getPresentableQName();
        if (presentableQName == null) {
            return true;
        }
        if (walkParent) {
            CSharpNamespaceAsElement parentNamespace = new CSharpNamespaceAsElement(entrance.getProject(), presentableQName, entrance.getResolveScope());
            if (!walkChildrenImpl(processor, parentNamespace, walkParent, maxScope, state, typeVisited)) {
                return false;
            }
        }
    } else if (entrance instanceof PsiFile) {
        CSharpNamespaceAsElement parentNamespace = new CSharpNamespaceAsElement(entrance.getProject(), CSharpNamespaceHelper.ROOT, entrance.getResolveScope());
        return walkChildrenImpl(processor, parentNamespace, walkParent, maxScope, state, typeVisited);
    }
    PsiFile psiFile = state.get(CONTAINS_FILE_KEY);
    return psiFile == null || walkChildrenImpl(processor, psiFile, walkParent, maxScope, state, typeVisited);
}

Output:
         if (typeDeclaration.hasModifier(CSharpModifier.PARTIAL)) {
-            val types = DotNetPsiFacade.getInstance(entrance.getProject()).findTypes(typeDeclaration.getPresentableQName(), entrance.getResolveScope(), typeDeclaration.getGenericParametersCount());
+            String vmQName = typeDeclaration.getVmQName();
+            val types = CSharpPsiSearcher.getInstance(entrance.getProject()).findTypes(vmQName, entrance.getResolveScope());
             for (val type : types) {


Input:
private List<PropertyContainer> constructPath(boolean includeNodes, boolean includeRels) {
    LinkedList<PropertyContainer> path = new LinkedList<PropertyContainer>();
    Relationship rel = firstSet.get(matchNode);
    Node currentNode = matchNode;
    while (rel != NULL_REL && rel != null) {
        if (includeRels) {
            path.addFirst(rel);
        }
        currentNode = rel.getOtherNode(currentNode);
        if (includeNodes && !currentNode.equals(matchNode) && !currentNode.equals(startNode)) {
            path.addFirst(currentNode);
        }
        rel = firstSet.get(currentNode);
    }
    if (includeNodes) {
        path.addFirst(startNode);
        if (!matchNode.equals(startNode)) {
            path.addLast(matchNode);
        }
    }
    rel = secondSet.get(matchNode);
    currentNode = matchNode;
    while (rel != NULL_REL && rel != null) {
        if (includeRels) {
            path.addLast(rel);
        }
        currentNode = rel.getOtherNode(currentNode);
        if (includeNodes && !currentNode.equals(endNode)) {
            path.addLast(currentNode);
        }
        rel = firstSet.get(currentNode);
    }
    if (includeNodes && !endNode.equals(matchNode)) {
        path.addLast(endNode);
    }
    return path;
}

Output:
         }
-        rel = firstSet.get(currentNode);
+        rel = secondSet.get(currentNode);
     }


Input:
public void lowlightCurrentNode() {
    if (m_currentNode != null) {
        HighlightNode.removeHighlight(m_currentNode);
    }
}

Output:
     if (m_currentNode != null) {
-        HighlightNode.removeHighlight(m_currentNode);
+        EventThreadQueuerJavaFXImpl.invokeAndWait("String_Node_Str", new Callable<Void>() {
+            public Void call() throws Exception {
+                HighlightNode.removeHighlight(m_currentNode);
+                return null;
+            }
+        });
     }


Input:
public boolean onContextItemSelected(MenuItem item) {
    final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
    if (info.position <= 0) {
        return false;
    }
    final Object selectedObject = lv.getAdapter().getItem(info.position);
    if (!(selectedObject instanceof RedditCommentListItem) || !((RedditCommentListItem) selectedObject).isComment()) {
        return false;
    }
    final Action action = Action.values()[item.getItemId()];
    final RedditPreparedComment comment = ((RedditCommentListItem) selectedObject).asComment();
    switch(action) {
        case UPVOTE:
            comment.action(getSupportActivity(), RedditAPI.RedditAction.UPVOTE);
            break;
        case DOWNVOTE:
            comment.action(getSupportActivity(), RedditAPI.RedditAction.DOWNVOTE);
            break;
        case UNVOTE:
            comment.action(getSupportActivity(), RedditAPI.RedditAction.UNVOTE);
            break;
        case SAVE:
            comment.action(getSupportActivity(), RedditAPI.RedditAction.SAVE);
            break;
        case UNSAVE:
            comment.action(getSupportActivity(), RedditAPI.RedditAction.UNSAVE);
            break;
        case REPORT:
            new AlertDialog.Builder(getSupportActivity()).setTitle(R.string.action_report).setMessage(R.string.action_report_sure).setPositiveButton(R.string.action_report, new DialogInterface.OnClickListener() {
                public void onClick(final DialogInterface dialog, final int which) {
                    comment.action(getSupportActivity(), RedditAPI.RedditAction.REPORT);
                }
            }).setNegativeButton(R.string.dialog_cancel, null).show();
            break;
        case REPLY:
            {
                final Intent intent = new Intent(getSupportActivity(), CommentReplyActivity.class);
                intent.putExtra("String_Node_Str", comment.idAndType);
                startActivity(intent);
                break;
            }
        case EDIT:
            {
                final Intent intent = new Intent(getSupportActivity(), CommentEditActivity.class);
                intent.putExtra("String_Node_Str", comment.idAndType);
                intent.putExtra("String_Node_Str", StringEscapeUtils.unescapeHtml4(comment.src.body));
                startActivity(intent);
                break;
            }
        case COMMENT_LINKS:
            final HashSet<String> linksInComment = comment.computeAllLinks();
            if (linksInComment.isEmpty()) {
                General.quickToast(getSupportActivity(), R.string.error_toast_no_urls_in_comment);
            } else {
                final String[] linksArr = linksInComment.toArray(new String[linksInComment.size()]);
                final AlertDialog.Builder builder = new AlertDialog.Builder(getSupportActivity());
                builder.setItems(linksArr, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        LinkHandler.onLinkClicked(getSupportActivity(), linksArr[which], false);
                        dialog.dismiss();
                    }
                });
                final AlertDialog alert = builder.create();
                alert.setTitle(R.string.action_comment_links);
                alert.setCanceledOnTouchOutside(true);
                alert.show();
            }
            break;
        case SHARE:
            final Intent mailer = new Intent(Intent.ACTION_SEND);
            mailer.setType("String_Node_Str");
            mailer.putExtra(Intent.EXTRA_SUBJECT, "String_Node_Str" + comment.src.author + "String_Node_Str");
            mailer.putExtra(Intent.EXTRA_TEXT, StringEscapeUtils.unescapeHtml4(comment.src.body));
            startActivityForResult(Intent.createChooser(mailer, getSupportActivity().getString(R.string.action_share)), 1);
            break;
        case COPY:
            ClipboardManager manager = (ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
            manager.setText(StringEscapeUtils.unescapeHtml4(comment.src.body));
            break;
        case COLLAPSE:
            if (comment.getBoundView() != null)
                handleCommentVisibilityToggle(comment.getBoundView());
            break;
        case USER_PROFILE:
            LinkHandler.onLinkClicked(getSupportActivity(), new UserProfileURL(comment.src.author).toString());
            break;
        case PROPERTIES:
            CommentPropertiesDialog.newInstance(comment.src).show(getSupportActivity());
            break;
        case GO_TO_COMMENT:
            {
                PostCommentListingURL url = new PostCommentListingURL(null, comment.src.link_id, comment.idAlone, null, null, null);
                LinkHandler.onLinkClicked(getSupportActivity(), url.toString());
                break;
            }
        case CONTEXT:
            {
                PostCommentListingURL url = new PostCommentListingURL(null, comment.src.link_id, comment.idAlone, 3, null, null);
                LinkHandler.onLinkClicked(getSupportActivity(), url.toString());
                break;
            }
    }
    return true;
}

Output:
         case COLLAPSE:
-            if (comment.getBoundView() != null)
+            if (comment.getBoundView() != null) {
                 handleCommentVisibilityToggle(comment.getBoundView());


Input:
public void updateBlockBreakSpeed(PlayerEvent.BreakSpeed event) {
    ItemStack equipped = event.entityPlayer.getCurrentEquippedItem();
    if (equipped != null && equipped.getItem() != null && equipped.getItem() instanceof ItemSteamDrill && event.block != null && event.block.getHarvestTool(event.metadata) != null && event.block.getHarvestTool(event.metadata).equals("String_Node_Str")) {
        ItemSteamDrill drill = (ItemSteamDrill) equipped.getItem();
        if (UtilSteamTool.hasUpgrade(equipped, SteamcraftItems.bigDrill) && drill.isWound(event.entityPlayer)) {
            float hardness = event.block.getBlockHardness(event.entityPlayer.worldObj, event.x, event.y, event.z);
            event.newSpeed = event.originalSpeed * ((hardness * 1.5F) / 8);
        }
    }
}

Output:
     ItemStack equipped = event.entityPlayer.getCurrentEquippedItem();
-    if (equipped != null && equipped.getItem() != null && equipped.getItem() instanceof ItemSteamDrill && event.block != null && event.block.getHarvestTool(event.metadata) != null && event.block.getHarvestTool(event.metadata).equals("String_Node_Str")) {
-        ItemSteamDrill drill = (ItemSteamDrill) equipped.getItem();
-        if (UtilSteamTool.hasUpgrade(equipped, SteamcraftItems.bigDrill) && drill.isWound(event.entityPlayer)) {
-            float hardness = event.block.getBlockHardness(event.entityPlayer.worldObj, event.x, event.y, event.z);
-            event.newSpeed = event.originalSpeed * ((hardness * 1.5F) / 8);
+    Block block = event.block;
+    int meta = event.metadata;
+    EntityPlayer player = event.entityPlayer;
+    if (equipped != null && equipped.getItem() != null) {
+        if (block != null) {
+            if (block.getHarvestTool(meta) != null && block.getHarvestTool(meta).equals("String_Node_Str")) {
+                if (equipped.getItem() instanceof ItemSteamDrill) {
+                    ItemSteamDrill drill = (ItemSteamDrill) equipped.getItem();
+                    if (UtilSteamTool.hasUpgrade(equipped, SteamcraftItems.bigDrill) && drill.isWound(player)) {
+                        float hardness = block.getBlockHardness(player.worldObj, event.x, event.y, event.z);
+                        event.newSpeed = event.originalSpeed * ((hardness * 1.5F) / 8);
+                    }
+                }
+            } else if (equipped.getItem() instanceof ItemSteamAxe) {
+                ItemSteamAxe axe = (ItemSteamAxe) equipped.getItem();
+                if (UtilSteamTool.hasUpgrade(equipped, SteamcraftItems.leafBlower)) {
+                    event.newSpeed = event.originalSpeed / 5F;
+                }
+            }
         }


Input:
public void parsesComplexMemberJson() throws Exception {
    GsonDocumentReader<Member1> _reader = new GsonDocumentReader<Member1>(new JsonDocumentDefinition<Member1>() {
        {
            registerConverters(new ThreadSafeDateStringConverter("String_Node_Str"));
            mapping(Member1.class).with(property("String_Node_Str"), property("String_Node_Str"), object("String_Node_Str", Member1.Person.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), object("String_Node_Str", Member1.Social.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), property("String_Node_Str"));
        }
    });
    Member1 _result = _reader.read(new InputStreamReader(getClass().getResourceAsStream("String_Node_Str")));
    Assert.assertNotNull(_result);
    Assert.assertEquals("String_Node_Str", _result.getId());
    Assert.assertEquals(new SimpleDateFormat("String_Node_Str").parse("String_Node_Str"), _result.getRegistrationDate());
    Member1.Person _person = _result.getPerson();
    Assert.assertNotNull(_person);
    Assert.assertEquals("String_Node_Str", _person.getId());
    Assert.assertEquals("String_Node_Str", _person.getFirstname());
    Assert.assertEquals("String_Node_Str", _person.getLastname());
    Assert.assertNull(_person.getEmail());
    Assert.assertNull(_person.getTitle());
    Member1.Social _social = _result.getSocial();
    Assert.assertNotNull(_social);
    Assert.assertEquals("String_Node_Str", _social.getProviderId());
    Assert.assertEquals("String_Node_Str", _social.getProviderUserId());
    Assert.assertEquals("String_Node_Str", _social.getImageUrl());
    Assert.assertEquals(50, _result.getPointsAccrued());
}

Output:
             registerConverters(new ThreadSafeDateStringConverter("String_Node_Str"));
-            mapping(Member1.class).with(property("String_Node_Str"), property("String_Node_Str"), object("String_Node_Str", Member1.Person.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), object("String_Node_Str", Member1.Social.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), property("String_Node_Str"));
+            mapping(Member1.class).with(property("String_Node_Str"), property("String_Node_Str"), object("String_Node_Str", Member1.Person.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), object("String_Node_Str", Member1.Social.class).with(property("String_Node_Str"), property("String_Node_Str"), property("String_Node_Str")), number("String_Node_Str", Integer.class));
         }


Input:
private static String getComponentName(Object component) {
    if (component instanceof XSDElementDeclaration) {
        XSDElementDeclaration decl = (XSDElementDeclaration) component;
        return Messages.Util_34 + decl.getName() + Messages.Util_35;
    } else if (component instanceof XSDParticle) {
        XSDParticle particle = (XSDParticle) component;
        XSDTerm term = particle.getTerm();
        if (term instanceof XSDElementDeclaration) {
            return Messages.Util_36 + ((XSDElementDeclaration) term).getName() + Messages.Util_37;
        }
    } else if (component instanceof XSDComplexTypeDefinition) {
        XSDComplexTypeDefinition type = (XSDComplexTypeDefinition) component;
        return type.getName();
    } else if (component instanceof XSDSimpleTypeDefinition) {
        return Messages.Util_38 + ((XSDSimpleTypeDefinition) component).getName() + Messages.Util_39;
    } else if (component instanceof XSDIdentityConstraintDefinition) {
        XSDIdentityConstraintDefinition identify = (XSDIdentityConstraintDefinition) component;
        XSDConcreteComponent c = identify.getContainer();
        return Messages.Util_40 + identify.getName() + Messages.Util_41;
    } else if (component instanceof XSDXPathDefinition) {
        XSDXPathDefinition path = (XSDXPathDefinition) component;
        return Messages.Util_42 + path.getValue() + Messages.Util_43;
    }
    return null;
}

Output:
         XSDComplexTypeDefinition type = (XSDComplexTypeDefinition) component;
-        return type.getName();
+        return Messages.Util_36 + type.getName() + Messages.Util_37;
     } else if (component instanceof XSDSimpleTypeDefinition) {


Input:
public void buildBloomFilters() {
    this.bloomFilters = new CountingBloomFilter[tableDefinition.getAttributeList().size()];
    this.isBloomFilterEnabled = true;
    for (int i = 0; i < bloomFilters.length; i++) {
        bloomFilters[i] = new CountingBloomFilter(bloomFilterSize, bloomFilterHashFunction, Hash.MURMUR_HASH);
    }
    Connection con = null;
    Statement stmt = null;
    try {
        con = dataSource.getConnection();
        stmt = con.createStatement();
        String selectTableRowQuery = constructQuery(tableName, elementMappings.get(RDBMSEventTableConstants.EVENT_TABLE_GENERIC_RDBMS_SELECT_TABLE), null, null, null, null, null);
        ResultSet results = stmt.executeQuery(selectTableRowQuery);
        while (results.next()) {
            for (int i = 0; i < bloomFilters.length; i++) {
                switch(tableDefinition.getAttributeList().get(i).getType()) {
                    case INT:
                        bloomFilters[i].add(new Key(Integer.toString(results.getInt(i + 1)).getBytes()));
                        break;
                    case LONG:
                        bloomFilters[i].add(new Key(Long.toString(results.getLong(i + 1)).getBytes()));
                        break;
                    case FLOAT:
                        bloomFilters[i].add(new Key(Float.toString(results.getFloat(i + 1)).getBytes()));
                        break;
                    case DOUBLE:
                        bloomFilters[i].add(new Key(Double.toString(results.getDouble(i + 1)).getBytes()));
                        break;
                    case STRING:
                        bloomFilters[i].add(new Key(results.getString(i + 1).getBytes()));
                        break;
                    case BOOL:
                        bloomFilters[i].add(new Key(Boolean.toString(results.getBoolean(i + 1)).getBytes()));
                        break;
                }
            }
        }
        results.close();
    } catch (SQLException ex) {
        throw new ExecutionPlanRuntimeException("String_Node_Str" + ex.getMessage(), ex);
    } finally {
        cleanUpConnections(stmt, con);
    }
}

Output:
 public void buildBloomFilters() {
-    this.bloomFilters = new CountingBloomFilter[tableDefinition.getAttributeList().size()];
-    this.isBloomFilterEnabled = true;
+    CountingBloomFilter[] bloomFilters = new CountingBloomFilter[tableDefinition.getAttributeList().size()];
     for (int i = 0; i < bloomFilters.length; i++) {


Input:
public void run() {
    LOG.debug("String_Node_Str");
    int delayUntilNextDownload = 5;
    TimeUnit timeUnit = TimeUnit.SECONDS;
    final SortedSet<String> availableFilenames = device.getAvailableFilenames();
    if (availableFilenames == null) {
        LOG.debug("String_Node_Str");
        delayUntilNextDownload = 1;
        timeUnit = TimeUnit.MINUTES;
    } else if (availableFilenames.isEmpty()) {
        LOG.debug("String_Node_Str");
        delayUntilNextDownload = 1;
        timeUnit = TimeUnit.MINUTES;
    } else {
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str" + availableFilenames.size() + "String_Node_Str");
        }
        for (final String filename : availableFilenames) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("String_Node_Str" + filename + "String_Node_Str");
            }
            final DataFileStatus fileStatus = dataFileManager.getDataFileStatusOfAnyMatchingFile(filename);
            if (fileStatus == null) {
                if (!downloadFileFromDevice(filename)) {
                    delayUntilNextDownload = 1;
                    timeUnit = TimeUnit.MINUTES;
                }
            } else {
                switch(fileStatus) {
                    case WRITING:
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
                        }
                        break;
                    case DOWNLOADED:
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
                        }
                        break;
                    case UPLOADING:
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
                        }
                        break;
                    case UPLOADED:
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
                        }
                        eraseFileFromDevice(filename);
                        break;
                    case CORRUPT_DATA:
                        if (LOG.isInfoEnabled()) {
                            LOG.info("String_Node_Str" + filename + "String_Node_Str");
                        }
                        eraseFileFromDevice(filename);
                        break;
                    case INCORRECT_CHECKSUM:
                        if (LOG.isInfoEnabled()) {
                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
                        }
                        break;
                    default:
                        LOG.error("String_Node_Str" + fileStatus + "String_Node_Str");
                }
            }
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + delayUntilNextDownload + "String_Node_Str" + timeUnit + "String_Node_Str");
    }
    scheduleNextFileDownload(delayUntilNextDownload, timeUnit);
}

Output:
             }
-            final DataFileStatus fileStatus = dataFileManager.getDataFileStatusOfAnyMatchingFile(filename);
-            if (fileStatus == null) {
-                if (!downloadFileFromDevice(filename)) {
-                    delayUntilNextDownload = 1;
-                    timeUnit = TimeUnit.MINUTES;
-                }
-            } else {
-                switch(fileStatus) {
-                    case WRITING:
-                        if (LOG.isDebugEnabled()) {
-                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        break;
-                    case DOWNLOADED:
-                        if (LOG.isDebugEnabled()) {
-                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        break;
-                    case UPLOADING:
-                        if (LOG.isDebugEnabled()) {
-                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        break;
-                    case UPLOADED:
-                        if (LOG.isDebugEnabled()) {
-                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        eraseFileFromDevice(filename);
-                        break;
-                    case CORRUPT_DATA:
-                        if (LOG.isInfoEnabled()) {
-                            LOG.info("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        eraseFileFromDevice(filename);
-                        break;
-                    case INCORRECT_CHECKSUM:
-                        if (LOG.isInfoEnabled()) {
-                            LOG.debug("String_Node_Str" + filename + "String_Node_Str");
-                        }
-                        break;
-                    default:
-                        LOG.error("String_Node_Str" + fileStatus + "String_Node_Str");
-                }
+            final DataFileManager.ActionToPerformOnDeviceDataFile actionToPerformOnDeviceDataFile = dataFileManager.getActionToPerformOnDeviceDataFile(filename);
+            switch(actionToPerformOnDeviceDataFile) {
+                case NO_ACTION:
+                    if (LOG.isDebugEnabled()) {
+                        LOG.debug("String_Node_Str" + filename + "String_Node_Str");
+                    }
+                    break;
+                case DELETE_FROM_DEVICE:
+                    if (LOG.isDebugEnabled()) {
+                        LOG.debug("String_Node_Str" + filename + "String_Node_Str");
+                    }
+                    deleteFileFromDevice(filename);
+                    break;
+                case DOWNLOAD_FROM_DEVICE:
+                    if (!downloadFileFromDevice(filename)) {
+                        delayUntilNextDownload = 1;
+                        timeUnit = TimeUnit.MINUTES;
+                    }
+                    break;
+                default:
+                    LOG.error("String_Node_Str" + actionToPerformOnDeviceDataFile + "String_Node_Str");
             }


Input:
public static void appendDrop(final StringBuilder builder, final String str, final int maxWidth) {
    appendAbbreviate(builder, str, maxWidth);
}

Output:
 public static void appendDrop(final StringBuilder builder, final String str, final int maxWidth) {
-    appendAbbreviate(builder, str, maxWidth);
+    com.navercorp.pinpoint.common.util.StringUtils.appendAbbreviate(builder, str, maxWidth);
 }


Input:
public void actionPerformed(ActionEvent e) {
    if (!myMasked) {
        Font base = (Font) myComboBox.getSelectedItem();
        Float f = (Float) (myFontSize.getSelectedItem());
        int size = (int) f.intValue();
        int style = 0;
        if (myBold.isSelected()) {
            style |= Font.BOLD;
        }
        if (myItalic.isSelected()) {
            style |= Font.ITALIC;
        }
        Font value = base.deriveFont(style, size);
        Object validValue = validateValue(value, null);
        if (validValue != value) {
            updateDisplay();
        }
        if (updateValue(validValue)) {
            updateDisplay();
        }
    }
}

Output:
         Font base = (Font) myComboBox.getSelectedItem();
-        Float f = (Float) (myFontSize.getSelectedItem());
-        int size = (int) f.intValue();
+        int size = (int) ((Number) (myFontSize.getSelectedItem())).intValue();
         int style = 0;


Input:
public boolean addPlayertoTeam(final UUID playerUUID, final UUID teamLeader) {
    if (!plugin.getPlayers().setJoinTeam(playerUUID, teamLeader, plugin.getPlayers().getIslandLocation(teamLeader))) {
        return false;
    }
    if (!playerUUID.equals(teamLeader)) {
        plugin.getPlayers().clearHomeLocations(playerUUID);
        if (plugin.getPlayers().getHomeLocation(teamLeader, 1) != null) {
            plugin.getPlayers().setHomeLocation(playerUUID, plugin.getPlayers().getHomeLocation(teamLeader));
        } else {
            plugin.getPlayers().setHomeLocation(playerUUID, plugin.getPlayers().getIslandLocation(teamLeader));
        }
        if (!plugin.getPlayers().getMembers(teamLeader).contains(playerUUID)) {
            plugin.getPlayers().addTeamMember(teamLeader, playerUUID);
        }
        if (!plugin.getPlayers().getMembers(teamLeader).contains(teamLeader)) {
            plugin.getPlayers().addTeamMember(teamLeader, teamLeader);
        }
        final Island island = plugin.getGrid().getIsland(teamLeader);
        final IslandJoinEvent event = new IslandJoinEvent(playerUUID, island);
        plugin.getServer().getPluginManager().callEvent(event);
    }
    return true;
}

Output:
         plugin.getPlayers().clearHomeLocations(playerUUID);
-        if (plugin.getPlayers().getHomeLocation(teamLeader, 1) != null) {
-            plugin.getPlayers().setHomeLocation(playerUUID, plugin.getPlayers().getHomeLocation(teamLeader));
-        } else {
+        for (Entry<Integer, Location> homes : plugin.getPlayers().getHomeLocations(teamLeader).entrySet()) {
+            if (homes.getKey() < 2) {
+                plugin.getPlayers().setHomeLocation(playerUUID, homes.getValue(), homes.getKey());
+            }
+        }
+        if (plugin.getPlayers().getHomeLocation(teamLeader, 1) == null) {
             plugin.getPlayers().setHomeLocation(playerUUID, plugin.getPlayers().getIslandLocation(teamLeader));


Input:
public int compare(RenderedMatch renderedMatch, RenderedMatch renderedMatch2) {
    int length1 = renderedMatch.getEnd() - renderedMatch.getStart();
    int length2 = renderedMatch2.getEnd() - renderedMatch.getEnd();
    return length2 - length1;
}

Output:
     int length1 = renderedMatch.getEnd() - renderedMatch.getStart();
-    int length2 = renderedMatch2.getEnd() - renderedMatch.getEnd();
+    int length2 = renderedMatch2.getEnd() - renderedMatch2.getStart();
     return length2 - length1;


Input:
public void add(Marker marker) {
    if (marker.isError()) {
        this.errors++;
    }
    if (marker.isWarning()) {
        this.warnings++;
    }
    int index = this.markerCount++;
    if (index >= this.markers.length) {
        Marker[] temp = new Marker[this.markerCount];
        System.arraycopy(this.markers, 0, temp, 0, this.markers.length);
        this.markers = temp;
    }
    this.markers[index] = marker;
}

Output:
     if (index >= this.markers.length) {
-        Marker[] temp = new Marker[this.markerCount];
-        System.arraycopy(this.markers, 0, temp, 0, this.markers.length);
+        Marker[] temp = new Marker[this.markerCount << 1];
+        System.arraycopy(this.markers, 0, temp, 0, index);
         this.markers = temp;