Input:
protected void onPostExecute(AsyncTaskResult<SSHClient> result) {
    if (result.exception != null) {
        if (SocketException.class.isAssignableFrom(result.exception.getClass()) || SocketTimeoutException.class.isAssignableFrom(result.exception.getClass())) {
            Toast.makeText(AppConfig.getInstance(), String.format(AppConfig.getInstance().getResources().getString(R.string.ssh_connect_failed), mHostname, mPort, result.exception.getLocalizedMessage()), Toast.LENGTH_LONG).show();
            return;
        } else if (TransportException.class.isAssignableFrom(result.exception.getClass())) {
            DisconnectReason disconnectReason = TransportException.class.cast(result.exception).getDisconnectReason();
            if (DisconnectReason.HOST_KEY_NOT_VERIFIABLE.equals(disconnectReason)) {
                new AlertDialog.Builder(AppConfig.getInstance().getActivityContext()).setTitle(R.string.ssh_connect_failed_host_key_changed_title).setMessage(R.string.ssh_connect_failed_host_key_changed_message).setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                }).show();
            }
            return;
        } else if (mPassword != null) {
            Toast.makeText(AppConfig.getInstance(), R.string.ssh_authentication_failure_password, Toast.LENGTH_LONG).show();
            return;
        } else if (mPrivateKey != null) {
            Toast.makeText(AppConfig.getInstance(), R.string.ssh_authentication_failure_key, Toast.LENGTH_LONG).show();
            return;
        }
    }
}

Output:
         if (SocketException.class.isAssignableFrom(result.exception.getClass()) || SocketTimeoutException.class.isAssignableFrom(result.exception.getClass())) {
-            Toast.makeText(AppConfig.getInstance(), String.format(AppConfig.getInstance().getResources().getString(R.string.ssh_connect_failed), mHostname, mPort, result.exception.getLocalizedMessage()), Toast.LENGTH_LONG).show();
+            Toast.makeText(AppConfig.getInstance(), String.format(AppConfig.getInstance().getResources().getString(R.string.ssh_connect_failed), hostname, port, result.exception.getLocalizedMessage()), Toast.LENGTH_LONG).show();
             return;


Input:
private InputStream renderXml(String contextPath, CacheEntry cacheEntry, InputStream xsltInputStream, ProxyDirContext proxyDirContext) throws IOException, ServletException {
    StringBuilder sb = new StringBuilder();
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(contextPath);
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    sb.append(cacheEntry.name);
    sb.append("String_Node_Str");
    sb.append("String_Node_Str").append(!cacheEntry.name.equals("String_Node_Str"));
    sb.append("String_Node_Str");
    sb.append("String_Node_Str");
    try {
        Enumeration<NameClassPair> enumeration = proxyDirContext.list(cacheEntry.name);
        if (sortedBy.equals(SortedBy.LAST_MODIFIED)) {
            ArrayList<NameClassPair> list = Collections.list(enumeration);
            Comparator<NameClassPair> c = new LastModifiedComparator(proxyDirContext, cacheEntry.name);
            Collections.sort(list, c);
            enumeration = Collections.enumeration(list);
        } else if (sortedBy.equals(SortedBy.SIZE)) {
            ArrayList<NameClassPair> list = Collections.list(enumeration);
            Comparator<NameClassPair> c = new SizeComparator(proxyDirContext, cacheEntry.name);
            Collections.sort(list, c);
            enumeration = Collections.enumeration(list);
        }
        String rewrittenContextPath = rewriteUrl(contextPath);
        while (enumeration.hasMoreElements()) {
            NameClassPair ncPair = enumeration.nextElement();
            String resourceName = ncPair.getName();
            String trimmed = resourceName;
            if (trimmed.equalsIgnoreCase("String_Node_Str") || trimmed.equalsIgnoreCase("String_Node_Str") || trimmed.equalsIgnoreCase(localXsltFile))
                continue;
            CacheEntry childCacheEntry = proxyDirContext.lookupCache(cacheEntry.name + resourceName);
            if (!childCacheEntry.exists) {
                continue;
            }
            sb.append("String_Node_Str");
            sb.append("String_Node_Str").append((childCacheEntry.context != null) ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
            sb.append("String_Node_Str").append(rewrittenContextPath).append(rewriteUrl(cacheEntry.name + resourceName)).append((childCacheEntry.context != null) ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str");
            if (childCacheEntry.resource != null) {
                sb.append("String_Node_Str").append(renderSize(childCacheEntry.attributes.getContentLength())).append("String_Node_Str");
            }
            sb.append("String_Node_Str").append(childCacheEntry.attributes.getLastModifiedHttp()).append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(RequestUtil.filter(trimmed));
            if (childCacheEntry.context != null)
                sb.append("String_Node_Str");
            sb.append("String_Node_Str");
        }
    } catch (NamingException e) {
        throw new ServletException("String_Node_Str", e);
    }
    sb.append("String_Node_Str");
    String readme = getReadme(cacheEntry.context);
    if (readme != null) {
        sb.append("String_Node_Str");
        sb.append(readme);
        sb.append("String_Node_Str");
    }
    sb.append("String_Node_Str");
    try {
        TransformerFactory tFactory = TransformerFactory.newInstance();
        Source xmlSource = new StreamSource(new StringReader(sb.toString()));
        Source xslSource = new StreamSource(xsltInputStream);
        Transformer transformer = tFactory.newTransformer(xslSource);
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        OutputStreamWriter osWriter = new OutputStreamWriter(stream, "String_Node_Str");
        StreamResult out = new StreamResult(osWriter);
        transformer.transform(xmlSource, out);
        osWriter.flush();
        return (new ByteArrayInputStream(stream.toByteArray()));
    } catch (Exception e) {
        log("String_Node_Str" + e.getMessage());
        return renderHtml(contextPath, cacheEntry);
    }
}

Output:
             sb.append("String_Node_Str");
-            sb.append(RequestUtil.filter(trimmed));
+            sb.append(htmlEntityEncoder.encode(trimmed));
             if (childCacheEntry.context != null)


Input:
public void moveTo(Session session, int newPos) throws SQLException {
    PageStore store = index.getPageStore();
    store.logUndo(this, data);
    PageDataNode p2 = PageDataNode.create(index, newPos, parentPageId);
    p2.rowCountStored = rowCountStored;
    p2.rowCount = rowCount;
    p2.childPageIds = childPageIds;
    p2.keys = keys;
    p2.entryCount = entryCount;
    p2.length = length;
    store.updateRecord(p2);
    if (parentPageId == ROOT) {
        index.setRootPageId(session, newPos);
    } else {
        PageDataNode p = (PageDataNode) store.getPage(parentPageId);
        p.moveChild(getPos(), newPos);
    }
    for (int i = 0; i < childPageIds.length; i++) {
        PageData p = (PageData) store.getPage(childPageIds[i]);
        p.setParentPageId(newPos);
        store.updateRecord(p);
    }
    store.freePage(getPos(), true, data);
}

Output:
     p2.length = length;
-    store.updateRecord(p2);
+    store.update(p2);
     if (parentPageId == ROOT) {


Input:
public void write(JsonWriter out, OldAttributes oldValues) throws IOException {
    out.beginObject();
    out.name("String_Node_Str");
    out.beginObject();
    out.name("String_Node_Str");
    out.beginObject();
    TaskAttribute attribute = taskData.getRoot().getAttribute(taskSchema.DESCRIPTION.getKey());
    String attValue = attribute.getValue() == null ? "String_Node_Str" : attribute.getValue();
    out.name("String_Node_Str").value(attValue);
    if (taskData.getRoot().getAttribute(TaskAttribute.OPERATION) != null) {
        attribute = taskData.getRoot().getAttribute(TaskAttribute.OPERATION);
    } else {
        attribute = taskData.getRoot().getAttribute(taskSchema.STATUS.getKey());
    }
    attValue = attribute.getValue();
    out.name("String_Node_Str").value(attValue);
    attribute = taskData.getRoot().getAttribute(taskSchema.SUMMARY.getKey());
    attValue = attribute.getValue();
    out.name("String_Node_Str").value(attValue);
    attribute = taskData.getRoot().getAttribute(taskSchema.VERSION.getKey());
    attValue = attribute.getValue();
    out.name("String_Node_Str").value(attValue);
    out.endObject();
    attribute = taskData.getRoot().getAttribute(taskSchema.UUID.getKey());
    attValue = attribute.getValue();
    out.name("String_Node_Str").value(attValue);
    out.name("String_Node_Str");
    out.beginObject();
    out.name("String_Node_Str");
    out.beginObject();
    out.name("String_Node_Str");
    out.beginObject();
    attribute = taskData.getRoot().getAttribute(taskSchema.SPACE.getKey());
    String spaceName = attribute.getValue();
    out.name("String_Node_Str").value(space.getId());
    out.name("String_Node_Str").value("String_Node_Str");
    out.endObject();
    out.endObject();
    attribute = taskData.getRoot().getAttribute(taskSchema.AREA.getKey());
    String areaName = attribute.getValue();
    if (areaName != null && !areaName.trim().isEmpty()) {
        out.name("String_Node_Str");
        out.beginObject();
        out.name("String_Node_Str");
        out.beginObject();
        Area area = space.getAreas().get(areaName);
        out.name("String_Node_Str").value(area.getId());
        out.name("String_Node_Str").value("String_Node_Str");
        out.endObject();
        out.endObject();
    }
    attribute = taskData.getRoot().getAttribute(taskSchema.ITERATION.getKey());
    String iterationName = attribute.getValue();
    if (iterationName != null && !iterationName.trim().isEmpty()) {
        out.name("String_Node_Str");
        out.beginObject();
        out.name("String_Node_Str");
        out.beginObject();
        Iteration iteration = space.getIterations().get(iterationName);
        out.name("String_Node_Str").value(iteration.getId());
        out.name("String_Node_Str").value("String_Node_Str");
        out.endObject();
        out.endObject();
    }
    out.name("String_Node_Str");
    out.beginObject();
    attribute = taskData.getRoot().getAttribute(taskSchema.ASSIGNEES.getKey());
    List<String> assignees = attribute.getValues();
    if (assignees == null) {
        assignees = new ArrayList<String>();
    } else {
        assignees = new ArrayList<>(assignees);
    }
    attribute = taskData.getRoot().getAttribute(taskSchema.REMOVE_ASSIGNEE.getKey());
    List<String> removals = attribute.getValues();
    if (removals != null) {
        for (String removal : removals) {
            int index = assignees.indexOf(removal);
            if (index >= 0) {
                assignees.remove(index);
            }
        }
    }
    attribute = taskData.getRoot().getAttribute(taskSchema.ADD_ASSIGNEE.getKey());
    List<String> additions = attribute.getValues();
    if (additions != null) {
        for (String addition : additions) {
            int index = assignees.indexOf(addition);
            if (index < 0) {
                assignees.add(addition);
            }
        }
    }
    if (assignees.size() > 0 && !assignees.get(0).isEmpty()) {
        Map<String, User> users = space.getUsers();
        out.name("String_Node_Str");
        out.beginArray();
        for (String assignee : assignees) {
            if (assignee != null && !assignee.isEmpty()) {
                User user = users.get(assignee);
                if (user == null) {
                    throw new UnsupportedOperationException(OSIORestMessages.getFormattedString("String_Node_Str", assignee));
                }
                String userid = user.getId();
                out.beginObject();
                out.name("String_Node_Str").value(userid);
                out.name("String_Node_Str").value("String_Node_Str");
                out.endObject();
            }
        }
        out.endArray();
    }
    out.endObject();
    attribute = taskData.getRoot().getAttribute(taskSchema.LABELS.getKey());
    List<String> labels = attribute.getValues();
    if (labels == null) {
        labels = new ArrayList<String>();
    } else {
        labels = new ArrayList<>(labels);
    }
    attribute = taskData.getRoot().getAttribute(taskSchema.REMOVE_LABEL.getKey());
    List<String> labelRemovals = attribute.getValues();
    if (labelRemovals != null) {
        for (String removal : labelRemovals) {
            int index = labels.indexOf(removal);
            if (index >= 0) {
                labels.remove(index);
            }
        }
    }
    attribute = taskData.getRoot().getAttribute(taskSchema.ADD_LABEL.getKey());
    String labelAddString = attribute.getValue();
    String[] labelAdditions = labelAddString.split("String_Node_Str");
    if (labelAdditions != null) {
        for (String addition : labelAdditions) {
            int index = labels.indexOf(addition);
            if (index < 0) {
                labels.add(addition);
            }
        }
    }
    out.name("String_Node_Str");
    out.beginObject();
    out.name("String_Node_Str");
    out.beginArray();
    if (labels.size() > 0 && !labels.get(0).isEmpty()) {
        Map<String, Label> spaceLabels = space.getLabels();
        for (String label : labels) {
            Label l = spaceLabels.get(label);
            if (l == null && !label.trim().isEmpty()) {
                try {
                    LabelResponse response = new OSIORestPostNewLabelTask(client, space, label).run(new NullOperationMonitor());
                    Label newLabel = response.getData();
                    spaceLabels.put(label, newLabel);
                } catch (OSIORestException e) {
                    e.printStackTrace();
                }
            }
            l = spaceLabels.get(label);
            if (l != null) {
                String labelid = l.getId();
                out.beginObject();
                out.name("String_Node_Str").value(labelid);
                out.name("String_Node_Str").value("String_Node_Str");
                out.endObject();
            }
        }
    }
    out.endArray();
    out.endObject();
    out.endObject();
    out.name("String_Node_Str").value("String_Node_Str");
    out.endObject();
    out.name("String_Node_Str");
    out.beginArray();
    out.value(true);
    out.endArray();
    out.endObject();
}

Output:
     attribute = taskData.getRoot().getAttribute(taskSchema.ADD_LABEL.getKey());
-    String labelAddString = attribute.getValue();
-    String[] labelAdditions = labelAddString.split("String_Node_Str");
+    List<String> labelAdditions = attribute.getValues();
     if (labelAdditions != null) {


Input:
private CompletableFuture<Void> lookupPledgesFromServer(Project project) {
    CompletableFuture<Void> future = new CompletableFuture<>();
    executor.execute(() -> {
        markAsInProgress(project);
        project.getStatus(wallet, null).whenCompleteAsync((status, ex) -> {
            if (ex != null) {
                markAsErrored(project, ex);
                future.completeExceptionally(ex);
            } else {
                log.info("String_Node_Str", status);
                syncPledges(project, new HashSet<>(status.getPledgesList()), status.getPledgesList(), true);
                if (status.hasClaimedBy() && diskManager.getProjectState(project).state != ProjectState.CLAIMED) {
                    diskManager.setProjectState(project, new ProjectStateInfo(ProjectState.CLAIMED, new Sha256Hash(status.getClaimedBy().toByteArray())));
                }
                markAsCheckDone(project);
                future.complete(null);
            }
        }, executor);
    });
    return future;
}

Output:
                 log.info("String_Node_Str", status);
-                syncPledges(project, new HashSet<>(status.getPledgesList()), status.getPledgesList(), true);
+                syncPledges(project, new HashSet<>(status.getPledgesList()), status.getPledgesList());
                 if (status.hasClaimedBy() && diskManager.getProjectState(project).state != ProjectState.CLAIMED) {


Input:
public boolean isPEI() {
    return operator == BinaryOpInstruction.Operator.DIV || operator == BinaryOpInstruction.Operator.REM;
}

Output:
 public boolean isPEI() {
-    return operator == BinaryOpInstruction.Operator.DIV || operator == BinaryOpInstruction.Operator.REM;
+    return mayBeInteger && operator == BinaryOpInstruction.Operator.DIV || operator == BinaryOpInstruction.Operator.REM;
 }


Input:
public static StratosApiResponse deployAutoscalingPolicy(AutoscalePolicy autoscalePolicyBean) throws RestAPIException {
    AutoscalerServiceClient autoscalerServiceClient = getAutoscalerServiceClient();
    if (autoscalerServiceClient != null) {
        org.apache.stratos.autoscaler.stub.policy.model.AutoscalePolicy autoscalePolicy = PojoConverter.convertToCCAutoscalerPojo(autoscalePolicyBean);
        try {
            autoscalerServiceClient.deployAutoscalingPolicy(autoscalePolicy);
        } catch (RemoteException e) {
            log.error(e.getMessage(), e);
            throw new RestAPIException(e.getMessage(), e);
        } catch (AutoScalerServiceInvalidPolicyExceptionException e) {
            String message = e.getFaultMessage().getInvalidPolicyException().getMessage();
            log.error(message, e);
            throw new RestAPIException(message, e);
        }
    }
    StratosApiResponse stratosApiResponse = new StratosApiResponse();
    stratosApiResponse.setMessage("String_Node_Str" + autoscalePolicyBean.getId());
    return stratosApiResponse;
}

Output:
     if (autoscalerServiceClient != null) {
-        org.apache.stratos.autoscaler.stub.policy.model.AutoscalePolicy autoscalePolicy = PojoConverter.convertToCCAutoscalerPojo(autoscalePolicyBean);
+        org.apache.stratos.autoscaler.stub.autoscale.policy.AutoscalePolicy autoscalePolicy = PojoConverter.convertToCCAutoscalerPojo(autoscalePolicyBean);
         try {


Input:
public boolean isWidthStatic() {
    if (!Float.isNaN(absoluteSizeX))
        return true;
    if (pixelSizeX == Integer.MIN_VALUE)
        return true;
    return false;
}

Output:
         return true;
-    if (pixelSizeX == Integer.MIN_VALUE)
+    if (pixelSizeX != Integer.MIN_VALUE)
         return true;


Input:
protected boolean build() {
    feeling = Feeling.CHASM;
    initRooms();
    int distance;
    int retry = 0;
    int minDistance = (int) Math.sqrt(rooms.size());
    do {
        int innerRetry = 0;
        do {
            if (innerRetry++ > 10) {
                return false;
            }
            roomEntrance = Random.element(rooms);
        } while (roomEntrance.width() < 4 || roomEntrance.height() < 4);
        innerRetry = 0;
        do {
            if (innerRetry++ > 10) {
                return false;
            }
            roomExit = Random.element(rooms);
        } while (roomExit == roomEntrance || roomExit.width() < 6 || roomExit.height() < 6 || roomExit.top == 0);
        Graph.buildDistanceMap(rooms, roomExit);
        distance = Graph.buildPath(rooms, roomEntrance, roomExit).size();
        if (retry++ > 10) {
            return false;
        }
    } while (distance < minDistance);
    roomEntrance.type = Type.ENTRANCE;
    roomExit.type = Type.EXIT;
    Graph.buildDistanceMap(rooms, roomExit);
    List<Room> path = Graph.buildPath(rooms, roomEntrance, roomExit);
    Graph.setPrice(path, roomEntrance.distance);
    Graph.buildDistanceMap(rooms, roomExit);
    path = Graph.buildPath(rooms, roomEntrance, roomExit);
    Room room = roomEntrance;
    for (Room next : path) {
        room.connect(next);
        room = next;
    }
    Room roomShop = null;
    int shopSquare = 0;
    for (Room r : rooms) {
        if (r.type == Type.NULL && r.connected.size() > 0) {
            r.type = Type.PASSAGE;
            if (r.square() > shopSquare) {
                roomShop = r;
                shopSquare = r.square();
            }
        }
    }
    if (roomShop == null || shopSquare < 30 || ((roomShop.width() - 1) * (roomShop.height() - 1) < ShopPainter.spaceNeeded())) {
        return false;
    } else {
        roomShop.type = Imp.Quest.isCompleted() ? Room.Type.SHOP : Room.Type.STANDARD;
    }
    paint();
    paintWater();
    paintGrass();
    return true;
}

Output:
     }
-    if (roomShop == null || shopSquare < 30 || ((roomShop.width() - 1) * (roomShop.height() - 1) < ShopPainter.spaceNeeded())) {
+    if (roomShop == null || shopSquare < 54) {
         return false;


Input:
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    Log.v(Constants.TAG, "String_Node_Str" + uri + "String_Node_Str" + Arrays.toString(projection) + "String_Node_Str");
    SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
    SQLiteDatabase db = mApgDatabase.getReadableDatabase();
    int match = mUriMatcher.match(uri);
    String groupBy = null, having = null;
    boolean all = false;
    switch(match) {
        case UNIFIED_KEY_RING:
            qb = buildKeyRingQuery(qb, match);
            groupBy = Tables.KEY_RINGS + "String_Node_Str" + KeyRingsColumns.MASTER_KEY_ID;
            if (TextUtils.isEmpty(sortOrder)) {
                sortOrder = KeyRings.TYPE + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
            }
            break;
        case PUBLIC_KEY_RING:
        case SECRET_KEY_RING:
            qb = buildKeyRingQuery(qb, match);
            if (TextUtils.isEmpty(sortOrder)) {
                sortOrder = Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
            }
            break;
        case PUBLIC_KEY_RING_BY_ROW_ID:
        case SECRET_KEY_RING_BY_ROW_ID:
            qb = buildKeyRingQuery(qb, match);
            qb.appendWhere("String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + BaseColumns._ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            if (TextUtils.isEmpty(sortOrder)) {
                sortOrder = Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
            }
            break;
        case PUBLIC_KEY_RING_BY_MASTER_KEY_ID:
        case SECRET_KEY_RING_BY_MASTER_KEY_ID:
            qb = buildKeyRingQuery(qb, match);
            qb.appendWhere("String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + KeyRingsColumns.MASTER_KEY_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            if (TextUtils.isEmpty(sortOrder)) {
                sortOrder = Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
            }
            break;
        case SECRET_KEY_RING_BY_KEY_ID:
        case PUBLIC_KEY_RING_BY_KEY_ID:
            qb = buildKeyRingQueryWithSpecificKey(qb, match);
            qb.appendWhere("String_Node_Str" + Tables.KEYS + "String_Node_Str" + KeysColumns.KEY_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            if (TextUtils.isEmpty(sortOrder)) {
                sortOrder = Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
            }
            break;
        case SECRET_KEY_RING_BY_EMAILS:
        case PUBLIC_KEY_RING_BY_EMAILS:
            qb = buildKeyRingQuery(qb, match);
            String emails = uri.getLastPathSegment();
            String[] chunks = emails.split("String_Node_Str");
            boolean gotCondition = false;
            String emailWhere = "String_Node_Str";
            for (int i = 0; i < chunks.length; ++i) {
                if (chunks[i].length() == 0) {
                    continue;
                }
                if (i != 0) {
                    emailWhere += "String_Node_Str";
                }
                emailWhere += "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str";
                emailWhere += DatabaseUtils.sqlEscapeString("String_Node_Str" + chunks[i] + "String_Node_Str");
                gotCondition = true;
            }
            if (gotCondition) {
                qb.appendWhere("String_Node_Str" + BaseColumns._ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.KEY_RING_ROW_ID + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + BaseColumns._ID + "String_Node_Str" + emailWhere + "String_Node_Str");
            }
            break;
        case SECRET_KEY_RING_BY_LIKE_EMAIL:
        case PUBLIC_KEY_RING_BY_LIKE_EMAIL:
            qb = buildKeyRingQuery(qb, match);
            String likeEmail = uri.getLastPathSegment();
            String likeEmailWhere = "String_Node_Str" + UserIdsColumns.USER_ID + "String_Node_Str" + DatabaseUtils.sqlEscapeString("String_Node_Str" + likeEmail + "String_Node_Str");
            qb.appendWhere("String_Node_Str" + BaseColumns._ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.KEY_RING_ROW_ID + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + BaseColumns._ID + "String_Node_Str" + likeEmailWhere + "String_Node_Str");
            break;
        case PUBLIC_KEY_RING_KEY:
        case SECRET_KEY_RING_KEY:
            qb.setTables(Tables.KEYS);
            qb.appendWhere(KeysColumns.TYPE + "String_Node_Str");
            qb.appendWhereEscapeString(Integer.toString(getKeyType(match)));
            qb.appendWhere("String_Node_Str" + KeysColumns.KEY_RING_ROW_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            qb.setProjectionMap(getProjectionMapForKeys());
            break;
        case PUBLIC_KEY_RING_KEY_BY_ROW_ID:
        case SECRET_KEY_RING_KEY_BY_ROW_ID:
            qb.setTables(Tables.KEYS);
            qb.appendWhere(KeysColumns.TYPE + "String_Node_Str");
            qb.appendWhereEscapeString(Integer.toString(getKeyType(match)));
            qb.appendWhere("String_Node_Str" + KeysColumns.KEY_RING_ROW_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            qb.appendWhere("String_Node_Str" + BaseColumns._ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            qb.setProjectionMap(getProjectionMapForKeys());
            break;
        case PUBLIC_KEY_RING_BY_MASTER_KEY_ID_USER_ID:
            qb.setTables(Tables.USER_IDS + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + BaseColumns._ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + KeysColumns.KEY_RING_ROW_ID + "String_Node_Str");
            qb.appendWhere(Tables.KEY_RINGS + "String_Node_Str" + KeyRingsColumns.MASTER_KEY_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(3));
            qb.setProjectionMap(getProjectionMapForUserIds());
            break;
        case PUBLIC_KEY_RING_USER_ID:
        case SECRET_KEY_RING_USER_ID:
            qb.setTables(Tables.USER_IDS + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.KEY_RING_ROW_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_RING_ROW_ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.RANK + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.RANK + "String_Node_Str");
            groupBy = Tables.USER_IDS + "String_Node_Str" + UserIds.RANK;
            HashMap<String, String> pmap = new HashMap<String, String>();
            pmap.put(UserIds._ID, Tables.USER_IDS + "String_Node_Str" + UserIds._ID);
            pmap.put(UserIds.USER_ID, Tables.USER_IDS + "String_Node_Str" + UserIds.USER_ID);
            pmap.put(UserIds.RANK, Tables.USER_IDS + "String_Node_Str" + UserIds.RANK);
            pmap.put("String_Node_Str", "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs._ID + "String_Node_Str");
            qb.setProjectionMap(pmap);
            qb.appendWhere(Tables.USER_IDS + "String_Node_Str" + UserIdsColumns.KEY_RING_ROW_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            break;
        case PUBLIC_KEY_RING_USER_ID_BY_ROW_ID:
        case SECRET_KEY_RING_USER_ID_BY_ROW_ID:
            qb.setTables(Tables.USER_IDS);
            qb.appendWhere(UserIdsColumns.KEY_RING_ROW_ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            qb.appendWhere("String_Node_Str" + BaseColumns._ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            break;
        case CERTS_BY_ROW_ID:
        case CERTS_BY_KEY_ROW_ID_ALL:
            all = true;
        case CERTS_BY_KEY_ROW_ID:
            qb.setTables(Tables.CERTS + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_RING_ROW_ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.KEY_RING_ROW_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.RANK + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.RANK + "String_Node_Str" + (all ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_ID_CERTIFIER + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Keys.KEY_ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Keys.KEY_RING_ROW_ID + "String_Node_Str" + "String_Node_Str" + UserIds.KEY_RING_ROW_ID + "String_Node_Str" + "String_Node_Str" + Keys.RANK + "String_Node_Str" + "String_Node_Str");
            HashMap<String, String> pmap2 = new HashMap<String, String>();
            pmap2.put(Certs._ID, Tables.CERTS + "String_Node_Str" + Certs._ID);
            pmap2.put(Certs.KEY_ID, Tables.CERTS + "String_Node_Str" + Certs.KEY_ID);
            pmap2.put(Certs.RANK, Tables.CERTS + "String_Node_Str" + Certs.RANK);
            pmap2.put(Certs.CREATION, Tables.CERTS + "String_Node_Str" + Certs.CREATION);
            pmap2.put(Certs.KEY_ID_CERTIFIER, Tables.CERTS + "String_Node_Str" + Certs.KEY_ID_CERTIFIER);
            pmap2.put(Certs.KEY_DATA, Tables.CERTS + "String_Node_Str" + Certs.KEY_DATA);
            pmap2.put(Certs.VERIFIED, Tables.CERTS + "String_Node_Str" + Certs.VERIFIED);
            pmap2.put(UserIds.USER_ID, Tables.USER_IDS + "String_Node_Str" + UserIds.USER_ID);
            pmap2.put("String_Node_Str", "String_Node_Str" + UserIds.USER_ID + "String_Node_Str");
            qb.setProjectionMap(pmap2);
            if (match == CERTS_BY_ROW_ID) {
                qb.appendWhere(Tables.CERTS + "String_Node_Str" + Certs._ID + "String_Node_Str");
                qb.appendWhereEscapeString(uri.getPathSegments().get(1));
            } else {
                qb.appendWhere(Tables.CERTS + "String_Node_Str" + Certs.KEY_RING_ROW_ID + "String_Node_Str");
                qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            }
            break;
        case API_APPS:
            qb.setTables(Tables.API_APPS);
            break;
        case API_APPS_BY_ROW_ID:
            qb.setTables(Tables.API_APPS);
            qb.appendWhere(BaseColumns._ID + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getLastPathSegment());
            break;
        case API_APPS_BY_PACKAGE_NAME:
            qb.setTables(Tables.API_APPS);
            qb.appendWhere(ApiApps.PACKAGE_NAME + "String_Node_Str");
            qb.appendWhereEscapeString(uri.getPathSegments().get(2));
            break;
        default:
            throw new IllegalArgumentException("String_Node_Str" + uri);
    }
    String orderBy;
    if (TextUtils.isEmpty(sortOrder)) {
        orderBy = null;
    } else {
        orderBy = sortOrder;
    }
    Cursor c = qb.query(db, projection, selection, selectionArgs, groupBy, having, orderBy);
    c.setNotificationUri(getContext().getContentResolver(), uri);
    if (Constants.DEBUG) {
        Log.d(Constants.TAG, "String_Node_Str" + qb.buildQuery(projection, selection, selectionArgs, null, null, orderBy, null));
        Log.d(Constants.TAG, "String_Node_Str" + DatabaseUtils.dumpCursorToString(c));
    }
    return c;
}

Output:
         case SECRET_KEY_RING_USER_ID:
-            qb.setTables(Tables.USER_IDS + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.KEY_RING_ROW_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_RING_ROW_ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.RANK + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.RANK + "String_Node_Str");
+            qb.setTables(Tables.USER_IDS + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + Tables.KEY_RINGS + "String_Node_Str" + BaseColumns._ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + KeysColumns.KEY_RING_ROW_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.KEY_RING_ROW_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_RING_ROW_ID + "String_Node_Str" + Tables.USER_IDS + "String_Node_Str" + UserIds.RANK + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.RANK + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Keys.KEY_ID + "String_Node_Str" + Tables.CERTS + "String_Node_Str" + Certs.KEY_ID_CERTIFIER + "String_Node_Str" + Tables.KEYS + "String_Node_Str" + Keys.TYPE + "String_Node_Str" + KeyTypes.SECRET + "String_Node_Str");
             groupBy = Tables.USER_IDS + "String_Node_Str" + UserIds.RANK;


Input:
private void approveComment() {
    if (!hasActivity() || !hasComment() || mIsApprovingComment)
        return;
    final TextView txtBtnApprove = (TextView) getActivity().findViewById(R.id.text_approve);
    ReaderAniUtils.flyOut(txtBtnApprove);
    Runnable runnable = new Runnable() {
        public void run() {
            showReplyBox();
        }
    };
    MessageBarUtils.showMessageBar(getActivity(), getString(R.string.comment_approved), MessageBarUtils.MessageBarType.INFO, runnable);
    mIsApprovingComment = true;
    CommentActions.CommentActionListener actionListener = new CommentActions.CommentActionListener() {
        public void onActionResult(boolean succeeded) {
            mIsApprovingComment = false;
            if (hasActivity()) {
                if (succeeded) {
                    mComment.setStatus(CommentStatus.toString(CommentStatus.APPROVED));
                    if (mChangeListener != null)
                        mChangeListener.onCommentModerated();
                } else {
                    hideReplyBox(true);
                    txtBtnApprove.setVisibility(View.VISIBLE);
                    ToastUtils.showToast(getActivity(), R.string.error_moderate_comment, ToastUtils.Duration.LONG);
                }
            }
        }
    };
    CommentActions.moderateComment(mAccountId, mComment, CommentStatus.APPROVED, actionListener);
}

Output:
     ReaderAniUtils.flyOut(txtBtnApprove);
-    Runnable runnable = new Runnable() {
-        public void run() {
-            showReplyBox();
-        }
-    };
-    MessageBarUtils.showMessageBar(getActivity(), getString(R.string.comment_approved), MessageBarUtils.MessageBarType.INFO, runnable);
-    mIsApprovingComment = true;
+    MessageBarUtils.showMessageBar(getActivity(), getString(R.string.comment_approved));
     CommentActions.CommentActionListener actionListener = new CommentActions.CommentActionListener() {


Input:
public IType resolve(MarkerList markers, IContext context) {
    this.resolveTypes(markers, context);
    return this;
}

Output:
 public IType resolve(MarkerList markers, IContext context) {
-    this.resolveTypes(markers, context);
+    if (this.upperBound != null) {
+        this.upperBound = this.upperBound.resolve(markers, context);
+    }
+    if (this.lowerBound != null) {
+        this.lowerBound = this.lowerBound.resolve(markers, context);
+    }
     return this;


Input:
public void renderLimitLines(Canvas c) {
    ArrayList<LimitLine> limitLines = mYAxis.getLimitLines();
    if (limitLines == null || limitLines.size() <= 0)
        return;
    float[] pts = new float[4];
    for (int i = 0; i < limitLines.size(); i++) {
        LimitLine l = limitLines.get(i);
        pts[1] = l.getLimit();
        pts[3] = l.getLimit();
        mTrans.pointValuesToPixel(pts);
        pts[0] = mViewPortHandler.contentLeft();
        pts[2] = mViewPortHandler.contentRight();
        mLimitLinePaint.setColor(l.getLineColor());
        mLimitLinePaint.setPathEffect(l.getDashPathEffect());
        mLimitLinePaint.setStrokeWidth(l.getLineWidth());
        c.drawLines(pts, mLimitLinePaint);
        String label = l.getLabel();
        if (label != null && !label.equals("String_Node_Str")) {
            float xOffset = Utils.convertDpToPixel(4f);
            float yOffset = l.getLineWidth() + Utils.calcTextHeight(mLimitLinePaint, label) / 2f;
            mLimitLinePaint.setPathEffect(null);
            mLimitLinePaint.setColor(l.getTextColor());
            mLimitLinePaint.setStrokeWidth(0.5f);
            mLimitLinePaint.setTextSize(l.getTextSize());
            if (l.getLabelPosition() == LimitLabelPosition.POS_RIGHT) {
                mLimitLinePaint.setTextAlign(Align.RIGHT);
                c.drawText(label, mViewPortHandler.contentRight() - xOffset, pts[1] - yOffset, mLimitLinePaint);
            } else {
                mLimitLinePaint.setTextAlign(Align.LEFT);
                c.drawText(label, mViewPortHandler.offsetLeft() + xOffset, pts[1] - yOffset, mLimitLinePaint);
            }
        }
    }
}

Output:
         mLimitLinePaint.setStrokeWidth(l.getLineWidth());
-        c.drawLines(pts, mLimitLinePaint);
+        c.drawPath(limitLinePath, mLimitLinePaint);
+        limitLinePath.reset();
         String label = l.getLabel();


Input:
public void validateTimesheet(ActionRequest request, ActionResponse response) {
    User user = AuthUtils.getUser();
    Employee employee = user.getEmployee();
    ActionViewBuilder actionView = ActionView.define(I18n.get("String_Node_Str")).model(Timesheet.class.getName()).add("String_Node_Str", "String_Node_Str").add("String_Node_Str", "String_Node_Str").context("String_Node_Str", Beans.get(GeneralService.class).getTodayDate());
    actionView.domain("String_Node_Str").context("String_Node_Str", user.getActiveCompany());
    if (employee == null || !employee.getHrManager()) {
        if (employee != null && employee.getManager() != null) {
            actionView.domain(actionView.get().getDomain() + "String_Node_Str").context("String_Node_Str", user.getId());
        } else {
            actionView.domain(actionView.get().getDomain() + "String_Node_Str").context("String_Node_Str", user.getId());
        }
    }
    response.setView(actionView.map());
}

Output:
         if (employee != null && employee.getManager() != null) {
-            actionView.domain(actionView.get().getDomain() + "String_Node_Str").context("String_Node_Str", user.getId());
+            actionView.domain(actionView.get().getDomain() + "String_Node_Str").context("String_Node_Str", user);
         } else {


Input:
public void onDestroy() {
    super.onDestroy();
    Log.d(TAG, "String_Node_Str");
    for (DroneApi droneApi : droneApiStore) {
        droneApi.destroy();
    }
    droneApiStore.clear();
    for (AndroidMavLinkConnection conn : mavConnections.values()) {
        conn.disconnect();
        conn.removeAllMavLinkConnectionListeners();
    }
    mavConnections.clear();
    stopForeground(true);
}

Output:
     Log.d(TAG, "String_Node_Str");
-    for (DroneApi droneApi : droneApiStore) {
+    for (DroneApi droneApi : droneApiStore.values()) {
         droneApi.destroy();


Input:
public void checkTypes(MarkerList markers, IContext context) {
    if (this.type != null)
        this.type.checkType(markers, context, TypePosition.RETURN_TYPE);
    if (this.annotations != null) {
        this.annotations.checkTypes(markers, context);
    }
}

Output:
 public void checkTypes(MarkerList markers, IContext context) {
-    if (this.type != null)
+    if (this.type != null) {
         this.type.checkType(markers, context, TypePosition.RETURN_TYPE);


Input:
protected void handlePollCalls(AsyncResult ar) {
    List polledCalls;
    if (ar.exception == null) {
        polledCalls = (List) ar.result;
    } else if (isCommandExceptionRadioNotAvailable(ar.exception)) {
        polledCalls = new ArrayList();
    } else {
        pollCallsAfterDelay();
        return;
    }
    Connection newRinging = null;
    boolean hasNonHangupStateChanged = false;
    boolean needsPollDelay = false;
    boolean unknownConnectionAppeared = false;
    for (int i = 0, curDC = 0, dcSize = polledCalls.size(); i < connections.length; i++) {
        CdmaConnection conn = connections[i];
        DriverCall dc = null;
        if (curDC < dcSize) {
            dc = (DriverCall) polledCalls.get(curDC);
            if (dc.index == i + 1) {
                curDC++;
            } else {
                dc = null;
            }
        }
        if (DBG_POLL)
            log("String_Node_Str" + i + "String_Node_Str" + conn + "String_Node_Str" + dc);
        if (conn == null && dc != null) {
            if (pendingMO != null && pendingMO.compareTo(dc)) {
                if (DBG_POLL)
                    log("String_Node_Str" + pendingMO);
                connections[i] = pendingMO;
                pendingMO.index = i;
                pendingMO.update(dc);
                pendingMO = null;
                if (hangupPendingMO) {
                    hangupPendingMO = false;
                    if (mIsEcmTimerCanceled) {
                        handleEcmTimer(phone.RESTART_ECM_TIMER);
                    }
                    try {
                        if (Phone.DEBUG_PHONE)
                            log("String_Node_Str" + i);
                        hangup(connections[i]);
                    } catch (CallStateException ex) {
                        Log.e(LOG_TAG, "String_Node_Str");
                    }
                    return;
                }
            } else {
                connections[i] = new CdmaConnection(phone.getContext(), dc, this, i);
                if (connections[i].getCall() == ringingCall) {
                    newRinging = connections[i];
                } else {
                    Log.i(LOG_TAG, "String_Node_Str" + dc);
                    if (dc.state != DriverCall.State.ALERTING && dc.state != DriverCall.State.DIALING) {
                        connections[i].connectTime = System.currentTimeMillis();
                    }
                    unknownConnectionAppeared = true;
                }
            }
            hasNonHangupStateChanged = true;
        } else if (conn != null && dc == null) {
            int count = foregroundCall.connections.size();
            if (count == 0) {
                droppedDuringPoll.add(conn);
            } else {
                for (int n = 0; n < count; n++) {
                    CdmaConnection cn = (CdmaConnection) foregroundCall.connections.get(n);
                    droppedDuringPoll.add(cn);
                }
            }
            foregroundCall.setGeneric(false);
            if (mIsEcmTimerCanceled) {
                handleEcmTimer(phone.RESTART_ECM_TIMER);
            } else {
                mIsInEmergencyCall = false;
            }
            connections[i] = null;
        } else if (conn != null && dc != null) {
            boolean changed;
            changed = conn.update(dc);
            hasNonHangupStateChanged = hasNonHangupStateChanged || changed;
        }
        if (REPEAT_POLLING) {
            if (dc != null) {
                if ((dc.state == DriverCall.State.DIALING) || (dc.state == DriverCall.State.ALERTING) || (dc.state == DriverCall.State.INCOMING) || (dc.state == DriverCall.State.WAITING)) {
                    needsPollDelay = true;
                }
            }
        }
    }
    if (pendingMO != null) {
        Log.d(LOG_TAG, "String_Node_Str" + foregroundCall.getState());
        droppedDuringPoll.add(pendingMO);
        pendingMO = null;
        hangupPendingMO = false;
        if (pendingCallInEcm) {
            pendingCallInEcm = false;
        }
    }
    if (newRinging != null) {
        phone.notifyNewRingingConnection(newRinging);
    }
    for (int i = droppedDuringPoll.size() - 1; i >= 0; i--) {
        CdmaConnection conn = droppedDuringPoll.get(i);
        if (conn.isIncoming() && conn.getConnectTime() == 0) {
            Connection.DisconnectCause cause;
            if (conn.cause == Connection.DisconnectCause.LOCAL) {
                cause = Connection.DisconnectCause.INCOMING_REJECTED;
            } else {
                cause = Connection.DisconnectCause.INCOMING_MISSED;
            }
            if (Phone.DEBUG_PHONE) {
                log("String_Node_Str" + conn.cause);
                log("String_Node_Str" + cause);
            }
            droppedDuringPoll.remove(i);
            conn.onDisconnect(cause);
        } else if (conn.cause == Connection.DisconnectCause.LOCAL) {
            droppedDuringPoll.remove(i);
            conn.onDisconnect(Connection.DisconnectCause.LOCAL);
        } else if (conn.cause == Connection.DisconnectCause.INVALID_NUMBER) {
            droppedDuringPoll.remove(i);
            conn.onDisconnect(Connection.DisconnectCause.INVALID_NUMBER);
        }
    }
    if (droppedDuringPoll.size() > 0) {
        cm.getLastCallFailCause(obtainNoPollCompleteMessage(EVENT_GET_LAST_CALL_FAIL_CAUSE));
    }
    if (needsPollDelay) {
        pollCallsAfterDelay();
    }
    if (newRinging != null || hasNonHangupStateChanged) {
        internalClearDisconnected();
    }
    updatePhoneState();
    if (unknownConnectionAppeared) {
        phone.notifyUnknownConnection();
    }
    if (hasNonHangupStateChanged || newRinging != null) {
        phone.notifyPreciseCallStateChanged();
    }
}

Output:
             } else {
-                connections[i] = new CdmaConnection(phone.getContext(), dc, this, i);
-                if (connections[i].getCall() == ringingCall) {
-                    newRinging = connections[i];
-                } else {
-                    Log.i(LOG_TAG, "String_Node_Str" + dc);
-                    if (dc.state != DriverCall.State.ALERTING && dc.state != DriverCall.State.DIALING) {
-                        connections[i].connectTime = System.currentTimeMillis();
-                    }
+                if (Phone.DEBUG_PHONE) {
+                    log("String_Node_Str" + pendingMO + dc);
+                }
+                newRinging = checkMtFindNewRinging(dc, i);
+                if (newRinging == null) {
                     unknownConnectionAppeared = true;


Input:
public void writeJumpInsn(int opcode, Label target) throws BytecodeException {
    if (opcode > 255) {
        switch(opcode) {
            case Opcodes.IF_LCMPEQ:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFEQ, target);
                return;
            case Opcodes.IF_LCMPNE:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFNE, target);
                return;
            case Opcodes.IF_LCMPLT:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFLT, target);
                return;
            case Opcodes.IF_LCMPGE:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFGE, target);
                return;
            case Opcodes.IF_LCMPGT:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFGT, target);
                return;
            case Opcodes.IF_LCMPLE:
                this.writeInsn(Opcodes.LCMP);
                this.writeJumpInsn(Opcodes.IFLE, target);
                return;
            case Opcodes.IF_FCMPEQ:
                this.writeInsn(Opcodes.FCMPL);
                this.writeJumpInsn(Opcodes.IFEQ, target);
                return;
            case Opcodes.IF_FCMPNE:
                this.writeInsn(Opcodes.FCMPL);
                this.writeJumpInsn(Opcodes.IFNE, target);
                return;
            case Opcodes.IF_FCMPLT:
                this.writeInsn(Opcodes.FCMPL);
                this.writeJumpInsn(Opcodes.IFLT, target);
                return;
            case Opcodes.IF_FCMPGE:
                this.writeInsn(Opcodes.FCMPG);
                this.writeJumpInsn(Opcodes.IFGE, target);
                return;
            case Opcodes.IF_FCMPGT:
                this.writeInsn(Opcodes.FCMPG);
                this.writeJumpInsn(Opcodes.IFGT, target);
                return;
            case Opcodes.IF_FCMPLE:
                this.writeInsn(Opcodes.FCMPL);
                this.writeJumpInsn(Opcodes.IFLE, target);
                return;
            case Opcodes.IF_DCMPEQ:
                this.writeInsn(Opcodes.DCMPL);
                this.writeJumpInsn(Opcodes.IFEQ, target);
                return;
            case Opcodes.IF_DCMPNE:
                this.writeInsn(Opcodes.DCMPL);
                this.writeJumpInsn(Opcodes.IFNE, target);
                return;
            case Opcodes.IF_DCMPLT:
                this.writeInsn(Opcodes.DCMPL);
                this.writeJumpInsn(Opcodes.IFLT, target);
                return;
            case Opcodes.IF_DCMPGE:
                this.writeInsn(Opcodes.DCMPG);
                this.writeJumpInsn(Opcodes.IFGE, target);
                return;
            case Opcodes.IF_DCMPGT:
                this.writeInsn(Opcodes.DCMPG);
                this.writeJumpInsn(Opcodes.IFGT, target);
                return;
            case Opcodes.IF_DCMPLE:
                this.writeInsn(Opcodes.DCMPL);
                this.writeJumpInsn(Opcodes.IFLE, target);
                return;
        }
    }
    this.insnCallback();
    this.visitFrame = true;
    this.frame.visitJumpInsn(opcode);
    target.info = this.frame;
    this.frame = this.frame.copy();
    this.mv.visitJumpInsn(opcode, target);
}

Output:
     this.frame.visitJumpInsn(opcode);
-    target.info = this.frame;
-    this.frame = this.frame.copy();
+    if (target.info == null) {
+        target.info = this.frame.copy();
+    }
     this.mv.visitJumpInsn(opcode, target);


Input:
public String toString() {
    String val = null;
    List<BeanDeploymentArchive> beanDeploymentArchives = getBeanDeploymentArchives();
    ListIterator<BeanDeploymentArchive> lIter = beanDeploymentArchives.listIterator();
    while (lIter.hasNext()) {
        BeanDeploymentArchive bda = lIter.next();
        val += bda.toString();
    }
    return val;
}

Output:
 public String toString() {
-    String val = null;
+    StringBuffer valBuff = new StringBuffer();
     List<BeanDeploymentArchive> beanDeploymentArchives = getBeanDeploymentArchives();


Input:
public static List<EDaoDan> getMissileInArea(Region2 region) {
    cleanUpMissiles();
    List<EDaoDan> returnArray = new ArrayList<EDaoDan>();
    for (EDaoDan missile : missiles) {
        if (region.isIn(Vector3.get(missile).toVector2())) {
            returnArray.add(missile);
        }
    }
    return returnArray;
}

Output:
     for (EDaoDan missile : missiles) {
-        if (region.isIn(Vector3.get(missile).toVector2())) {
+        if (Vector2.distance(vector, Vector3.get(missile).toVector2()) <= radius) {
             returnArray.add(missile);


Input:
public TypedReturnCode<IFile> create(ModelElement element, IFolder folder) {
    TypedReturnCode<IFile> trc = new TypedReturnCode<IFile>();
    if (getFileExtension() == null) {
        trc.setMessage("String_Node_Str");
        log.error("String_Node_Str");
    } else {
        String fname = DqRepositoryViewService.createLogicalFileNmae(element, getFileExtension());
        IFile file = folder.getFile(fname);
        if (file.exists()) {
            trc.setReturnCode("String_Node_Str", false);
        } else {
            ReturnCode rc = save(element, file);
            trc.setReturnCode(rc.getMessage(), rc.isOk(), file);
        }
    }
    return trc;
}

Output:
     } else {
-        String fname = DqRepositoryViewService.createLogicalFileNmae(element, getFileExtension());
+        String fname = DqRepositoryViewService.createLogicalFileName(element, getFileExtension());
         IFile file = folder.getFile(fname);


Input:
public void writeLaunchConfig(File stageDir, File utilDir) throws IOException {
    File pathEXE = new File(stageDir, "String_Node_Str");
    File pathICO = new File(utilDir, "String_Node_Str");
    scanJARs(new File(utilDir, "String_Node_Str"));
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(new File(stageDir, "String_Node_Str"))));
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str" + this.mainJar + "String_Node_Str");
    out.println("String_Node_Str" + pathEXE + "String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str" + pathICO + "String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    for (String cp : this.classpath) {
        out.println("String_Node_Str" + cp + "String_Node_Str");
    }
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.println("String_Node_Str");
    out.close();
}

Output:
     File pathICO = new File(utilDir, "String_Node_Str");
-    scanJARs(new File(utilDir, "String_Node_Str"));
-    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(new File(stageDir, "String_Node_Str"))));
+    scanJARs(new File(stageDir, "String_Node_Str"));
+    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(new File(utilDir, "String_Node_Str"))));
     out.println("String_Node_Str");


Input:
public static void mockGrailsProject(IProject project, GrailsVersion grailsVersion) throws Exception {
    IClasspathEntry[] classpath = JavaCore.create(project).getRawClasspath();
    boolean wasAutobuilding = isAutoBuilding();
    try {
        setAutoBuilding(false);
        Hashtable options = JavaCore.getDefaultOptions();
        options.put(JavaCore.COMPILER_COMPLIANCE, "String_Node_Str");
        options.put(JavaCore.COMPILER_SOURCE, "String_Node_Str");
        JavaCore.setOptions(options);
        addGrailsNature(project);
        grailsVersion.setOn(project);
        Set<String> dependencies = findDependencies();
        for (String file : dependencies) {
            if (new File(file).isFile()) {
                if (!(file.contains("String_Node_Str") || file.contains("String_Node_Str"))) {
                    addExternalLibrary(project, file);
                }
            } else {
                System.out.println("String_Node_Str" + file);
            }
        }
        GroovyRuntime.addGroovyClasspathContainer(JavaCore.create(project));
        File grailsDSLD = GrailsTestsActivator.getGrailsDSLD();
        addExternalLibrary(project, grailsDSLD.getCanonicalPath());
        new RefreshDSLDJob(project).run(null);
    } finally {
        setAutoBuilding(wasAutobuilding);
    }
}

Output:
         addGrailsNature(project);
-        grailsVersion.setOn(project);
+        grailsVersion.setOn(project, true);
         Set<String> dependencies = findDependencies();


Input:
private static boolean verifyStapANaluLengths(byte[] data, int offset, int lengthRemaining) {
    int initialLength = lengthRemaining;
    while (lengthRemaining > 0 && offset + 1 < initialLength) {
        if (lengthRemaining < kNalUSize) {
            return false;
        }
        int naluSize = data[offset] << 8 | data[offset + 1];
        offset += kNalUSize;
        lengthRemaining -= kNalUSize;
        if (naluSize > lengthRemaining) {
            return false;
        }
        offset += naluSize;
        lengthRemaining -= naluSize;
    }
    return true;
}

Output:
     int initialLength = lengthRemaining;
-    while (lengthRemaining > 0 && offset + 1 < initialLength) {
+    while (lengthRemaining > 0 && offset + 1 < initialLength && offset > 0) {
         if (lengthRemaining < kNalUSize) {


Input:
public void refreshUI() {
    logError(null);
    resizeTableColumns();
    canUpdate = false;
    CloudFoundryApplicationModule appModule = null;
    try {
        appModule = getUpdatedApplication();
    } catch (CoreException ce) {
        logApplicationModuleFailureError("String_Node_Str");
    }
    refreshPublishState(appModule);
    if (appModule == null) {
        return;
    }
    if (saveManifest != null) {
        ManifestParser parser = new ManifestParser(appModule, cloudServer);
        if (!parser.canWriteToManifest()) {
            saveManifest.setEnabled(false);
        } else {
            saveManifest.setEnabled(true);
        }
    }
    updateServerNameDisplay(appModule);
    int state = appModule.getState();
    setCurrentStartDebugApplicationAction();
    instanceSpinner.setSelection(appModule.getInstanceCount());
    refreshApplicationDeploymentButtons(appModule);
    mappedURIsLink.setEnabled(state == IServer.STATE_STARTED);
    CloudApplication cloudApplication = appModule.getApplication();
    instanceSpinner.setEnabled(cloudApplication != null);
    instancesViewer.getTable().setEnabled(cloudApplication != null);
    instancesViewer.setInput(null);
    memoryCombo.setEnabled(cloudApplication != null);
    if (cloudApplication != null) {
        int appMemory = appModule.getApplication().getMemory();
        memoryCombo.removeAll();
        boolean found = false;
        int[] applicationMemoryChoices = editorPage.getApplicationMemoryChoices();
        if (applicationMemoryChoices != null) {
            for (int option : applicationMemoryChoices) {
                memoryCombo.add(option + "String_Node_Str");
                if (option == appMemory) {
                    int index = memoryCombo.getItemCount() - 1;
                    memoryCombo.select(index);
                    found = true;
                }
            }
            if (!found && appMemory != 0) {
                memoryCombo.add(appMemory + "String_Node_Str", 0);
                memoryCombo.select(0);
            }
            memoryCombo.setEnabled(true);
            memoryCombo.redraw();
        }
    }
    List<String> currentURIs = null;
    if (cloudApplication != null) {
        currentURIs = cloudApplication.getUris();
        ApplicationStats applicationStats = appModule.getApplicationStats();
        InstancesInfo instancesInfo = appModule.getInstancesInfo();
        if (applicationStats != null) {
            List<InstanceStats> statss = applicationStats.getRecords();
            List<InstanceInfo> infos = instancesInfo != null ? instancesInfo.getInstances() : null;
            InstanceStatsAndInfo[] statsAndInfos = new InstanceStatsAndInfo[statss.size()];
            for (int i = 0; i < statss.size(); i++) {
                InstanceStats stats = statss.get(i);
                InstanceInfo info = null;
                if (infos != null && infos.size() > i) {
                    info = infos.get(i);
                }
                statsAndInfos[i] = new InstanceStatsAndInfo(stats, info);
            }
            instancesViewer.setInput(statsAndInfos);
        }
    }
    if (currentURIs == null && !isPublished) {
        currentURIs = appModule.getDeploymentInfo() != null ? appModule.getDeploymentInfo().getUris() : null;
    }
    if (currentURIs == null) {
        currentURIs = Collections.emptyList();
    }
    if (!currentURIs.equals(URIs)) {
        URIs = currentURIs;
        mappedURIsLink.setText(getURIsAsLinkText(URIs));
        generalSection.getParent().layout(true, true);
        editorPage.reflow();
    }
    if (provideServices) {
        List<CloudService> updatedServices = new ArrayList<CloudService>();
        DeploymentInfoWorkingCopy deploymentInfo = appModule.getDeploymentInfoWorkingCopy();
        List<String> serviceNames = deploymentInfo.asServiceBindingList();
        if (serviceNames != null && !serviceNames.isEmpty()) {
            List<CloudService> allServices = editorPage.getServices();
            if (allServices != null) {
                for (CloudService service : allServices) {
                    if (serviceNames.contains(service.getName())) {
                        updatedServices.add(service);
                    }
                }
                if (!updatedServices.isEmpty()) {
                    deploymentInfo.setServices(updatedServices);
                    deploymentInfo.save();
                }
            }
            servicesViewer.setInput(updatedServices.toArray(new CloudService[updatedServices.size()]));
        }
        servicesDropListener.setModule(appModule);
        servicesViewer.refresh(true);
    }
    instancesViewer.refresh(true);
    canUpdate = true;
    if (appModule.getErrorMessage() != null) {
        editorPage.setMessage(appModule.getErrorMessage(), IMessageProvider.ERROR);
    } else {
        editorPage.setMessage(null, IMessageProvider.ERROR);
    }
}

Output:
         int[] applicationMemoryChoices = editorPage.getApplicationMemoryChoices();
-        if (applicationMemoryChoices != null) {
+        if (applicationMemoryChoices != null && applicationMemoryChoices.length > 0) {
+            boolean found = false;
+            memoryCombo.removeAll();
             for (int option : applicationMemoryChoices) {


Input:
public void run() throws EngineException {
    doValidateParameters();
    loadDesign();
}

Output:
 public void run() throws EngineException {
-    doValidateParameters();
+    usingParameterValues();
     loadDesign();


Input:
public static Set<PlayerGain> parseConfig(ConfigurationSection config) {
    Set<PlayerGain> gain = Collections.emptySet();
    if (config != null && DependencyUtils.hasFactions()) {
        Map<String, Double> multipliers = new HashMap<String, Double>();
        for (String relation : config.getKeys(false)) {
            try {
                multipliers.put(relation, Double.valueOf(config.getConfigurationSection(relation).getDouble(AMOUNT_KEY, NO_GAIN)));
            } catch (IllegalArgumentException e) {
                LoggerUtil.getInstance().warning("String_Node_Str" + relation);
            }
        }
        gain = new HashSet<PlayerGain>();
        gain.add(new FactionsGain(multipliers));
    }
    return gain;
}

Output:
     if (config != null && DependencyUtils.hasFactions()) {
-        Map<String, Double> multipliers = new HashMap<String, Double>();
+        Map<Rel, Double> multipliers = new HashMap<Rel, Double>();
         for (String relation : config.getKeys(false)) {


Input:
private void initComponents(boolean isPlayback) {
    super.removeAll();
    menu.setVisible(false);
    inCheck = new JLabel("String_Node_Str");
    inCheck.setHorizontalTextPosition(inCheck.CENTER);
    inCheck.setForeground(Color.RED);
    int ifDouble = 0;
    Driver.getInstance().setMenu(createMenu());
    setLayout(new GridBagLayout());
    GridBagConstraints c = new GridBagConstraints();
    final Board[] boards = getGame().getBoards();
    this.setBorder(BorderFactory.createLoweredBevelBorder());
    inCheck.setHorizontalTextPosition(SwingConstants.CENTER);
    inCheck.setHorizontalAlignment(SwingConstants.CENTER);
    c.fill = GridBagConstraints.NONE;
    c.gridy = 0;
    c.gridx = 9;
    inCheck.setVisible(false);
    this.add(inCheck, c);
    if (boards.length == 1) {
        c.gridheight = 12;
        c.gridy = 2;
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridwidth = 10;
        c.gridheight = 10;
        c.insets = new Insets(10, 0, 0, 0);
        c.gridx = 0;
        this.add(createGrid(boards[0], isPlayback), c);
    } else {
        c.gridheight = 12;
        c.gridy = 2;
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridwidth = 10;
        c.insets = new Insets(10, 0, 0, 0);
        c.gridx = 0;
        this.add(createGrid(boards[0], isPlayback), c);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.gridwidth = 10;
        c.insets = new Insets(10, 0, 0, 0);
        c.gridx = 11;
        this.add(createGrid(boards[1], isPlayback), c);
        ifDouble += 10;
    }
    JButton nextButt = new JButton("String_Node_Str");
    nextButt.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            if (index + 1 == history.length)
                return;
            try {
                history[++index].execute();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    });
    JButton prevButt = new JButton("String_Node_Str");
    prevButt.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            if (index == -1)
                return;
            history[index--].undo();
        }
    });
    whiteLabel = new JLabel("String_Node_Str");
    whiteLabel.setHorizontalAlignment(SwingConstants.CENTER);
    whiteLabel.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    blackLabel = new JLabel("String_Node_Str");
    blackLabel.setHorizontalAlignment(SwingConstants.CENTER);
    blackLabel.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    whiteLabel.setOpaque(true);
    blackLabel.setOpaque(true);
    whiteLabel.setBackground(getGame().isBlackMove() ? null : Square.HIGHLIGHT_COLOR);
    int k;
    if (getGame().getWhiteTeam().size() <= 4 && getGame().getBlackTeam().size() <= 4) {
        k = 4;
    } else {
        double o = getGame().getWhiteTeam().size() > getGame().getBlackTeam().size() ? Math.sqrt(getGame().getWhiteTeam().size()) : Math.sqrt(getGame().getBlackTeam().size());
        k = (int) Math.ceil(o);
    }
    whiteCaptures = new JPanel();
    whiteCaptures.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    whiteCapturesBox = new Jail(k, k);
    whiteCaptures.setLayout(new GridLayout(k, k));
    whiteCaptures.setPreferredSize(new Dimension((whiteCapturesBox.numCols() + 1) * 25, (whiteCapturesBox.numRows() + 1) * 25));
    for (int i = k; i > 0; i--) {
        for (int j = 1; j <= k; j++) {
            JButton jb = new JButton();
            whiteCapturesBox.getSquare(i, j).setButton(jb);
            whiteCaptures.add(jb);
        }
    }
    blackCaptures = new JPanel();
    blackCaptures.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
    blackCapturesBox = new Jail(k, k);
    blackCaptures.setLayout(new GridLayout(k, k));
    blackCaptures.setPreferredSize(new Dimension((blackCapturesBox.numCols() + 1) * 25, (blackCapturesBox.numRows() + 1) * 25));
    for (int i = k; i > 0; i--) {
        for (int j = 1; j <= k; j++) {
            JButton jb = new JButton();
            blackCapturesBox.getSquare(i, j).setButton(jb);
            blackCaptures.add(jb);
        }
    }
    c.fill = GridBagConstraints.NONE;
    c.anchor = GridBagConstraints.BASELINE;
    c.gridwidth = 3;
    c.gridheight = 1;
    c.insets = new Insets(10, 10, 10, 0);
    c.ipadx = 100;
    c.gridx = 11 + ifDouble;
    c.gridy = 0;
    this.add(blackLabel, c);
    c.fill = GridBagConstraints.NONE;
    c.anchor = GridBagConstraints.BASELINE;
    c.gridwidth = 3;
    c.gridheight = 3;
    c.ipadx = 0;
    c.insets = new Insets(0, 25, 10, 25);
    c.gridx = 11 + ifDouble;
    c.gridy = 1;
    this.add(blackCaptures, c);
    if (!isPlayback) {
        c.fill = GridBagConstraints.HORIZONTAL;
        c.anchor = GridBagConstraints.BASELINE;
        c.gridwidth = 3;
        c.gridheight = 1;
        c.ipadx = 100;
        c.gridx = 11 + ifDouble;
        c.gridy = 4;
        this.add(blackTimer.getLabel(), c);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.anchor = GridBagConstraints.BASELINE;
        c.gridwidth = 3;
        c.gridheight = 1;
        c.ipadx = 100;
        c.gridx = 11 + ifDouble;
        c.gridy = 6;
        this.add(whiteTimer.getLabel(), c);
    } else {
        c.fill = GridBagConstraints.HORIZONTAL;
        c.anchor = GridBagConstraints.BASELINE;
        c.gridwidth = 3;
        c.gridheight = 1;
        c.ipadx = 100;
        c.gridx = 11 + ifDouble;
        c.gridy = 4;
        this.add(nextButt, c);
        c.fill = GridBagConstraints.HORIZONTAL;
        c.anchor = GridBagConstraints.BASELINE;
        c.gridwidth = 3;
        c.gridheight = 1;
        c.ipadx = 100;
        c.gridx = 11 + ifDouble;
        c.gridy = 5;
        this.add(prevButt, c);
    }
    c.fill = GridBagConstraints.NONE;
    c.anchor = GridBagConstraints.BASELINE;
    c.gridwidth = 3;
    c.gridheight = 3;
    c.ipadx = 0;
    c.gridx = 11 + ifDouble;
    if (whiteTimer instanceof NoTimer) {
        c.gridy = 6;
        c.insets = new Insets(10, 25, 0, 25);
    } else {
        c.gridy = 7;
        c.insets = new Insets(0, 25, 0, 25);
    }
    this.add(whiteCaptures, c);
    c.fill = GridBagConstraints.NONE;
    c.anchor = GridBagConstraints.BASELINE;
    c.gridwidth = 3;
    c.weightx = 0.0;
    c.weighty = 0.0;
    c.insets = new Insets(10, 0, 10, 0);
    if (whiteTimer instanceof NoTimer) {
        c.gridheight = 1;
        c.gridy = 9;
    } else {
        c.gridheight = 2;
        c.gridy = 11;
    }
    c.ipadx = 100;
    c.gridx = 11 + ifDouble;
    this.add(whiteLabel, c);
}

Output:
     whiteCaptures.setBorder(BorderFactory.createTitledBorder("String_Node_Str"));
-    whiteCapturesBox = new Jail(k, k);
-    whiteCaptures.setLayout(new GridLayout(k, k));
+    if (k < 4) {
+        whiteCapturesBox = new Jail(4, 4);
+        whiteCaptures.setLayout(new GridLayout(4, 4));
+    } else {
+        whiteCapturesBox = new Jail(k, k);
+        whiteCaptures.setLayout(new GridLayout(k, k));
+    }
     whiteCaptures.setPreferredSize(new Dimension((whiteCapturesBox.numCols() + 1) * 25, (whiteCapturesBox.numRows() + 1) * 25));


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.route_info);
    registerForContextMenu(getExpandableListView());
    Bundle bundle = getIntent().getExtras();
    mRouteId = bundle.getString(ROUTE_ID);
    setListAdapter(new SimpleExpandableListAdapter(this, new ArrayList<HashMap<String, String>>(), android.R.layout.simple_expandable_list_item_1, new String[] { "String_Node_Str" }, new int[] { android.R.id.text1 }, new ArrayList<ArrayList<HashMap<String, String>>>(), 0, null, new int[] {}));
    Object config = getLastNonConfigurationInstance();
    if (config != null) {
        Object[] results = (Object[]) config;
        setHeader((ObaResponse) results[0], false);
        setStopsForRoute((StopsForRouteInfo) results[1]);
    } else {
        mRouteInfoTask = new GetRouteInfo().execute(mRouteId);
    }
}

Output:
     registerForContextMenu(getExpandableListView());
-    Bundle bundle = getIntent().getExtras();
-    mRouteId = bundle.getString(ROUTE_ID);
+    final Intent intent = getIntent();
+    final Bundle bundle = intent.getExtras();
+    final Uri data = intent.getData();
+    if (data != null) {
+        mRouteId = data.getLastPathSegment();
+    } else if (bundle != null) {
+        mRouteId = bundle.getString(ROUTE_ID);
+    } else {
+        Log.e(TAG, "String_Node_Str");
+        finish();
+        return;
+    }
     setListAdapter(new SimpleExpandableListAdapter(this, new ArrayList<HashMap<String, String>>(), android.R.layout.simple_expandable_list_item_1, new String[] { "String_Node_Str" }, new int[] { android.R.id.text1 }, new ArrayList<ArrayList<HashMap<String, String>>>(), 0, null, new int[] {}));


Input:
private double getMarginalLogLikelihoodForExample(int i) {
    FgExample ex = data.get(i);
    FeatureTemplateList fts = data.getTemplates();
    FgInferencer infLat = infLatList.get(i);
    FactorGraph fgLat = ex.updateFgLat(model, infLat.isLogDomain());
    infLat.run();
    double numerator = infLat.isLogDomain() ? infLat.getPartition() : Utilities.log(infLat.getPartition());
    for (int a = 0; a < fgLat.getNumFactors(); a++) {
        Factor f = fgLat.getFactor(a);
        if (f.getVars().size() == 0) {
            if (f instanceof ExpFamFactor) {
                int goldConfig = ex.getGoldConfigIdxPred(a);
                double[] params = model.getParams(fts.getTemplateId(f), goldConfig);
                numerator += ex.getObservationFeatures(a).dot(params);
            } else {
                throw new UnsupportedFactorTypeException(f);
            }
        }
    }
    infLat.clear();
    FgInferencer infLatPred = infLatPredList.get(i);
    FactorGraph fgLatPred = ex.updateFgLatPred(model, infLatPred.isLogDomain());
    infLatPred.run();
    double denominator = infLatPred.isLogDomain() ? infLatPred.getPartition() : Utilities.log(infLatPred.getPartition());
    for (int a = 0; a < fgLatPred.getNumFactors(); a++) {
        Factor f = fgLatPred.getFactor(a);
        if (f.getVars().size() == 0) {
            if (f instanceof ExpFamFactor) {
                int goldConfig = ex.getGoldConfigIdxPred(a);
                double[] params = model.getParams(fts.getTemplateId(f), goldConfig);
                denominator += ex.getObservationFeatures(a).dot(params);
            } else {
                throw new UnsupportedFactorTypeException(f);
            }
        }
    }
    infLatPred.clear();
    double ll = numerator - denominator;
    if (ll > MAX_LOG_LIKELIHOOD) {
        log.warn("String_Node_Str" + ll);
    }
    return ll;
}

Output:
     FeatureTemplateList fts = data.getTemplates();
-    FgInferencer infLat = infLatList.get(i);
+    FgInferencer infLat = getInfLat(ex);
     FactorGraph fgLat = ex.updateFgLat(model, infLat.isLogDomain());


Input:
public void onPhotoChanged(int index, Path item) {
    int oldIndex = mCurrentIndex;
    mCurrentIndex = index;
    if (mAppBridge != null) {
        if (mCurrentIndex > 0) {
            mSkipUpdateCurrentPhoto = false;
        }
        if (oldIndex == 0 && mCurrentIndex > 0 && !mPhotoView.getFilmMode()) {
            mPhotoView.setFilmMode(true);
        } else if (oldIndex == 2 && mCurrentIndex == 1) {
            mCameraSwitchCutoff = SystemClock.uptimeMillis() + CAMERA_SWITCH_CUTOFF_THRESHOLD_MS;
            mPhotoView.stopScrolling();
        } else if (oldIndex == 1 && mCurrentIndex == 0) {
            mPhotoView.setWantPictureCenterCallbacks(true);
            mSkipUpdateCurrentPhoto = true;
        }
    }
    if (!mSkipUpdateCurrentPhoto) {
        if (item != null) {
            MediaItem photo = mModel.getMediaItem(0);
            if (photo != null)
                updateCurrentPhoto(photo);
        }
        updateBars();
    }
    refreshHidingMessage();
}

Output:
             mPhotoView.stopScrolling();
-        } else if (oldIndex == 1 && mCurrentIndex == 0) {
+        } else if (oldIndex >= 1 && mCurrentIndex == 0) {
             mPhotoView.setWantPictureCenterCallbacks(true);


Input:
public void testHttpUrnRequest() {
    for (int i = 0; i < _fileManager.getNumFiles(); i++) {
        FileDesc fd = _fileManager.get(i);
        String request = "String_Node_Str" + fd.getSHA1Urn().httpStringValue() + "String_Node_Str";
        sendRequestThatShouldSucceed(HTTPRequestMethod.GET, request, fd);
        sendRequestThatShouldSucceed(HTTPRequestMethod.HEAD, request, fd);
    }
}

Output:
 public void testHttpUrnRequest() {
-    for (int i = 0; i < _fileManager.getNumFiles(); i++) {
-        FileDesc fd = _fileManager.get(i);
+    for (int i = 0; i < RouterService.getFileManager().getNumFiles(); i++) {
+        FileDesc fd = RouterService.getFileManager().get(i);
         String request = "String_Node_Str" + fd.getSHA1Urn().httpStringValue() + "String_Node_Str";


Input:
private boolean processMicroPdf417() {
    int i, k, j, blockCount, longueur, offset;
    int total;
    int LeftRAPStart, CentreRAPStart, RightRAPStart, StartCluster;
    int LeftRAP, CentreRAP, RightRAP, Cluster, flip, loop;
    String codebarre;
    int[] dummy = new int[5];
    int[] mccorrection = new int[50];
    int length = inputData.length;
    EncodingMode currentEncodingMode;
    String bin;
    blockIndex = 0;
    blockCount = 0;
    currentEncodingMode = chooseMode(inputData[blockCount]);
    for (i = 0; i < 1000; i++) {
        blockLength[i] = 0;
    }
    do {
        blockType[blockIndex] = currentEncodingMode;
        while ((blockType[blockIndex] == currentEncodingMode) && (blockCount < length)) {
            blockLength[blockIndex]++;
            blockCount++;
            if (blockCount != length) {
                currentEncodingMode = chooseMode(inputData[blockCount]);
            }
        }
        blockIndex++;
    } while (blockCount < length);
    for (i = 0; i < blockIndex; i++) {
        if ((blockType[i] == EncodingMode.NUM) && (blockLength[i] > 44)) {
            for (j = blockIndex + 1; j > (i + 1); j--) {
                blockType[j] = blockType[j - 1];
                blockLength[j] = blockLength[j - 1];
            }
            blockType[i + 1] = blockType[i];
            blockLength[i + 1] = blockLength[i] - 44;
            blockLength[i] = 44;
            blockIndex++;
        }
    }
    pdfSmooth();
    blockCount = 0;
    codeWordCount = 0;
    if (readerInit) {
        codeWords[codeWordCount] = 921;
        codeWordCount++;
    }
    if (eciMode != 3) {
        if (eciMode <= 899) {
            codeWords[codeWordCount] = 927;
            codeWordCount++;
            codeWords[codeWordCount] = eciMode;
            codeWordCount++;
        }
        if ((eciMode >= 900) && (eciMode <= 810899)) {
            codeWords[codeWordCount] = 926;
            codeWordCount++;
            codeWords[codeWordCount] = (eciMode / 900) - 1;
            codeWordCount++;
            codeWords[codeWordCount] = eciMode % 900;
            codeWordCount++;
        }
        if ((eciMode >= 810900) && (eciMode <= 811799)) {
            codeWords[codeWordCount] = 925;
            codeWordCount++;
            codeWords[codeWordCount] = eciMode - 810900;
            codeWordCount++;
        }
    }
    for (i = 0; i < blockIndex; i++) {
        switch(blockType[i]) {
            case TEX:
                processText(blockCount, blockLength[i], false);
                break;
            case BYT:
                processBytes(blockCount, blockLength[i]);
                break;
            case NUM:
                processNumbers(blockCount, blockLength[i]);
                break;
            default:
                throw new OkapiException("String_Node_Str" + blockType[i]);
        }
        blockCount = blockCount + blockLength[i];
    }
    encodeInfo += "String_Node_Str";
    for (i = 0; i < codeWordCount; i++) {
        encodeInfo += Integer.toString(codeWords[i]) + "String_Node_Str";
    }
    encodeInfo += "String_Node_Str";
    if (!validateRows(4, 44) || !validateColumns(1, 4)) {
        return false;
    }
    if (columns != null) {
        int max;
        switch(columns) {
            case 1:
                max = 20;
                break;
            case 2:
                max = 37;
                break;
            case 3:
                max = 82;
                break;
            case 4:
                max = 126;
                break;
            default:
                throw new OkapiException("String_Node_Str" + columns);
        }
        if (codeWordCount > max) {
            error_msg = "String_Node_Str" + columns + "String_Node_Str" + codeWordCount + "String_Node_Str";
            return false;
        }
    }
    int variant = getMicroPdf417Variant(codeWordCount, columns, rows);
    variant--;
    columns = MICRO_VARIANTS[variant];
    rows = MICRO_VARIANTS[variant + 34];
    k = MICRO_VARIANTS[variant + 68];
    longueur = (columns * rows) - k;
    i = longueur - codeWordCount;
    offset = MICRO_VARIANTS[variant + 102];
    encodeInfo += "String_Node_Str" + longueur + "String_Node_Str";
    encodeInfo += "String_Node_Str" + k + "String_Node_Str";
    while (i > 0) {
        codeWords[codeWordCount] = 900;
        codeWordCount++;
        i--;
    }
    longueur = codeWordCount;
    for (loop = 0; loop < 50; loop++) {
        mccorrection[loop] = 0;
    }
    for (i = 0; i < longueur; i++) {
        total = (codeWords[i] + mccorrection[k - 1]) % 929;
        for (j = k - 1; j >= 0; j--) {
            if (j == 0) {
                mccorrection[j] = (929 - (total * MICRO_COEFFS[offset + j]) % 929) % 929;
            } else {
                mccorrection[j] = (mccorrection[j - 1] + 929 - (total * MICRO_COEFFS[offset + j]) % 929) % 929;
            }
        }
    }
    for (j = 0; j < k; j++) {
        if (mccorrection[j] != 0) {
            mccorrection[j] = 929 - mccorrection[j];
        }
    }
    for (i = k - 1; i >= 0; i--) {
        codeWords[codeWordCount] = mccorrection[i];
        codeWordCount++;
    }
    LeftRAPStart = RAP_TABLE[variant];
    CentreRAPStart = RAP_TABLE[variant + 34];
    RightRAPStart = RAP_TABLE[variant + 68];
    StartCluster = RAP_TABLE[variant + 102] / 3;
    LeftRAP = LeftRAPStart;
    CentreRAP = CentreRAPStart;
    RightRAP = RightRAPStart;
    Cluster = StartCluster;
    readable = "String_Node_Str";
    pattern = new String[rows];
    row_count = rows;
    row_height = new int[rows];
    encodeInfo += "String_Node_Str" + columns + "String_Node_Str" + row_count + "String_Node_Str";
    for (i = 0; i < rows; i++) {
        codebarre = "String_Node_Str";
        offset = 929 * Cluster;
        for (j = 0; j < 5; j++) {
            dummy[j] = 0;
        }
        for (j = 0; j < columns; j++) {
            dummy[j + 1] = codeWords[i * columns + j];
        }
        codebarre += RAPLR[LeftRAP];
        codebarre += "String_Node_Str";
        codebarre += CODAGEMC[offset + dummy[1]];
        codebarre += "String_Node_Str";
        if (columns == 3) {
            codebarre += RAPC[CentreRAP];
        }
        if (columns >= 2) {
            codebarre += "String_Node_Str";
            codebarre += CODAGEMC[offset + dummy[2]];
            codebarre += "String_Node_Str";
        }
        if (columns == 4) {
            codebarre += RAPC[CentreRAP];
        }
        if (columns >= 3) {
            codebarre += "String_Node_Str";
            codebarre += CODAGEMC[offset + dummy[3]];
            codebarre += "String_Node_Str";
        }
        if (columns == 4) {
            codebarre += "String_Node_Str";
            codebarre += CODAGEMC[offset + dummy[4]];
            codebarre += "String_Node_Str";
        }
        codebarre += RAPLR[RightRAP];
        codebarre += "String_Node_Str";
        flip = 1;
        bin = "String_Node_Str";
        for (loop = 0; loop < codebarre.length(); loop++) {
            if ((codebarre.charAt(loop) >= '0') && (codebarre.charAt(loop) <= '9')) {
                for (k = 0; k < Character.getNumericValue(codebarre.charAt(loop)); k++) {
                    if (flip == 0) {
                        bin += '0';
                    } else {
                        bin += '1';
                    }
                }
                if (flip == 0) {
                    flip = 1;
                } else {
                    flip = 0;
                }
            } else {
                bin += PDF_TTF[positionOf(codebarre.charAt(loop), BR_SET)];
            }
        }
        pattern[i] = bin2pat(bin);
        row_height[i] = default_height;
        LeftRAP++;
        CentreRAP++;
        RightRAP++;
        Cluster++;
        if (LeftRAP == 53) {
            LeftRAP = 1;
        }
        if (CentreRAP == 53) {
            CentreRAP = 1;
        }
        if (RightRAP == 53) {
            RightRAP = 1;
        }
        if (Cluster == 3) {
            Cluster = 0;
        }
    }
    return true;
}

Output:
             case BYT:
-                processBytes(blockCount, blockLength[i]);
+                EncodingMode lastMode = (i == 0 ? EncodingMode.TEX : blockType[i - 1]);
+                processBytes(blockCount, blockLength[i], lastMode);
                 break;


Input:
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
    this.drawDefaultBackground();
    super.drawScreen(mouseX, mouseY, partialTicks);
    DecimalFormat format = new DecimalFormat("String_Node_Str");
    EntityPlayer player = mc.player;
    PlayerInformation playerInfo = (PlayerInformation) player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION, null);
    Stats statsCap = (Stats) player.getCapability(CapabilityPlayerStats.STATS, null);
    if (player != null && playerInfo != null && statsCap != null) {
        this.drawCenteredString(this.fontRenderer, I18n.format("String_Node_Str"), this.width / 2, 20, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str" + I18n.format("String_Node_Str" + playerInfo.getPlayerClass()), this.width / 2 - 50, 40, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getPlayerLevel(), this.width / 2 - 50, 50, 0xFFFFFF);
        String experience = I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getPlayerExperience() + "String_Node_Str" + playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel());
        double percent = (((double) playerInfo.getPlayerExperience() * 100) / (double) (playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())));
        String percentString = "String_Node_Str" + String.format("String_Node_Str", percent) + "String_Node_Str";
        this.drawString(this.fontRenderer, experience + percentString, this.width / 2 - 50, 60, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getSkillPoints(), this.width / 2 - 50, 70, 0xFFFFFF);
        this.drawCenteredString(this.fontRenderer, I18n.format("String_Node_Str"), this.width / 2 + 120, 120, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 140, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 150, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 160, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 170, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 180, 0xFFFFFF);
        this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str", this.width / 2 + 80, 190, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getStrengthStat() + playerInfo.getBonusStrengthStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusStrengthStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 140, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getAgilityStat() + playerInfo.getBonusAgilityStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusAgilityStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 150, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getDexterityStat() + playerInfo.getBonusDexterityStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusDexterityStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 160, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getIntelligenceStat() + playerInfo.getBonusIntelligenceStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusIntelligenceStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 170, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getWisdomStat() + playerInfo.getBonusWisdomStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusWisdomStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 180, 0xFFFFFF);
        this.drawString(this.fontRenderer, "String_Node_Str" + (playerInfo.getFortitudeStat() + playerInfo.getBonusFortitudeStat()) + "String_Node_Str" + TextFormatting.GREEN + "String_Node_Str" + playerInfo.getBonusFortitudeStat() + TextFormatting.WHITE + "String_Node_Str", this.width / 2 + 150, 190, 0xFFFFFF);
        double playerDamage = (Math.pow(Configs.weaponCategory.damageBaseFactor, playerInfo.getPlayerLevel()) + playerInfo.getTotalStrength()) * (0.85 * 0.8);
        double magicalPower = (Math.pow(Configs.weaponCategory.damageBaseFactor, playerInfo.getPlayerLevel()) + playerInfo.getTotalIntelligence()) * (0.85 * 0.8);
        playerDamage = playerDamage < 1 ? 0 : playerDamage;
        magicalPower = magicalPower < 1 ? 0 : magicalPower;
        this.drawCenteredString(this.fontRenderer, I18n.format("String_Node_Str"), this.width / 2 - 130, 120, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + format.format(playerDamage), this.width / 2 - 160, 140, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + format.format(magicalPower), this.width / 2 - 160, 150, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + format.format((Configs.playerCategory.attackSpeedMultiplier * (playerInfo.getTotalAgility()))), this.width / 2 - 160, 160, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + format.format(DamageUtils.getTotalArmor(player, playerInfo)), this.width / 2 - 160, 170, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + ((int) (statsCap.getCriticalChance() * 100)) + "String_Node_Str", this.width / 2 - 160, 180, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + ((int) (statsCap.getCriticalDamage() * 100)) + "String_Node_Str", this.width / 2 - 160, 190, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + (int) (Configs.playerCategory.maxHealthMultiplier * (playerInfo.getTotalFortitude())), this.width / 2 - 160, 200, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + statsCap.getHealthPerSecond(), this.width / 2 - 160, 210, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + "String_Node_Str" + (int) (Configs.playerCategory.maxManaMultiplier * (playerInfo.getTotalWisdom())), this.width / 2 - 160, 220, 0xFFFFFF);
        this.drawString(this.fontRenderer, TextFormatting.GRAY + I18n.format("String_Node_Str") + "String_Node_Str" + TextFormatting.WHITE + statsCap.getManaPerSecond(), this.width / 2 - 160, 230, 0xFFFFFF);
        drawTooltips(mouseX, mouseY);
    }
}

Output:
         this.drawString(this.fontRenderer, I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getPlayerLevel(), this.width / 2 - 50, 50, 0xFFFFFF);
-        String experience = I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getPlayerExperience() + "String_Node_Str" + playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel());
-        double percent = (((double) playerInfo.getPlayerExperience() * 100) / (double) (playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())));
+        String experience = I18n.format("String_Node_Str") + "String_Node_Str" + playerInfo.getPlayerExperience() + "String_Node_Str" + ExperienceUtils.getLevelUpExperience(playerInfo.getPlayerLevel());
+        double percent = (((double) playerInfo.getPlayerExperience() * 100) / (double) (ExperienceUtils.getLevelUpExperience(playerInfo.getPlayerLevel())));
         String percentString = "String_Node_Str" + String.format("String_Node_Str", percent) + "String_Node_Str";