Input:
protected void paintInternal(GC gc, Device device) {
    if (this.parentNode != null) {
        gc.drawLine(this.rect.x + (rect.width / 2), this.rect.y + (this.rect.height - TEXTBOXHEIGHT) / 2, this.parentNode.getX() + (this.parentNode.getWidth() / 2), this.parentNode.getY() + this.parentNode.getHeight());
    }
    if (this.networkNode.isLeafNode()) {
        if (LEAFNODEIMAGE != null) {
            final int destHeight = (int) ((float) LEAFNODEIMAGERECT.height * imageScaleFactor);
            final int destWidth = (int) ((float) LEAFNODEIMAGERECT.width * imageScaleFactor);
            final int destX = this.rect.x + (this.rect.width - destWidth) / 2;
            final int destY = this.rect.y + ((this.rect.height - TEXTBOXHEIGHT) - destHeight) / 2;
            gc.drawImage(LEAFNODEIMAGE, LEAFNODEIMAGERECT.x, LEAFNODEIMAGERECT.y, LEAFNODEIMAGERECT.width, LEAFNODEIMAGERECT.height, destX, destY, destWidth, destHeight);
        }
    } else {
        if (NODEIMAGE != null) {
            final int destHeight = (int) ((float) NODEIMAGERECT.height * imageScaleFactor);
            final int destWidth = (int) ((float) NODEIMAGERECT.width * imageScaleFactor);
            final int destX = this.rect.x + (this.rect.width - destWidth) / 2;
            final int destY = this.rect.y + ((this.rect.height - TEXTBOXHEIGHT) - destHeight) / 2;
            gc.drawImage(NODEIMAGE, NODEIMAGERECT.x, NODEIMAGERECT.y, NODEIMAGERECT.width, NODEIMAGERECT.height, destX, destY, destWidth, destHeight);
        }
    }
    String name = this.networkNode.getName();
    Point pt = gc.textExtent(name);
    boolean cropped = false;
    while (pt.x > this.rect.width) {
        cropped = true;
        name = name.substring(0, name.length() - 1);
        pt = gc.textExtent(name + "String_Node_Str");
    }
    if (cropped) {
        name += "String_Node_Str";
    }
    gc.setBackground(ColorScheme.getNetworkNodeBackgroundColor(device));
    gc.fillRectangle(this.rect.x + (this.rect.width - pt.x) / 2 - TEXTBOXSPACING, this.rect.y + this.rect.height - TEXTBOXHEIGHT, pt.x + (2 * TEXTBOXSPACING), TEXTBOXHEIGHT);
    gc.setForeground(ColorScheme.getNetworkNodeBorderColor(device));
    gc.drawRectangle(this.rect.x + (this.rect.width - pt.x) / 2 - TEXTBOXSPACING, this.rect.y + this.rect.height - TEXTBOXHEIGHT, pt.x + (2 * TEXTBOXSPACING), TEXTBOXHEIGHT);
    gc.setForeground(ColorScheme.getNetworkNodeBorderColor(device));
    final int textX = this.rect.x + ((this.rect.width - pt.x) / 2);
    final int textY = this.rect.y + this.rect.height - TEXTBOXHEIGHT + ((TEXTBOXHEIGHT - pt.y) / 2);
    gc.drawText(name, textX, textY);
}

Output:
     if (this.networkNode.isLeafNode()) {
-        if (LEAFNODEIMAGE != null) {
-            final int destHeight = (int) ((float) LEAFNODEIMAGERECT.height * imageScaleFactor);
-            final int destWidth = (int) ((float) LEAFNODEIMAGERECT.width * imageScaleFactor);
+        if (this.leafNodeImage != null) {
+            final int destHeight = (int) ((float) this.leafNodeImageRect.height * imageScaleFactor);
+            final int destWidth = (int) ((float) this.leafNodeImageRect.width * imageScaleFactor);
             final int destX = this.rect.x + (this.rect.width - destWidth) / 2;


Input:
public void updateDescription() {
    if (this.amount > 0) {
        this.description = ("String_Node_Str" + DESCRIPTIONS[0] + this.amount + "String_Node_Str");
    }
}

Output:
     if (this.amount > 0) {
-        this.description = ("String_Node_Str" + DESCRIPTIONS[0] + this.amount + "String_Node_Str");
+        this.description = ("String_Node_Str" + DESCRIPTIONS[0] + this.amount + "String_Node_Str" + cap + "String_Node_Str");
     }


Input:
public double call(double v) {
    assertEquals(0.0, v, 1e-13);
    x.increment();
    return 1.0;
}

Output:
     assertEquals(0.0, v, 1e-13);
-    x.increment();
+    x.v++;
     return 1.0;


Input:
public void HandlePacket(Packet230ModLoader packet) {
    int entityId = packet.dataInt[0];
    Entity entity = ((WorldClient) ModLoader.getMinecraftInstance().theWorld).getEntityByID(entityId);
    ((ThxEntity) entity).handleUpdatePacketFromServer(packet);
}

Output:
     int entityId = packet.dataInt[0];
-    Entity entity = ((WorldClient) ModLoader.getMinecraftInstance().theWorld).getEntityByID(entityId);
-    ((ThxEntity) entity).handleUpdatePacketFromServer(packet);
+    if (entityId < 1)
+        log("String_Node_Str" + packet.packetType + "String_Node_Str" + packet);
+    else {
+        Entity entity = ((WorldClient) ModLoader.getMinecraftInstance().theWorld).getEntityByID(entityId);
+        if (entity != null)
+            ((ThxEntity) entity).handleUpdatePacketFromServer(packet);
+    }
 }


Input:
public static void updateAppWidget(Context context, AppWidgetManager appWidgetManager, int appWidgetId) {
    RemoteViews rv = new RemoteViews(context.getPackageName(), R.layout.widget_layout);
    Intent intent = new Intent(context, WidgetService.class);
    intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
    rv.setRemoteAdapter(appWidgetId, R.id.list_view, intent);
    Intent onListClickIntent = new Intent(context, WidgetProvider.class);
    onListClickIntent.setAction(ACTION_LIST_CLICK);
    onListClickIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
    onListClickIntent.setData(Uri.parse(onListClickIntent.toUri(Intent.URI_INTENT_SCHEME)));
    final PendingIntent onListClickPendingIntent = PendingIntent.getBroadcast(context, 0, onListClickIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    rv.setPendingIntentTemplate(R.id.list_view, onListClickPendingIntent);
    Intent intentToDoListAct = new Intent(context, NewsReaderListActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intentToDoListAct, 0);
    rv.setOnClickPendingIntent(R.id.tV_widget_header, pendingIntent);
    appWidgetManager.updateAppWidget(appWidgetId, rv);
    if (Constants.debugModeWidget)
        Log.d(TAG, "String_Node_Str" + appWidgetId);
}

Output:
     intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
-    rv.setRemoteAdapter(appWidgetId, R.id.list_view, intent);
+    rv.setRemoteAdapter(R.id.list_view, intent);
     Intent onListClickIntent = new Intent(context, WidgetProvider.class);


Input:
private static void fillListOfCatalogs(Connection connection, List<String> catalogNames) throws SQLException {
    if (catalogNames.isEmpty()) {
        ResultSet catalogSet = null;
        DatabaseMetaData connectionMetadata = getConnectionMetadata(connection);
        if (connectionMetadata.getDriverName() != null && connectionMetadata.getDriverName().toLowerCase().indexOf(DatabaseConstant.ODBC_ORACLE_DRIVER_NAME) < 0) {
            catalogSet = connectionMetadata.getCatalogs();
        }
        try {
            if (catalogSet != null) {
                while (catalogSet.next()) {
                    String catalogName = catalogSet.getString(MetaDataConstants.TABLE_CAT.name());
                    if (catalogName != null || !"String_Node_Str".equals(catalogName)) {
                        catalogNames.add(catalogName);
                    }
                }
            }
        } catch (SQLException e) {
            log.warn("String_Node_Str", e);
        } finally {
            if (catalogSet != null) {
                catalogSet.close();
            }
        }
    }
}

Output:
         DatabaseMetaData connectionMetadata = getConnectionMetadata(connection);
-        if (connectionMetadata.getDriverName() != null && connectionMetadata.getDriverName().toLowerCase().indexOf(DatabaseConstant.ODBC_ORACLE_DRIVER_NAME) < 0) {
+        if (connectionMetadata.getDatabaseProductName() != null && connectionMetadata.getDatabaseProductName().toLowerCase().indexOf(DatabaseConstant.ODBC_ORACLE_PRODUCT_NAME) < 0) {
             catalogSet = connectionMetadata.getCatalogs();


Input:
public static String toFatCatCore(AFPChain afpChain, Atom[] ca1, Atom[] ca2, boolean printLegend, boolean longHeader, boolean showHTML) {
    if (!afpChain.isSequentialAlignment()) {
        return "String_Node_Str";
    }
    String name1 = afpChain.getName1();
    String name2 = afpChain.getName2();
    int ca1Length = afpChain.getCa1Length();
    int ca2Length = afpChain.getCa2Length();
    int blockNum = afpChain.getBlockNum();
    int totalLenIni = afpChain.getTotalLenIni();
    double totalRmsdIni = afpChain.getTotalRmsdIni();
    int optLength = afpChain.getOptLength();
    double totalRmsdOpt = afpChain.getTotalRmsdOpt();
    double chainRmsd = afpChain.getChainRmsd();
    double alignScore = afpChain.getAlignScore();
    int alnLength = afpChain.getAlnLength();
    int gapLen = afpChain.getGapLen();
    List<AFP> afpSet = afpChain.getAfpSet();
    double similarity = afpChain.getSimilarity();
    double identity = afpChain.getIdentity();
    if (similarity < 0 || identity < 0) {
        afpChain.calcSimilarity();
        similarity = afpChain.getSimilarity();
        identity = afpChain.getIdentity();
    }
    String algorithmName = afpChain.getAlgorithmName();
    double probability = afpChain.getProbability();
    int afpNum = afpSet.size();
    int[] blockGap = afpChain.getBlockGap();
    double[] blockScore = afpChain.getBlockScore();
    double[] blockRmsd = afpChain.getBlockRmsd();
    int[] blockSize = afpChain.getBlockSize();
    int alnbeg1 = afpChain.getAlnbeg1();
    int alnbeg2 = afpChain.getAlnbeg2();
    char[] alnseq1 = afpChain.getAlnseq1();
    char[] alnseq2 = afpChain.getAlnseq2();
    char[] alnsymb = afpChain.getAlnsymb();
    StringBuffer txt = new StringBuffer();
    if (longHeader) {
        txt.append(String.format("String_Node_Str", name1, ca1Length, name2, ca2Length));
    } else {
        txt.append(String.format("String_Node_Str", name1, ca1Length, name2, ca2Length));
    }
    txt.append(newline);
    if (afpChain.isShortAlign()) {
        txt.append("String_Node_Str");
        return txt.toString();
    }
    if (longHeader) {
        txt.append(String.format("String_Node_Str", blockNum - 1, totalLenIni, totalRmsdIni, optLength, totalRmsdOpt, chainRmsd, alignScore, alnLength, gapLen, (100.0 * (double) gapLen / (double) alnLength)));
        txt.append(newline);
    } else {
        if (!longHeader)
            printScore(txt, algorithmName, probability, longHeader);
        printScoresInLines(afpChain, blockNum, optLength, totalRmsdOpt, alignScore, alnLength, gapLen, identity, similarity, txt);
    }
    if (longHeader) {
        printScore(txt, algorithmName, probability, longHeader);
        txt.append(String.format("String_Node_Str", afpNum, identity * 100, similarity * 100));
        txt.append(newline);
    }
    int i;
    double gap;
    if (longHeader) {
        int fragLen = 8;
        for (i = 0; i < blockNum; i++) {
            gap = (double) blockGap[i] / ((double) blockGap[i] + fragLen * blockSize[i]);
            txt.append(String.format("String_Node_Str", i, blockSize[i], blockScore[i], blockRmsd[i], blockGap[i], gap));
            txt.append(newline);
        }
    }
    int linelen = 70;
    String a;
    String b;
    String c;
    int t = 0;
    int ap = alnbeg1;
    int bp = alnbeg2;
    int k, len;
    while ((alnLength - t) > 0) {
        if (alnLength - t > linelen)
            len = linelen;
        else
            len = alnLength - t;
        String lseq1 = new String(alnseq1).substring(t, t + len);
        String lseq2 = new String(alnseq2).substring(t, t + len);
        String lsymb = new String(alnsymb).substring(t, t + len);
        if (showHTML) {
            a = "String_Node_Str";
            b = "String_Node_Str";
            c = "String_Node_Str";
            for (int pos = 0; pos < lseq1.length(); pos++) {
                char c1 = lseq1.charAt(pos);
                char c2 = lseq2.charAt(pos);
                char cl = lsymb.charAt(pos);
                if (cl != ' ') {
                    a += "String_Node_Str" + c1 + "String_Node_Str";
                    b += "String_Node_Str" + c2 + "String_Node_Str";
                    c += "String_Node_Str" + cl + "String_Node_Str";
                } else if (c1 != '-' && c2 != '-') {
                    a += "String_Node_Str" + c1 + "String_Node_Str";
                    b += "String_Node_Str" + c2 + "String_Node_Str";
                    c += "String_Node_Str" + cl + "String_Node_Str";
                } else {
                    a += "String_Node_Str" + c1 + "String_Node_Str";
                    b += "String_Node_Str" + c2 + "String_Node_Str";
                    c += "String_Node_Str" + cl + "String_Node_Str";
                }
                if (c1 != '-')
                    ap++;
                if (c2 != '-')
                    bp++;
            }
        } else {
            a = lseq1;
            b = lseq2;
            c = lsymb;
        }
        txt.append(newline);
        if (longHeader)
            txt.append(String.format("String_Node_Str", "String_Node_Str"));
        else
            txt.append(String.format("String_Node_Str", "String_Node_Str"));
        if (longHeader) {
            for (k = 10; k <= len; k += 10) txt.append("String_Node_Str");
            if (k <= len + 5)
                txt.append("String_Node_Str");
        } else {
            for (k = 10; k <= len; k += 10) txt.append("String_Node_Str");
            if (k <= len + 5)
                txt.append("String_Node_Str");
        }
        if (ap >= ca1.length)
            break;
        if (bp >= ca2.length)
            break;
        String pdb1 = ca1[ap].getGroup().getResidueNumber().toString();
        String pdb2 = ca2[bp].getGroup().getResidueNumber().toString();
        txt.append(newline);
        txt.append(String.format("String_Node_Str" + newline + "String_Node_Str" + newline + "String_Node_Str", pdb1, a, "String_Node_Str", c, pdb2, b));
        txt.append(newline);
        if (!showHTML) {
            for (k = 0; k < len; k++) {
                if (a.charAt(k) != '-')
                    ap++;
                if (b.charAt(k) != '-')
                    bp++;
            }
        }
        t += len;
    }
    txt.append(newline);
    if (printLegend) {
        if (algorithmName.equalsIgnoreCase(CeMain.algorithmName) || algorithmName.equalsIgnoreCase(SmithWaterman3Daligner.algorithmName)) {
            txt.append("String_Node_Str");
        } else {
            txt.append("String_Node_Str");
        }
        txt.append(newline);
    }
    return txt.toString();
}

Output:
                 if (cl != ' ') {
-                    a += "String_Node_Str" + c1 + "String_Node_Str";
-                    b += "String_Node_Str" + c2 + "String_Node_Str";
-                    c += "String_Node_Str" + cl + "String_Node_Str";
+                    try {
+                        block = Integer.parseInt(cl + "String_Node_Str");
+                    } catch (Exception e) {
+                    }
+                }
+                if (cl != ' ') {
+                    if (block > -1) {
+                        a += "String_Node_Str" + block + "String_Node_Str" + c1 + "String_Node_Str";
+                        b += "String_Node_Str" + block + "String_Node_Str" + c2 + "String_Node_Str";
+                        c += "String_Node_Str" + cl + "String_Node_Str";
+                    } else {
+                        a += "String_Node_Str" + c1 + "String_Node_Str";
+                        b += "String_Node_Str" + c2 + "String_Node_Str";
+                        c += "String_Node_Str" + cl + "String_Node_Str";
+                    }
                 } else if (c1 != '-' && c2 != '-') {


Input:
public void performInteraction(THEvent event) {
    if (!(event instanceof ClickEvent) && !(event instanceof KeyboardEvent))
        return;
    Actionable<DLAction> a = null;
    if (event instanceof ClickEvent)
        a = ((ClickEvent) event).getAction();
    if (event instanceof KeyboardEvent)
        a = ((KeyboardEvent) event).getAction();
    if (a == null)
        return;
    DLAction id = a.action();
    if (!id.is2D() && this.is2D())
        return;
    Vec trans;
    switch(id) {
        case DRAW_AXIS:
            toggleAxisIsDrawn();
            break;
        case DRAW_GRID:
            toggleGridIsDrawn();
            break;
        case CAMERA_PROFILE:
            break;
        case CAMERA_TYPE:
            toggleCameraType();
            break;
        case CAMERA_KIND:
            toggleCameraKind();
            break;
        case ANIMATION:
            toggleAnimation();
            break;
        case GLOBAL_HELP:
            displayGlobalHelp();
            break;
        case CURRENT_CAMERA_PROFILE_HELP:
            displayCurrentCameraProfileHelp();
            break;
        case EDIT_CAMERA_PATH:
            toggleCameraPathsAreDrawn();
            break;
        case FOCUS_INTERACTIVE_FRAME:
            break;
        case DRAW_FRAME_SELECTION_HINT:
            toggleFrameSelectionHintIsDrawn();
            break;
        case CONSTRAIN_FRAME:
            break;
        case INTERPOLATE_TO_ZOOM_ON_PIXEL:
            if (this.is3D()) {
                Camera.WorldPoint wP = camera().interpolateToZoomOnPixel(new Point(cursorX, cursorY));
                if (wP.found) {
                    pupVec = wP.point;
                    pupFlag = true;
                    timerFx.runOnce(1000);
                }
            } else {
                viewWindow().interpolateToZoomOnPixel(new Point(cursorX, cursorY));
                pupVec = viewWindow().unprojectedCoordinatesOf(new Vec((float) cursorX, (float) cursorY, 0.5f));
                pupFlag = true;
                timerFx.runOnce(1000);
            }
            break;
        case INTERPOLATE_TO_FIT_SCENE:
            pinhole().interpolateToFitScene();
            break;
        case SHOW_ALL:
            showAll();
            break;
        case MOVE_CAMERA_LEFT:
            trans = new Vec(-10.0f * pinhole().flySpeed(), 0.0f, 0.0f);
            if (this.is3D())
                trans.div(camera().frame().magnitude());
            pinhole().frame().translate(pinhole().frame().inverseTransformOf(trans));
            break;
        case MOVE_CAMERA_RIGHT:
            trans = new Vec(10.0f * pinhole().flySpeed(), 0.0f, 0.0f);
            if (this.is3D())
                trans.div(camera().frame().magnitude());
            pinhole().frame().translate(pinhole().frame().inverseTransformOf(trans));
            break;
        case MOVE_CAMERA_UP:
            trans = pinhole().frame().inverseTransformOf(new Vec(0.0f, isRightHanded() ? 10.0f : -10.0f * pinhole().flySpeed(), 0.0f));
            if (this.is3D())
                trans.div(camera().frame().magnitude());
            pinhole().frame().translate(trans);
            break;
        case MOVE_CAMERA_DOWN:
            trans = pinhole().frame().inverseTransformOf(new Vec(0.0f, isRightHanded() ? -10.0f : 10.0f * pinhole().flySpeed(), 0.0f));
            if (this.is3D())
                trans.div(camera().frame().magnitude());
            pinhole().frame().translate(trans);
            break;
        case INCREASE_ROTATION_SENSITIVITY:
            pinhole().setRotationSensitivity(pinhole().rotationSensitivity() * 1.2f);
            break;
        case DECREASE_ROTATION_SENSITIVITY:
            pinhole().setRotationSensitivity(pinhole().rotationSensitivity() / 1.2f);
            break;
        case INCREASE_CAMERA_FLY_SPEED:
            ((Camera) pinhole()).setFlySpeed(((Camera) pinhole()).flySpeed() * 1.2f);
            break;
        case DECREASE_CAMERA_FLY_SPEED:
            ((Camera) pinhole()).setFlySpeed(((Camera) pinhole()).flySpeed() / 1.2f);
            break;
        case INCREASE_AVATAR_FLY_SPEED:
            if (avatar() != null)
                if (avatarIsInteractiveDrivableFrame)
                    ((InteractiveDrivableFrame) avatar()).setFlySpeed(((InteractiveDrivableFrame) avatar()).flySpeed() * 1.2f);
            break;
        case DECREASE_AVATAR_FLY_SPEED:
            if (avatar() != null)
                if (avatarIsInteractiveDrivableFrame)
                    ((InteractiveDrivableFrame) avatar()).setFlySpeed(((InteractiveDrivableFrame) avatar()).flySpeed() / 1.2f);
            break;
        case INCREASE_AZYMUTH:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setAzimuth(((InteractiveAvatarFrame) avatar()).azimuth() + PI / 64);
            break;
        case DECREASE_AZYMUTH:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setAzimuth(((InteractiveAvatarFrame) avatar()).azimuth() - PI / 64);
            break;
        case INCREASE_INCLINATION:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setInclination(((InteractiveAvatarFrame) avatar()).inclination() + PI / 64);
            break;
        case DECREASE_INCLINATION:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setInclination(((InteractiveAvatarFrame) avatar()).inclination() - PI / 64);
            break;
        case INCREASE_TRACKING_DISTANCE:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setTrackingDistance(((InteractiveAvatarFrame) avatar()).trackingDistance() + radius() / 50);
            break;
        case DECREASE_TRACKING_DISTANCE:
            if (avatar() != null)
                if (avatarIsInteractiveAvatarFrame)
                    ((InteractiveAvatarFrame) avatar()).setTrackingDistance(((InteractiveAvatarFrame) avatar()).trackingDistance() - radius() / 50);
            break;
        case ZOOM_ON_PIXEL:
            if (this.is2D()) {
                viewWindow().interpolateToZoomOnPixel(new Point(cursorX, cursorY));
                pupVec = viewWindow().unprojectedCoordinatesOf(new Vec((float) cursorX, (float) cursorY, 0.5f));
                pupFlag = true;
                timerFx.runOnce(1000);
            } else {
                Camera.WorldPoint wP = camera().interpolateToZoomOnPixel(new Point(cursorX, cursorY));
                if (wP.found) {
                    pupVec = wP.point;
                    pupFlag = true;
                    timerFx.runOnce(1000);
                }
            }
            break;
        case ZOOM_TO_FIT:
            pinhole().interpolateToFitScene();
            break;
        case ARP_FROM_PIXEL:
            if (setArcballReferencePointFromPixel(new Point(cursorX, cursorY))) {
                arpFlag = true;
                timerFx.runOnce(1000);
            }
            break;
        case RESET_ARP:
            pinhole().setArcballReferencePoint(new Vec(0, 0, 0));
            arpFlag = true;
            timerFx.runOnce(1000);
            break;
        case CENTER_FRAME:
            break;
        case CENTER_SCENE:
            pinhole().centerScene();
            break;
        case ALIGN_FRAME:
            break;
        case ALIGN_CAMERA:
            pinhole().frame().alignWithFrame(null, true);
            break;
        default:
            System.out.println("String_Node_Str");
            break;
    }
}

Output:
 public void performInteraction(THEvent event) {
-    if (!(event instanceof ClickEvent) && !(event instanceof KeyboardEvent))
+    if (!(event instanceof GenericClickEvent) && !(event instanceof GenericKeyboardEvent))
         return;


Input:
public void init(GLAutoDrawable canvas) {
    bInitGLcanvawsWasCalled = true;
    this.gl = canvas.getGL();
    gl.glEnable(GL.GL_LINE_SMOOTH);
    gl.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST);
    gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
    gl.glLineWidth(1.0f);
    float[] fMatSpecular = { 1.0f, 1.0f, 1.0f, 1.0f };
    float[] fMatShininess = { 25.0f };
    float[] fLightPosition = { -1.0f, 0.0f, 0.0f, 1.0f };
    float[] fWhiteLight = { 1.0f, 1.0f, 1.0f, 1.0f };
    float[] fModelAmbient = { 0.2f, 0.2f, 0.2f, 1.0f };
    gl.glEnable(GL.GL_COLOR_MATERIAL);
    gl.glColorMaterial(GL.GL_FRONT, GL.GL_DIFFUSE);
    gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, fLightPosition, 0);
    gl.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, fModelAmbient, 0);
    gl.glEnable(GL.GL_LIGHTING);
    gl.glEnable(GL.GL_LIGHT0);
    gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    buildPathwayDisplayList();
}

Output:
 public void init(GLAutoDrawable canvas) {
-    bInitGLcanvawsWasCalled = true;
+    setInitGLDone();
     this.gl = canvas.getGL();


Input:
public void useVertexPositionData(FloatBuffer positionBuffer) {
    lock.lock();
    try {
        super.useVertexPositionData(positionBuffer);
        updateSelectedTime();
    } finally {
        lock.unlock();
    }
}

Output:
 public void useVertexPositionData(FloatBuffer positionBuffer) {
-    lock.lock();
+    painterLock.lock();
     try {


Input:
public Entry nextEntry() throws IOException {
    EnumSet<PropagationMode> propModes = toPropagationMode(ois.readInt());
    ContextBootstrap.debug(MessageID.READ_PROP_MODES, propModes);
    String className = readAscii();
    Entry.ContextType contextType = toContextType(className);
    ContextBootstrap.debug(MessageID.READ_CONTEXT_TYPE, contextType);
    Object value;
    switch(contextType) {
        case LONG:
            value = ois.readLong();
            if (key.equals(Catalog.CATALOG_META_KEY)) {
                wlsCatalog.setMeta((Long) value);
            }
            break;
        case STRING:
            value = ois.readUTF();
            break;
        case ASCII_STRING:
            value = readAscii();
            break;
        case SERIALIZABLE:
            byte[] bytes = new byte[ois.readInt()];
            ois.readFully(bytes);
            try {
                Carrier carrier = Carrier.fromBytes(bytes);
                value = carrier.serializable;
                if (value instanceof ViewMeta) {
                    try {
                        value = ((PrivilegedWireAdapterAccessor) ContextMapHelper.getScopeAwareContextMap()).createViewCapable(key, false);
                    } catch (InsufficientCredentialException e) {
                        throw new AssertionError("String_Node_Str");
                    }
                } else {
                    if (key.equals(Catalog.CATALOG_KEY)) {
                        wlsCatalog.setPosisionsFrom((Catalog) value);
                    }
                }
            } catch (ClassNotFoundException e) {
                ContextBootstrap.debug(MessageID.READING_OPAQUE_TYPE, key, bytes.length);
                value = bytes;
                contextType = ContextType.OPAQUE;
            }
            break;
        case OPAQUE:
            SerializableContextFactory factory = HELPER.findContextFactory(key, className);
            if (factory == null) {
                error(MessageID.ERROR_NO_WORK_CONTEXT_FACTORY, key, className);
                return null;
            } else {
                value = factory.createInstance();
                if (value instanceof WLSContext) {
                    ((WLSContext) value).readContext(ois);
                }
            }
            break;
        default:
            throw new AssertionError("String_Node_Str" + contextType);
    }
    ContextBootstrap.debug(MessageID.READ_VALUE, value);
    return contextType == ContextType.OPAQUE ? Entry.createOpaqueEntryInstance(value, propModes, className) : new Entry(value, propModes, contextType);
}

Output:
             } else {
-                value = factory.createInstance();
-                if (value instanceof WLSContext) {
-                    ((WLSContext) value).readContext(ois);
+                WLSContext ctx = factory.createInstance();
+                if (ctx != null) {
+                    ctx.readContext(ois);
                 }


Input:
public void afterCommand() {
    env = null;
    buildRequest = null;
    ExecutorUtil.interruptibleShutdown(backgroundWorkers);
}

Output:
     buildRequest = null;
-    ExecutorUtil.interruptibleShutdown(backgroundWorkers);
+    backgroundWorkers = null;
+    sandboxOptions = null;
 }


Input:
public void contextInitialized(ServletContextEvent event) {
    ServletContext ctx = event.getServletContext();
    String mdir = ctx.getRealPath("String_Node_Str");
    System.out.println("String_Node_Str" + mdir);
    timer.schedule(new ListenerTask(mdir), sec_start, sec);
}

Output:
     ServletContext ctx = event.getServletContext();
-    String mdir = ctx.getRealPath("String_Node_Str");
-    System.out.println("String_Node_Str" + mdir);
-    timer.schedule(new ListenerTask(mdir), sec_start, sec);
+    Settings.init(ctx);
+    MapCache mc = MapCache.getInstance();
+    mc.init(ctx);
+    System.out.println("String_Node_Str" + mc.mapPath);
+    timer.schedule(new ListenerTask(mc.mapPath), sec_start, sec);
 }


Input:
public void write(final File filename) {
    if (filename == null || !filename.exists()) {
        return;
    }
    curMatchTopic = topicSet.contains(SHARP) ? SHARP : null;
    topicIdStack = new ArrayDeque<String>();
    final File inputFile = filename;
    final File outputFile = new File(filename.getPath() + FILE_EXTENSION_TEMP);
    FileOutputStream fileOutput = null;
    try {
        fileOutput = new FileOutputStream(outputFile);
        output = new OutputStreamWriter(fileOutput, UTF8);
        reader.setErrorHandler(new DITAOTXMLErrorHandler(filename.getPath(), logger));
        reader.parse(inputFile.toURI().toString());
    } catch (final Exception e) {
        logger.error(e.getMessage(), e);
    } finally {
        try {
            if (fileOutput != null) {
                fileOutput.close();
            }
        } catch (final Exception e) {
            logger.error(e.getMessage(), e);
        }
        try {
            if (output != null) {
                output.close();
            }
        } catch (final Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
    try {
        FileUtils.moveFile(outputFile, inputFile);
    } catch (final Exception e) {
        logger.error("String_Node_Str" + inputFile + "String_Node_Str" + e.getMessage());
    }
}

Output:
         reader.setErrorHandler(new DITAOTXMLErrorHandler(filename.getPath(), logger));
-        reader.parse(inputFile.toURI().toString());
+        reader.parse(filename.toURI().toString());
     } catch (final Exception e) {


Input:
public BigInteger getBigInt() {
    try {
        if (this.sqltype == Types.BIGINT) {
            return (BigInteger) data;
        } else if (getFieldType().equals(FieldType.BOOLEAN)) {
            return ((Boolean) data).booleanValue() ? BigInteger.ONE : BigInteger.ZERO;
        } else if (getFieldType().equals(FieldType.BINARY)) {
            return new BigInteger((byte[]) data);
        } else if (getFieldType().equals(FieldType.STRING)) {
            return new BigInteger(data.toString());
        } else {
            long l = 0;
            if (getFieldType().equals(FieldType.INTEGER) || getFieldType().equals(FieldType.REAL)) {
                l = ((Number) data).longValue();
            } else if (getFieldType().equals(FieldType.DATE)) {
                l = ((Date) data).getTime();
            }
            return new BigInteger(String.valueOf(l));
        }
    } catch (NumberFormatException e) {
    }
    return BigInteger.ZERO;
}

Output:
     try {
-        if (this.sqltype == Types.BIGINT) {
+        if (data instanceof BigInteger) {
             return (BigInteger) data;


Input:
public void run() {
    List<Topic> topics = new ArrayList<>();
    boolean succeed = false;
    try {
        Document doc = getConnection(mUrl).get();
        Elements elements = doc.select("String_Node_Str");
        for (Element element : elements) {
            Topic topic = createTopicFromElement(element);
            topics.add(topic);
        }
        succeed = true;
    } catch (IOException e) {
        e.printStackTrace();
    }
    if (succeed) {
        if (topics.size() > 0) {
            successOnUI(topics);
        } else {
            failedOnUI("String_Node_Str");
        }
    } else {
        failedOnUI("String_Node_Str");
    }
}

Output:
         if (topics.size() > 0) {
-            successOnUI(topics);
+            TopicList topicList = new TopicList();
+            topicList.setTopics(topics);
+            topicList.setHasMore(hasMore);
+            successOnUI(topicList);
         } else {


Input:
public void severalFeatures() throws IOException {
    encodedDecode(nodes(TYPE.FEATURE, 1, false, false, false), TYPE.FEATURE);
    encodedDecode(nodes(TYPE.FEATURE, 1024, false, false, true), TYPE.FEATURE);
    encodedDecode(nodes(TYPE.FEATURE, 1024, false, true, true), TYPE.FEATURE);
    encodedDecode(nodes(TYPE.FEATURE, 1024, true, true, true), TYPE.FEATURE);
    encodedDecode(nodes(TYPE.FEATURE, 1024, true, false, false), TYPE.FEATURE);
    encodedDecode(nodes(TYPE.FEATURE, 1024, true, true, false), TYPE.FEATURE);
}

Output:
 public void severalFeatures() throws IOException {
-    encodedDecode(nodes(TYPE.FEATURE, 1, false, false, false), TYPE.FEATURE);
+    encodedDecode(nodes(TYPE.FEATURE, 1024, false, false, false), TYPE.FEATURE);
     encodedDecode(nodes(TYPE.FEATURE, 1024, false, false, true), TYPE.FEATURE);


Input:
public static int getLatestVersion() {
    return VERSION_2_2_1_1;
}

Output:
 public static int getLatestVersion() {
-    return VERSION_2_2_1_1;
+    return VERSION_2_2_1_2;
 }


Input:
private <T extends SecurityPrice> List<T> internalGetQuotes(Class<T> klass, Security security, LocalDate startDate, List<Exception> errors) {
    if (security.getTickerSymbol() == null) {
        errors.add(new IOException(MessageFormat.format(Messages.MsgMissingTickerSymbol, security.getName())));
        return Collections.emptyList();
    }
    LocalDate stopDate = LocalDate.now();
    String wknUrl = MessageFormat.format(HISTORICAL_URL, security.getTickerSymbol(), startDate.getMonth().getValue() - 1, startDate.getDayOfMonth(), Integer.toString(startDate.getYear()), stopDate.getMonth().getValue() - 1, stopDate.getDayOfMonth(), Integer.toString(stopDate.getYear()));
    List<T> answer = new ArrayList<>();
    String line = null;
    try (BufferedReader reader = openReader(wknUrl, errors)) {
        if (reader == null)
            return answer;
        line = reader.readLine();
        if (!"String_Node_Str".equals(line))
            throw new IOException(MessageFormat.format(Messages.MsgUnexpectedHeader, line));
        DecimalFormat priceFormat = FMT_PRICE.get();
        DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("String_Node_Str");
        while ((line = reader.readLine()) != null) {
            String[] values = line.split("String_Node_Str");
            if (values.length != 7)
                throw new IOException(MessageFormat.format(Messages.MsgUnexpectedValue, line));
            T price = klass.newInstance();
            fillValues(values, price, priceFormat, dateFormat);
            answer.add(price);
        }
    } catch (NumberFormatException | ParseException | DateTimeParseException e) {
        errors.add(new IOException(MessageFormat.format(Messages.MsgErrorsConvertingValue, line), e));
    } catch (InstantiationException | IllegalAccessException | IOException e) {
        errors.add(e);
    }
    return answer;
}

Output:
             T price = klass.newInstance();
-            fillValues(values, price, priceFormat, dateFormat);
+            fillValues(values, price, dateFormat);
             answer.add(price);


Input:
public void keyReleased(int keyCode) {
    if (indexWhenKeyPressed == this.activeQuestionIndex) {
        super.keyReleased(keyCode);
    }
}

Output:
 public void keyReleased(int keyCode) {
-    if (indexWhenKeyPressed == this.activeQuestionIndex) {
+    if (keyCode == KEY_CENTER_LETS_HOPE && !(indexWhenKeyPressed == this.activeQuestionIndex)) {
+    } else {
         super.keyReleased(keyCode);


Input:
public void update(Brain brain, TimeStep timeStep) {
    PlayerEntity ent = brain.getEntityOwner();
    this.sampleTime -= timeStep.getDeltaTime();
    if (this.sampleTime < 0) {
        PathFeeder<?> feeder = brain.getMotion().getPathFeeder();
        Vector2f dest = null;
        if (feeder.hasPath()) {
            dest = feeder.nextDestination(ent);
        } else {
            dest = ent.getMovementDir();
        }
        Vector2f.Vector2fNormalize(dest, dest);
        destination.set(dest);
        this.sampleTime = 200;
    }
    float currentOrientation = ent.getOrientation();
    float destinationOrientation = (float) (Math.atan2(destination.y, destination.x));
    float deltaOrientation = (destinationOrientation - currentOrientation);
    float deltaOrientationAbs = Math.abs(deltaOrientation);
    if (deltaOrientationAbs > Math.PI) {
        deltaOrientation = deltaOrientationAbs - fullCircle;
    }
    final double movementSpeed = Math.toRadians(15.0f);
    if (deltaOrientation != 0) {
        float direction = deltaOrientation / deltaOrientationAbs;
        currentOrientation += (direction * Math.min(movementSpeed, deltaOrientationAbs));
        currentOrientation %= fullCircle;
    }
    ent.setOrientation(currentOrientation);
}

Output:
     if (this.sampleTime < 0) {
-        PathFeeder<?> feeder = brain.getMotion().getPathFeeder();
+        PathPlanner<?> feeder = brain.getMotion().getPathPlanner();
         Vector2f dest = null;


Input:
public boolean testImpl(Object receiver, String property, Object[] args) {
    ITestResultSummaryPO summary = (ITestResultSummaryPO) receiver;
    if (property.equals(HAS_MONITORING_DATA_PROP)) {
        return summary.isReportWritten();
    }
    final EntityManager masterSession = GeneralStorage.getInstance().getMasterSession();
    if (property.equals(HAS_TEST_RESULT_DETAILS_PROP)) {
        return TestResultPM.hasTestResultDetails(masterSession, summary.getId());
    } else if (property.equals(HAS_PENDING_ALM_REPORT_PROP)) {
        return hasPendingALMReport(summary, masterSession);
    }
    return false;
}

Output:
 public boolean testImpl(Object receiver, String property, Object[] args) {
-    ITestResultSummaryPO summary = (ITestResultSummaryPO) receiver;
-    if (property.equals(HAS_MONITORING_DATA_PROP)) {
-        return summary.isReportWritten();
-    }
-    final EntityManager masterSession = GeneralStorage.getInstance().getMasterSession();
-    if (property.equals(HAS_TEST_RESULT_DETAILS_PROP)) {
-        return TestResultPM.hasTestResultDetails(masterSession, summary.getId());
-    } else if (property.equals(HAS_PENDING_ALM_REPORT_PROP)) {
-        return hasPendingALMReport(summary, masterSession);
+    final GeneralStorage instance = GeneralStorage.getInstance();
+    if (instance != null) {
+        final EntityManager masterSession = instance.getMasterSession();
+        if (masterSession.isOpen()) {
+            ITestResultSummaryPO summary = (ITestResultSummaryPO) receiver;
+            if (property.equals(HAS_MONITORING_DATA_PROP)) {
+                return summary.isReportWritten();
+            }
+            if (property.equals(HAS_TEST_RESULT_DETAILS_PROP)) {
+                return TestResultPM.hasTestResultDetails(masterSession, summary.getId());
+            } else if (property.equals(HAS_PENDING_ALM_REPORT_PROP)) {
+                return hasPendingALMReport(summary, masterSession);
+            }
+        }
     }


Input:
public void postRemoveUserRole() {
    this.authorizationManager.removeUserFromRole(this.in("String_Node_Str"), this.in("String_Node_Str"), this.subDomain());
    this.jsonSuccess();
}

Output:
 public void postRemoveUserRole() {
-    this.authorizationManager.removeUserFromRole(this.in("String_Node_Str"), this.in("String_Node_Str"), this.subDomain());
+    this.authorizationManager.removeUserFromRole(this.in("String_Node_Str", safeStringConverter), this.in("String_Node_Str"), this.subDomain());
     this.jsonSuccess();


Input:
protected IndexedAttributeList buildAttributeList(Element elem) throws SAXException {
    IndexedAttributeList attributes = new IndexedAttributeList();
    NamedNodeMap attrs = elem.getAttributes();
    int length = attrs.getLength();
    for (int i = 0; i < length; i++) {
        Attr next = (Attr) attrs.item(i);
        String attrPrefix = next.getPrefix();
        if (attrPrefix != null && attrPrefix.equals(XMLConstants.XMLNS)) {
            getContentHandler().startPrefixMapping(next.getLocalName(), next.getValue());
            handleXMLNSPrefixedAttribute(elem, next);
        } else if (attrPrefix == null) {
            String name = next.getLocalName();
            if (name == null) {
                name = next.getNodeName();
            }
            if (name != null && name.equals(XMLConstants.XMLNS)) {
                getContentHandler().startPrefixMapping(XMLConstants.EMPTY_STRING, next.getValue());
            }
        }
        attributes.addAttribute(next);
    }
    return attributes;
}

Output:
     NamedNodeMap attrs = elem.getAttributes();
-    int length = attrs.getLength();
-    for (int i = 0; i < length; i++) {
+    for (int i = 0, length = attrs.getLength(); i < length; i++) {
         Attr next = (Attr) attrs.item(i);


Input:
public void removeSlowly() {
    super.remove();
    for (int i = affectedBlocks.size() - 1; i > -1; i--) {
        final TempBlock tblock = affectedBlocks.get(i);
        final boolean isTempAir = TEMP_AIR_BLOCKS.values().contains(tblock);
        new BukkitRunnable() {
            public void run() {
                tblock.revertBlock();
                if (isTempAir && tblock.getState().getType() == Material.DOUBLE_PLANT) {
                    tblock.getBlock().getRelative(BlockFace.UP).setType(Material.DOUBLE_PLANT);
                    tblock.getBlock().getRelative(BlockFace.UP).setData((byte) (tblock.getState().getRawData() + 8));
                }
            }
        }.runTaskLater(ProjectKorra.plugin, (long) (i / shiftRemoveSpeed));
        if (TEMP_LAVA_BLOCKS.values().contains(tblock)) {
            affectedBlocks.remove(tblock);
            TEMP_LAVA_BLOCKS.remove(TEMP_LAVA_BLOCKS_BY_TEMPBLOCK.get(tblock));
            TEMP_LAVA_BLOCKS_BY_TEMPBLOCK.remove(tblock);
        }
        if (TEMP_LAND_BLOCKS.values().contains(tblock)) {
            affectedBlocks.remove(tblock);
            TEMP_LAND_BLOCKS.remove(tblock);
        }
        if (TEMP_AIR_BLOCKS.values().contains(tblock)) {
            affectedBlocks.remove(tblock);
            TEMP_AIR_BLOCKS.remove(tblock);
        }
    }
    for (BukkitRunnable task : tasks) {
        task.cancel();
    }
}

Output:
             affectedBlocks.remove(tblock);
-            TEMP_LAND_BLOCKS.remove(tblock);
+            TEMP_LAND_BLOCKS.remove(TEMP_LAND_BLOCKS_BY_TEMPBLOCK.get(tblock));
+            TEMP_LAVA_BLOCKS_BY_TEMPBLOCK.remove(tblock);
         }


Input:
public synchronized TooltipPainter setBreakOnEol(boolean breakOnEol) {
    this.breakOnEol = breakOnEol;
    this.textLayout = null;
    return this;
}

Output:
     this.breakOnEol = breakOnEol;
-    this.textLayout = null;
+    this.resetTextLayout();
     return this;


Input:
private void setRoutesFilter(boolean[] checks) {
    final int len = checks.length;
    final ArrayList<String> newFilter = new ArrayList<String>(len);
    ObaArrivalInfoResponse response = getArrivalsLoader().getLastGoodResponse();
    final List<ObaRoute> routes = response.getRoutes(mStop.getRouteIds());
    assert (routes.size() == len);
    for (int i = 0; i < len; ++i) {
        final ObaRoute route = routes.get(i);
        if (checks[i]) {
            newFilter.add(route.getId());
        }
    }
    if (newFilter.size() == len) {
        newFilter.clear();
    }
    setRoutesFilter(newFilter);
    mHeader.refresh();
}

Output:
     setRoutesFilter(newFilter);
-    mHeader.refresh();
+    if (mHeader != null) {
+        mHeader.refresh();
+    }
 }


Input:
protected void update() throws BirtException {
    if (parent != null) {
        if (context.isFixedLayout() && getContentHeight() > specifiedHeight && specifiedHeight > 0) {
            setContentHeight(specifiedHeight);
            setNeedClip(true);
        }
        if (!isInInlineStacking && context.isAutoPageBreak()) {
            int aHeight = getAllocatedHeight();
            int size = children.size();
            if ((aHeight + parent.getAbsoluteBP() > context.getMaxBP()) && (size > 1)) {
                IStyle style = content.getComputedStyle();
                int widow = Math.min(size, PropertyUtil.getIntValue(style.getProperty(IStyle.STYLE_WIDOWS)));
                int orphan = Math.min(size, PropertyUtil.getIntValue(style.getProperty(IStyle.STYLE_ORPHANS)));
                for (int i = 0; i < size; i++) {
                    TextLineArea line = (TextLineArea) children.get(i);
                    if (i > 0 && i < orphan) {
                        line.setPageBreakBefore(IStyle.AVOID_VALUE);
                    } else if (i > size - widow) {
                        line.setPageBreakBefore(IStyle.AVOID_VALUE);
                    }
                }
            }
            while (aHeight + parent.getAbsoluteBP() >= context.getMaxBP()) {
                parent.autoPageBreak();
                aHeight = getAllocatedHeight();
            }
        }
        parent.update(this);
    }
}

Output:
             while (aHeight + parent.getAbsoluteBP() >= context.getMaxBP()) {
-                parent.autoPageBreak();
+                if (!parent.autoPageBreak()) {
+                    break;
+                }
                 aHeight = getAllocatedHeight();


Input:
public void onKey(int primaryCode, Key key, int multiTapIndex, int[] nearByKeyCodes, boolean fromUI) {
    Log.d(TAG, "String_Node_Str" + primaryCode);
    final InputConnection ic = getCurrentInputConnection();
    switch(primaryCode) {
        case KeyCodes.ENTER:
        case KeyCodes.SPACE:
            handleSeparator(primaryCode);
            if (!mKeyboardSwitcher.isAlphabetMode()) {
                Log.d(TAG, "String_Node_Str");
                if (mAskPrefs.getSwitchKeyboardOnSpace()) {
                    Log.d(TAG, "String_Node_Str");
                    mKeyboardSwitcher.nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Alphabet);
                }
            }
            break;
        case KeyCodes.DELETE_WORD:
            if (ic == null)
                break;
            handleBackword(ic);
            break;
        case KeyCodes.DELETE:
            if (ic == null)
                break;
            if (mInputView != null && mInputView.isShifted() && !mInputView.getKeyboard().isShiftLocked() && ((mDistinctMultiTouch && mShiftKeyState.isPressed()) || mAskPrefs.useBackword())) {
                handleBackword(ic);
            } else {
                handleDeleteLastCharacter(false);
            }
            break;
        case KeyCodes.CLEAR_INPUT:
            if (ic != null) {
                ic.beginBatchEdit();
                commitTyped(ic);
                ic.deleteSurroundingText(Integer.MAX_VALUE, Integer.MAX_VALUE);
                ic.endBatchEdit();
            }
            break;
        case KeyCodes.SHIFT:
            if ((!mDistinctMultiTouch) || !fromUI)
                handleShift(false);
            break;
        case KeyCodes.CTRL:
            if ((!mDistinctMultiTouch) || !fromUI)
                handleControl(false);
            break;
        case KeyCodes.ARROW_LEFT:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_LEFT);
            break;
        case KeyCodes.ARROW_RIGHT:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_RIGHT);
            break;
        case KeyCodes.ARROW_UP:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_UP);
            break;
        case KeyCodes.ARROW_DOWN:
            sendDownUpKeyEvents(KeyEvent.KEYCODE_DPAD_DOWN);
            break;
        case KeyCodes.MOVE_HOME:
            if (Workarounds.getApiLevel() >= 11) {
                sendDownUpKeyEvents(0x0000007a);
            } else {
                if (ic != null) {
                    CharSequence textBefore = ic.getTextBeforeCursor(1024, 0);
                    if (!TextUtils.isEmpty(textBefore)) {
                        int newPosition = textBefore.length() - 1;
                        while (newPosition > 0) {
                            char chatAt = textBefore.charAt(newPosition - 1);
                            if (chatAt == '\n' || chatAt == '\r') {
                                break;
                            }
                            newPosition--;
                        }
                        if (newPosition < 0)
                            newPosition = 0;
                        ic.setSelection(newPosition, newPosition);
                    }
                }
            }
            break;
        case KeyCodes.MOVE_END:
            if (Workarounds.getApiLevel() >= 11) {
                sendDownUpKeyEvents(0x0000007b);
            } else {
                if (ic != null) {
                    CharSequence textAfter = ic.getTextAfterCursor(1024, 0);
                    if (!TextUtils.isEmpty(textAfter)) {
                        int newPosition = 1;
                        while (newPosition < textAfter.length()) {
                            char chatAt = textAfter.charAt(newPosition);
                            if (chatAt == '\n' || chatAt == '\r') {
                                break;
                            }
                            newPosition++;
                        }
                        if (newPosition > textAfter.length())
                            newPosition = textAfter.length();
                        try {
                            CharSequence textBefore = ic.getTextBeforeCursor(Integer.MAX_VALUE, 0);
                            if (!TextUtils.isEmpty(textBefore)) {
                                newPosition = newPosition + textBefore.length();
                            }
                            ic.setSelection(newPosition, newPosition);
                        } catch (Throwable e) {
                            Log.w(TAG, "String_Node_Str", e);
                        }
                    }
                }
            }
            break;
        case KeyCodes.VOICE_INPUT:
            if (mVoiceRecognitionTrigger != null)
                mVoiceRecognitionTrigger.startVoiceRecognition(getCurrentKeyboard().getDefaultDictionaryLocale());
            break;
        case KeyCodes.CANCEL:
            if (mOptionsDialog == null || !mOptionsDialog.isShowing()) {
                handleClose();
            }
            break;
        case KeyCodes.SETTINGS:
            showOptionsMenu();
            break;
        case KeyCodes.SPLIT_LAYOUT:
        case KeyCodes.MERGE_LAYOUT:
        case KeyCodes.COMPACT_LAYOUT_TO_RIGHT:
        case KeyCodes.COMPACT_LAYOUT_TO_LEFT:
            if (getCurrentKeyboard() != null && mInputView != null) {
                mKeyboardInCondensedMode = CondenseType.fromKeyCode(primaryCode);
                AnyKeyboard currentKeyboard = getCurrentKeyboard();
                setKeyboardStuffBeforeSetToView(currentKeyboard);
                mInputView.setKeyboard(currentKeyboard);
            }
            break;
        case KeyCodes.DOMAIN:
            onText(mAskPrefs.getDomainText());
            break;
        case KeyCodes.QUICK_TEXT:
            QuickTextKey quickTextKey = QuickTextKeyFactory.getCurrentQuickTextKey(this);
            if (mSmileyOnShortPress) {
                if (TextUtils.isEmpty(mOverrideQuickTextText))
                    onText(quickTextKey.getKeyOutputText());
                else
                    onText(mOverrideQuickTextText);
            } else {
                if (quickTextKey.isPopupKeyboardUsed()) {
                    showQuickTextKeyPopupKeyboard(quickTextKey);
                } else {
                    showQuickTextKeyPopupList(quickTextKey);
                }
            }
            break;
        case KeyCodes.QUICK_TEXT_POPUP:
            quickTextKey = QuickTextKeyFactory.getCurrentQuickTextKey(this);
            if (quickTextKey.getId().equals(SMILEY_PLUGIN_ID) && !mSmileyOnShortPress) {
                if (TextUtils.isEmpty(mOverrideQuickTextText))
                    onText(quickTextKey.getKeyOutputText());
                else
                    onText(mOverrideQuickTextText);
            } else {
                if (quickTextKey.isPopupKeyboardUsed()) {
                    showQuickTextKeyPopupKeyboard(quickTextKey);
                } else {
                    showQuickTextKeyPopupList(quickTextKey);
                }
            }
            break;
        case KeyCodes.MODE_SYMOBLS:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Symbols);
            break;
        case KeyCodes.MODE_ALPHABET:
            if (mKeyboardSwitcher.shouldPopupForLanguageSwitch()) {
                showLanguageSelectionDialog();
            } else
                nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Alphabet);
            break;
        case KeyCodes.UTILITY_KEYBOARD:
            mInputView.openUtilityKeyboard();
            break;
        case KeyCodes.MODE_ALPHABET_POPUP:
            showLanguageSelectionDialog();
            break;
        case KeyCodes.ALT:
            nextAlterKeyboard(getCurrentInputEditorInfo());
            break;
        case KeyCodes.KEYBOARD_CYCLE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.Any);
            break;
        case KeyCodes.KEYBOARD_REVERSE_CYCLE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.PreviousAny);
            break;
        case KeyCodes.KEYBOARD_CYCLE_INSIDE_MODE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.AnyInsideMode);
            break;
        case KeyCodes.KEYBOARD_MODE_CHANGE:
            nextKeyboard(getCurrentInputEditorInfo(), NextKeyboardType.OtherMode);
            break;
        case KeyCodes.CLIPBOARD:
            Clipboard cp = AnyApplication.getFrankenRobot().embody(new Clipboard.ClipboardDiagram(getApplicationContext()));
            CharSequence clipboardText = cp.getText();
            if (!TextUtils.isEmpty(clipboardText)) {
                onText(clipboardText);
            }
            break;
        case KeyCodes.TAB:
            sendTab();
            break;
        case KeyCodes.ESCAPE:
            sendEscape();
            break;
        default:
            if (mKeyboardSwitcher.isRightToLeftMode()) {
                if (primaryCode == (int) ')')
                    primaryCode = (int) '(';
                else if (primaryCode == (int) '(')
                    primaryCode = (int) ')';
            }
            if (isWordSeparator(primaryCode)) {
                handleSeparator(primaryCode);
            } else {
                if (mInputView != null && mInputView.isControl() && primaryCode >= 32 && primaryCode < 127) {
                    int controlCode = primaryCode & 31;
                    Log.d(TAG, "String_Node_Str" + primaryCode + "String_Node_Str" + controlCode);
                    if (controlCode == 9) {
                        sendTab();
                    } else {
                        ic.commitText(Character.toString((char) controlCode), 1);
                    }
                } else {
                    handleCharacter(primaryCode, key, multiTapIndex, nearByKeyCodes);
                }
                mJustAddedAutoSpace = false;
            }
            break;
    }
}

Output:
             } else {
-                if (mInputView != null && mInputView.isControl() && primaryCode >= 32 && primaryCode < 127) {
+                if (mControlKeyState.isActive() && primaryCode >= 32 && primaryCode < 127) {
                     int controlCode = primaryCode & 31;


Input:
public boolean canPay(Ability ability, UUID sourceId, UUID controllerId, Game game) {
    Permanent permanent = game.getPermanent(sourceId);
    if (permanent.getCounters().getCount(name) >= amount) {
        return true;
    }
    return false;
}

Output:
     Permanent permanent = game.getPermanent(sourceId);
-    if (permanent.getCounters().getCount(name) >= amount) {
+    if (permanent != null && permanent.getCounters().getCount(name) >= amount) {
         return true;


Input:
public void start(JSONObject serializedLog) {
    if (isTest) {
        insertSync(type(), serializedLog);
        flushSync();
    } else {
        new AsyncInsertTask(this, type(), serializedLog).execute();
        lazyTaskRunner.tryToStart();
    }
}

Output:
 public void start(JSONObject serializedLog) {
-    if (isTest) {
+    if (LogHouseConfiguration.isTest) {
         insertSync(type(), serializedLog);


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_menu_albums);
    ActionBar actionBar = getActionBar();
    actionBar.setDisplayHomeAsUpEnabled(true);
    listView = (ListView) findViewById(R.id.activity_menu_albums_list);
    items = kMP.songs.getAlbums();
    final ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, items);
    listView.setAdapter(adapter);
    listView.setOnItemClickListener(this);
}

Output:
     ActionBar actionBar = getActionBar();
-    actionBar.setDisplayHomeAsUpEnabled(true);
+    if (actionBar != null)
+        actionBar.setDisplayHomeAsUpEnabled(true);
     listView = (ListView) findViewById(R.id.activity_menu_albums_list);


Input:
public String toString() {
    return "String_Node_Str" + mStackId + "String_Node_Str" + mTaskHistory;
}

Output:
 public String toString() {
-    return "String_Node_Str" + mStackId + "String_Node_Str" + mTaskHistory;
+    return "String_Node_Str" + Integer.toHexString(System.identityHashCode(this)) + "String_Node_Str" + mStackId + "String_Node_Str" + mTaskHistory.size() + "String_Node_Str";
 }


Input:
public void modifyEvent(PrimitiveRenderEvent event) {
    if (iun == null)
        return;
    restoreEvent();
    String source = getSource((StructureSource) event.getSource());
    if (source == null)
        return;
    Set typeSet = (Set) targets.get(source);
    if (typeSet != null) {
        for (Iterator iter = typeSet.iterator(); iter.hasNext(); ) {
            ActionType type = (ActionType) iter.next();
            switch(type.getValue()) {
                case ActionType.HIGHLIGHT:
                    highlight(event);
                    break;
                case ActionType.TOGGLE_DATA_POINT_VISIBILITY:
                    hideLabel(event);
                    break;
                case ActionType.TOGGLE_VISIBILITY:
                    hideElement(event);
                    break;
            }
        }
    }
}

Output:
         return;
-    Set typeSet = (Set) targets.get(source);
+    Set<ActionType> typeSet = targets.get(source);
     if (typeSet != null) {


Input:
public static boolean silentSetBlock(Chunk chunk, BlockPos pos, Block block, int meta) {
    int dx = pos.getX() & 15;
    int dz = pos.getZ() & 15;
    int y = pos.getY();
    int i1 = dz << 4 | dx;
    try {
        int[] precMap = (int[]) field_Chunk_precipitationHeightMap.get(chunk);
        if (y >= precMap[i1] - 1) {
            precMap[i1] = -999;
        }
    } catch (Exception e) {
    }
    IBlockState state1 = chunk.getBlockState(dx, y, dz);
    Block block1 = state1.getBlock();
    int k1 = block1.getMetaFromState(state1);
    if (block1 == block && k1 == meta) {
        return false;
    } else {
        ExtendedBlockStorage extendedblockstorage = chunk.getBlockStorageArray()[y >> 4];
        if (extendedblockstorage == Chunk.NULL_BLOCK_STORAGE) {
            if (block == Blocks.AIR) {
                return false;
            }
            extendedblockstorage = chunk.getBlockStorageArray()[y >> 4] = new ExtendedBlockStorage(y >> 4 << 4, !chunk.getWorld().provider.isNether());
        }
        extendedblockstorage.set(dx, y & 15, dz, block.getStateFromMeta(meta));
        chunk.setModified(true);
        return true;
    }
}

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


Input:
private Bitmap getImageThumbnail(Context context, int kind) {
    if ((null == getMimeType(context)) || !getMimeType(context).startsWith("String_Node_Str")) {
        return null;
    }
    Bitmap thumbnailBitmap = null;
    try {
        ContentResolver resolver = context.getContentResolver();
        List uriPath = getUri().getPathSegments();
        long imageId;
        String lastSegment = (String) uriPath.get(uriPath.size() - 1);
        if (lastSegment.startsWith("String_Node_Str")) {
            lastSegment = lastSegment.substring("String_Node_Str".length());
        }
        imageId = Long.parseLong(lastSegment);
        thumbnailBitmap = MediaStore.Images.Thumbnails.getThumbnail(resolver, imageId, kind, null);
    } catch (Exception e) {
        Log.e(LOG_TAG, "String_Node_Str" + e.getMessage());
    }
    return thumbnailBitmap;
}

Output:
         List uriPath = getUri().getPathSegments();
-        long imageId;
+        Long imageId;
         String lastSegment = (String) uriPath.get(uriPath.size() - 1);


Input:
private void initServlets() {
    URLTranslator urlTranslator = new URLTranslator(new UUIDIdGenerator());
    ForwardingMapper forwardingMapper = new ForwardingMapper();
    addServlet("String_Node_Str", new HelloServlet());
    addServlet("String_Node_Str", new HeartbeatServlet(capturedBrowsers, new TimeImpl()));
    addServlet("String_Node_Str", new CaptureServlet(new BrowserHunter(capturedBrowsers)));
    addServlet("String_Node_Str", new StandaloneRunnerServlet(new BrowserHunter(capturedBrowsers), filesCache, new StandaloneRunnerFilesFilterImpl(), new SlaveResourceService(SlaveResourceService.RESOURCE_LOCATION)));
    addServlet("String_Node_Str", new SlaveResourceServlet(new SlaveResourceService(SlaveResourceService.RESOURCE_LOCATION)));
    addServlet("String_Node_Str", new CommandServlet(capturedBrowsers, urlTranslator, forwardingMapper));
    addServlet("String_Node_Str", new BrowserQueryResponseServlet(capturedBrowsers, urlTranslator, forwardingMapper));
    addServlet("String_Node_Str", new FileSetServlet(capturedBrowsers, filesCache));
    addServlet("String_Node_Str", new TestResourceServlet(filesCache));
    addServlet("String_Node_Str", new HomeServlet(capturedBrowsers));
    addServlet("String_Node_Str", new ForwardingServlet(forwardingMapper));
}

Output:
 private void initServlets() {
-    URLTranslator urlTranslator = new URLTranslator(new UUIDIdGenerator());
+    URLTranslator urlTranslator = new URLTranslator();
     ForwardingMapper forwardingMapper = new ForwardingMapper();


Input:
public void refresh(IElementParameter param, boolean check) {
    CCombo combo = (CCombo) hashCurControls.get(getParameterName(param));
    if (combo == null || combo.isDisposed()) {
        return;
    }
    updateComponentList(elem, param);
    String[] curComponentNameList = param.getListItemsDisplayName();
    String[] curComponentValueList = (String[]) param.getListItemsValue();
    Object value = param.getValue();
    boolean listContainValue = false;
    int numValue = 0;
    for (int i = 0; i < curComponentValueList.length && !listContainValue; i++) {
        if (curComponentValueList[i].equals(value)) {
            listContainValue = true;
            numValue = i;
        }
    }
    if (param.isContextMode()) {
        combo.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_YELLOW));
        combo.setEnabled(false);
        combo.setText((String) value);
    } else {
        combo.setItems(curComponentNameList);
        if (!listContainValue) {
            elem.setPropertyValue(getParameterName(param), "String_Node_Str");
        } else {
            combo.setText(curComponentNameList[numValue]);
        }
    }
}

Output:
         if (!listContainValue) {
-            elem.setPropertyValue(getParameterName(param), "String_Node_Str");
+            if (curComponentNameList.length > 0) {
+                elem.setPropertyValue(getParameterName(param), curComponentValueList[0]);
+                combo.setText(curComponentNameList[0]);
+            }
         } else {


Input:
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    prepareContentRect();
    Log.i(LOG_TAG, "String_Node_Str" + mContentRect.width() + "String_Node_Str" + mContentRect.height());
    if (this instanceof BarLineChartBase) {
        if (!((BarLineChartBase) this).hasFixedYValues())
            prepareMatrix();
    } else {
        prepareMatrix();
    }
}

Output:
     if (this instanceof BarLineChartBase) {
-        if (!((BarLineChartBase) this).hasFixedYValues())
+        BarLineChartBase b = (BarLineChartBase) this;
+        if (!b.hasFixedYValues() && !mMatrixOnLayoutPrepared) {
             prepareMatrix();


Input:
public static boolean hasAggregation(String expression) {
    if (expression == null)
        return false;
    try {
        return ExpressionParserUtility.hasAggregation(expression, ExpressionUtil.ROW_INDICATOR);
    } catch (BirtException e) {
        return false;
    }
}

Output:
     try {
-        return ExpressionParserUtility.hasAggregation(expression, ExpressionUtil.ROW_INDICATOR);
+        return ExpressionParserUtility.hasAggregation(expression, ExpressionUtil.ROW_INDICATOR) || ExpressionParserUtility.hasAggregation(expression, ExpressionUtil.DATASET_ROW_INDICATOR);
     } catch (BirtException e) {


Input:
private void showPost() {
    if (!TextUtils.isEmpty(mBlogId) && !TextUtils.isEmpty(mPostId)) {
        try {
            final long blogId = Long.parseLong(mBlogId);
            final long postId = Long.parseLong(mPostId);
            if (mIsFeed) {
                AnalyticsUtils.trackWithFeedPostDetails(AnalyticsTracker.Stat.READER_FEED_POST_INTERCEPTED, blogId, postId);
            } else {
                AnalyticsUtils.trackWithBlogPostDetails(AnalyticsTracker.Stat.READER_FEED_POST_INTERCEPTED, blogId, postId);
            }
            ReaderActivityLauncher.showReaderPostDetail(this, mIsFeed, blogId, postId, false);
        } catch (NumberFormatException e) {
            AppLog.e(T.READER, e);
        }
    } else {
        ToastUtils.showToast(this, R.string.error_generic);
    }
    finish();
}

Output:
             } else {
-                AnalyticsUtils.trackWithBlogPostDetails(AnalyticsTracker.Stat.READER_FEED_POST_INTERCEPTED, blogId, postId);
+                AnalyticsUtils.trackWithBlogPostDetails(AnalyticsTracker.Stat.READER_BLOG_POST_INTERCEPTED, blogId, postId);
             }


Input:
public void postParse(TypeDeclaration typeDec) {
    super.postParse(typeDec);
    ((DeclareAnnotation) declareDecl).setAnnotationMethod(new String(selector));
}

Output:
     super.postParse(typeDec);
-    ((DeclareAnnotation) declareDecl).setAnnotationMethod(new String(selector));
+    if (declareDecl != null) {
+        ((DeclareAnnotation) declareDecl).setAnnotationMethod(new String(selector));
+    }
 }


Input:
void updateExecutorStats(TopologyInfo info, MetricsState state, long now, boolean firstTime) {
    long overallTransferred = 0;
    long spoutTransferred = 0;
    long spoutAcked = 0;
    int executorsWithMetircs = 0;
    int spoutExecutors = 0;
    Map<String, List<Double>> comLat = new HashMap<String, List<Double>>();
    for (ExecutorSummary es : info.get_executors()) {
        String id = es.get_component_id();
        LOG.debug("String_Node_Str" + id);
        if (Utils.isSystemId(id)) {
            LOG.debug("String_Node_Str" + id);
            continue;
        }
        ExecutorStats exeStats = es.get_stats();
        if (exeStats != null) {
            ExecutorSpecificStats specs = exeStats.get_specific();
            ComponentCommon common = Utils.getComponentCommon(topology, id);
            for (String stream : common.get_streams().keySet()) {
                LOG.debug("String_Node_Str" + stream + "String_Node_Str" + id);
                executorsWithMetircs++;
                long transferred = MetricsUtils.getTransferred(exeStats, ALL_TIME, stream);
                overallTransferred += transferred;
                if (isSpout(specs)) {
                    if (isDefaultStream(stream) || isBatchStream(stream)) {
                        spoutExecutors++;
                        spoutTransferred += transferred;
                        SpoutStats spStats = specs.get_spout();
                        spoutAcked += MetricsUtils.getSpoutAcked(spStats, ALL_TIME, stream);
                        if (firstTime) {
                            header.add(MetricsUtils.getSpoutAvgCompleteLatencyTitle(id));
                        }
                        double lat = MetricsUtils.getSpoutCompleteLatency(spStats, ALL_TIME, stream);
                        MetricsUtils.addLatency(comLat, id, lat);
                    }
                }
            }
        } else {
            LOG.error("String_Node_Str" + id);
        }
    }
    for (String id : comLat.keySet()) {
        List<Double> latList = comLat.get(id);
        double avg = null == latList ? 0.0 : BenchmarkUtils.avg(latList);
        double max = null == latList ? 0.0 : BenchmarkUtils.max(latList);
        metrics.put(MetricsUtils.getSpoutAvgCompleteLatencyTitle(id), String.format(SPOUT_AVG_LATENCY_FORMAT, avg));
        metrics.put(MetricsUtils.getSpoutMaxCompleteLatencyTitle(id), String.format(SPOUT_MAX_LATENCY_FORMAT, max));
    }
    metrics.put(EXECUTORS_METRICS, Integer.toString(executorsWithMetircs));
    metrics.put(SPOUT_EXECUTORS, Integer.toString(spoutExecutors));
    long timeDiff = now - state.lastTime;
    long overallDiff = overallTransferred - state.overallTransferred;
    long spoutDiff = spoutTransferred - state.spoutTransferred;
    long throughput = (long) MetricsUtils.getThroughput(overallDiff, timeDiff);
    double throughputMB = (long) MetricsUtils.getThroughputMB(overallDiff, timeDiff, msgSize);
    long spoutThroughput = (long) MetricsUtils.getThroughput(spoutDiff, timeDiff);
    double spoutThroughputMB = (long) MetricsUtils.getThroughputMB(spoutDiff, timeDiff, msgSize);
    metrics.put(TRANSFERRED, Long.toString(overallDiff));
    metrics.put(THROUGHPUT, Long.toString(throughput));
    metrics.put(THROUGHPUT_MB, String.format(THROUGHPUT_MB_FORMAT, throughputMB));
    metrics.put(SPOUT_TRANSFERRED, Long.toString(spoutDiff));
    metrics.put(SPOUT_ACKED, Long.toString(spoutAcked));
    metrics.put(SPOUT_THROUGHPUT, Long.toString(spoutThroughput));
    metrics.put(SPOUT_THROUGHPUT_MB, String.format(SPOUT_THROUGHPUT_MB_FORMAT, spoutThroughputMB));
    state.overallTransferred = overallTransferred;
    state.spoutTransferred = spoutTransferred;
}

Output:
                 overallTransferred += transferred;
-                if (isSpout(specs)) {
+                if (isSpout) {
                     if (isDefaultStream(stream) || isBatchStream(stream)) {


Input:
protected void addDependencies(ExportFileResource[] allResources, ProcessItem processItem, Boolean needDependencies, ExportFileResource resource) {
    if (!needDependencies) {
        return;
    }
    Collection<IRepositoryViewObject> allDependencies = ProcessUtils.getAllProcessDependencies(Arrays.asList(new Item[] { processItem }), false);
    try {
        for (IRepositoryViewObject object : allDependencies) {
            Item item = object.getProperty().getItem();
            ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(item);
            IPath typeFolderPath = new Path(ERepositoryObjectType.getFolderName(itemType));
            String itemName = item.getProperty().getLabel();
            String itemVersion = item.getProperty().getVersion();
            String itemPath = item.getState().getPath();
            itemPath = (itemPath == null || itemPath.equals("String_Node_Str")) ? "String_Node_Str" : itemPath;
            IPath projectRootPath = getCorrespondingProjectRootPath(item);
            String projectName = getCorrespondingProjectName(item);
            IPath projectFilePath = getCorrespondingProjectRootPath(item).append(FileConstants.LOCAL_PROJECT_FILENAME);
            checkAndAddProjectResource(allResources, resource, JOB_ITEMS_FOLDER_NAME + PATH_SEPARATOR + projectName, FileLocator.toFileURL(projectFilePath.toFile().toURL()));
            IPath itemFilePath;
            String itemVersionString = (itemVersion == null) ? "String_Node_Str" : "String_Node_Str" + itemVersion;
            if (item.getFileExtension() == null || "String_Node_Str".equals(item.getFileExtension())) {
                itemFilePath = projectRootPath.append(typeFolderPath).append(itemPath).append(itemName + itemVersionString + "String_Node_Str" + FileConstants.ITEM_EXTENSION);
            } else {
                itemFilePath = projectRootPath.append(typeFolderPath).append(itemPath).append(itemName + itemVersionString + "String_Node_Str" + item.getFileExtension());
            }
            IPath propertiesFilePath = projectRootPath.append(typeFolderPath).append(itemPath).append(itemName + itemVersionString + "String_Node_Str" + FileConstants.PROPERTIES_EXTENSION);
            List<URL> metadataNameFileUrls = new ArrayList<URL>();
            metadataNameFileUrls.add(FileLocator.toFileURL(itemFilePath.toFile().toURL()));
            metadataNameFileUrls.add(FileLocator.toFileURL(propertiesFilePath.toFile().toURL()));
            String basePath = JOB_ITEMS_FOLDER_NAME + PATH_SEPARATOR + projectName + PATH_SEPARATOR + typeFolderPath.toString();
            if (itemPath != null && !"String_Node_Str".equals(itemPath)) {
                basePath = basePath + PATH_SEPARATOR + itemPath;
            }
            resource.addResources(basePath, metadataNameFileUrls);
        }
        if (org.talend.commons.utils.platform.PluginChecker.isTDQLoaded()) {
            ITDQItemService tdqItemService = (ITDQItemService) GlobalServiceRegister.getDefault().getService(ITDQItemService.class);
            if (tdqItemService != null && tdqItemService.hasProcessItemDependencies(Arrays.asList(new Item[] { processItem }))) {
                String defIdxFolderName = "String_Node_Str";
                String defIdxFileName = "String_Node_Str";
                IProject project = ReponsitoryContextBridge.getRootProject();
                IFile defIdxFile = project.getFile(defIdxFolderName + PATH_SEPARATOR + defIdxFileName);
                if (defIdxFile.exists()) {
                    String defIdxBasePath = JOB_ITEMS_FOLDER_NAME + PATH_SEPARATOR + project.getName().toLowerCase() + PATH_SEPARATOR + defIdxFolderName;
                    List<URL> defIdxUrls = new ArrayList<URL>();
                    defIdxUrls.add(project.getLocation().makeAbsolute().append(defIdxFolderName).append(defIdxFileName).toFile().toURI().toURL());
                    resource.addResources(defIdxBasePath, defIdxUrls);
                }
                String reportingBundlePath = PluginChecker.getBundlePath("String_Node_Str");
                List<URL> reportResourceUrls = new ArrayList<URL>();
                File imageFolder = new File(reportingBundlePath + PATH_SEPARATOR + "String_Node_Str");
                if (imageFolder.exists()) {
                    reportResourceUrls.add(imageFolder.toURI().toURL());
                }
                File templateFolder = new File(reportingBundlePath + PATH_SEPARATOR + "String_Node_Str");
                if (templateFolder.exists() && templateFolder.isDirectory()) {
                    reportResourceUrls.add(templateFolder.toURI().toURL());
                }
                resource.addResources(JOB_ITEMS_FOLDER_NAME + PATH_SEPARATOR, reportResourceUrls);
            }
        }
    } catch (Exception e) {
        ExceptionHandler.process(e);
    }
}

Output:
         }
-        if (org.talend.commons.utils.platform.PluginChecker.isTDQLoaded()) {
+        if (GlobalServiceRegister.getDefault().isServiceRegistered(ITDQItemService.class)) {
             ITDQItemService tdqItemService = (ITDQItemService) GlobalServiceRegister.getDefault().getService(ITDQItemService.class);


Input:
private CsvWriterSettings createSettings(final char delimiter, final char quote, final char escape, final char[] linebreak, final CSVOptions options) {
    CsvFormat format = new CsvFormat();
    format.setDelimiter(delimiter);
    format.setQuote(quote);
    format.setQuoteEscape(escape);
    format.setLineSeparator(linebreak);
    format.setNormalizedNewline(CSVSyntax.getNormalizedLinebreak(linebreak));
    CsvWriterSettings settings = new CsvWriterSettings();
    settings.setEmptyValue("String_Node_Str");
    settings.setNullValue("String_Node_Str");
    settings.setFormat(format);
    options.apply(settings);
    return settings;
}

Output:
     settings.setFormat(format);
-    options.apply(settings);
+    if (options != null) {
+        options.apply(settings);
+    }
     return settings;


Input:
public Kit getKit(String name) {
    KitDataAccess data = new KitDataAccess();
    try {
        Database.get().load(data, new String[] { "String_Node_Str" }, new Object[] { name });
        if (!data.hasData()) {
            return null;
        }
        Kit kit = new Kit();
        kit.setContentFromStrings(data.items);
        kit.setDelay(data.useDelay);
        kit.setGroups((String[]) data.groups.toArray());
        kit.setName(data.name);
        kit.setOwner((String[]) data.groups.toArray());
        kit.setId(data.id);
        return kit;
    } catch (DatabaseReadException e) {
        Canary.logStacktrace(e.getMessage(), e);
    }
    return null;
}

Output:
         kit.setDelay(data.useDelay);
-        kit.setGroups((String[]) data.groups.toArray());
+        kit.setGroups(data.groups.toArray(new String[0]));
         kit.setName(data.name);


Input:
protected Object readObject() throws IOException {
    short fieldCount = randomAccessFile.readShort();
    if (fieldCount == NULL_VALUE) {
        return null;
    }
    Object[] objects = new Object[fieldCount];
    for (int i = 0; i < objects.length; i++) {
        if (i < fieldReaders.length && fieldReaders[i].getDataType() != fieldWriters[i].getDataType())
            fieldReaders[i].setDataType(fieldWriters[i].getDataType());
        if (i >= fieldReaders.length) {
            objects[i] = fieldReaders[fieldReaders.length - 1].read(randomAccessFile);
        } else {
            objects[i] = fieldReaders[i].read(randomAccessFile);
        }
    }
    return creator.createInstance(objects);
}

Output:
 protected Object readObject() throws IOException {
-    short fieldCount = randomAccessFile.readShort();
+    short fieldCount = getRandomAccessFile().readShort();
     if (fieldCount == NULL_VALUE) {


Input:
public void dataReceived(USART source, int data) {
    if (DEBUG) {
        System.out.println("String_Node_Str" + Utils.hex8(data) + "String_Node_Str" + ((data >= ' ' && data <= 'Z') ? (char) data : '.') + ')' + "String_Node_Str" + chipSelect + "String_Node_Str" + state + "String_Node_Str" + stateMachine);
    }
    if ((stateMachine != STATE_VREG_OFF) && chipSelect) {
        switch(state) {
            case WAITING:
                if ((data & FLAG_READ) != 0) {
                    state = READ_REGISTER;
                } else {
                    state = WRITE_REGISTER;
                }
                if ((data & FLAG_RAM) != 0) {
                    state = RAM_ACCESS;
                    address = data & 0x7f;
                } else {
                    address = data & 0x3f;
                    if (address == REG_RXFIFO) {
                        state = READ_RXFIFO;
                    } else if (address == REG_TXFIFO) {
                        state = WRITE_TXFIFO;
                    }
                }
                if (data < 0x0f) {
                    strobe(data);
                }
                pos = 0;
                break;
            case WRITE_REGISTER:
                if (pos == 0) {
                    source.byteReceived(registers[address] >> 8);
                    registers[address] = (registers[address] & 0xff) | (data << 8);
                    pos = 1;
                } else {
                    source.byteReceived(registers[address] & 0xff);
                    registers[address] = (registers[address] & 0xff00) | data;
                    state = WAITING;
                }
                break;
            case READ_REGISTER:
                if (pos == 0) {
                    source.byteReceived(registers[address] >> 8);
                    pos = 1;
                } else {
                    source.byteReceived(registers[address] & 0xff);
                    if (DEBUG) {
                        System.out.println("String_Node_Str" + Utils.hex8(address) + "String_Node_Str" + registers[address]);
                    }
                    state = WAITING;
                }
                return;
            case READ_RXFIFO:
                if (rxfifo_len == 0)
                    break;
                if (DEBUG)
                    System.out.println("String_Node_Str" + rxfifo_read_pos + "String_Node_Str" + (memory[RAM_RXFIFO + rxfifo_read_pos] & 0xFF));
                source.byteReceived((memory[RAM_RXFIFO + rxfifo_read_pos] & 0xFF));
                rxfifo_read_pos++;
                setFIFOP(false);
                if (--rxfifo_len == 0)
                    setFIFO(false);
                if (rxfifo_read_pos >= 128) {
                    rxfifo_read_pos = 0;
                }
                if (rxPacket) {
                    rxPacket = false;
                    setFIFOP(false);
                }
                return;
            case WRITE_TXFIFO:
                if (txfifo_flush) {
                    txCursor = 0;
                    txfifo_flush = false;
                }
                if (DEBUG)
                    System.out.println("String_Node_Str" + data + "String_Node_Str" + txCursor);
                memory[RAM_TXFIFO + txCursor++] = data & 0xff;
                break;
            case RAM_ACCESS:
                if (pos == 0) {
                    address = address | (data << 1) & 0x180;
                    ramRead = (data & 0x20) != 0;
                    if (DEBUG) {
                        System.out.println("String_Node_Str" + Utils.hex16(address) + "String_Node_Str" + ramRead);
                    }
                    pos++;
                } else {
                    if (!ramRead) {
                        memory[address++] = data;
                        if (DEBUG && address == RAM_PANID + 2) {
                            System.out.println("String_Node_Str" + Utils.hex8(memory[RAM_PANID]) + Utils.hex8(memory[RAM_PANID + 1]));
                        }
                    } else {
                        source.byteReceived(memory[address++]);
                        return;
                    }
                }
                break;
        }
        source.byteReceived(status);
    }
}

Output:
             case READ_RXFIFO:
-                if (rxfifo_len == 0)
+                if (rxfifoLen == 0)
                     break;


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (GALLERY_INTENT_ID == requestCode) {
        try {
            currPic = Media.getBitmap(getContentResolver(), data.getData());
            if (currPic.getWidth() > 1080) {
                currPic = Bitmap.createScaledBitmap(currPic, 1080, 1920, false);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        imgFrame.setImageBitmap(currPic);
        try {
            FuncTracer.startProc("String_Node_Str");
            if (null == proc) {
                proc = new FaceAlignProc();
                proc.init(appCntx, model);
            }
            proc.searchInImage(appCntx, currPic);
            for (int t = 0; t < 5; t++) {
                proc.optimize(Algorithm.CQF);
            }
            FuncTracer.endProc("String_Node_Str");
            imgFrame.addPlot(proc);
        } catch (Exception e) {
            FuncTracer.procException(e);
            e.printStackTrace();
        }
    }
}

Output:
             }
-            proc.searchInImage(appCntx, currPic);
-            for (int t = 0; t < 5; t++) {
-                proc.optimize(Algorithm.CQF);
-            }
+            proc.searchInImage(appCntx, currPic, Algorithm.CQF);
             FuncTracer.endProc("String_Node_Str");


Input:
public void fire(final VmRunResponseType reply) {
    if (!reply.get_return()) {
        throw new EucalyptusClusterException("String_Node_Str" + this.getRequest().getInstanceId());
    }
    Logs.extreme().error(reply);
    EntityTransaction db = Entities.get(VmInstance.class);
    try {
        this.token.redeem();
        for (final VmInfo vmInfo : reply.getVms()) {
            final VmInstance vm = VmInstances.lookup(vmInfo.getInstanceId());
            vm.updateAddresses(vmInfo.getNetParams().getIpAddress(), vmInfo.getNetParams().getIgnoredPublicIp());
        }
        db.commit();
    } catch (Exception ex) {
        Logs.exhaust().error(ex, ex);
        db.rollback();
        throw new EucalyptusClusterException("String_Node_Str" + this.getRequest().getInstanceId() + "String_Node_Str" + ex.getMessage(), ex);
    }
}

Output:
     Logs.extreme().error(reply);
-    EntityTransaction db = Entities.get(VmInstance.class);
-    try {
-        this.token.redeem();
-        for (final VmInfo vmInfo : reply.getVms()) {
-            final VmInstance vm = VmInstances.lookup(vmInfo.getInstanceId());
-            vm.updateAddresses(vmInfo.getNetParams().getIpAddress(), vmInfo.getNetParams().getIgnoredPublicIp());
+    Predicate<VmRunResponseType> redeemToken = new Predicate<VmRunResponseType>() {
+        public boolean apply(final VmRunResponseType reply) {
+            EntityTransaction db = Entities.get(VmInstance.class);
+            try {
+                VmRunCallback.this.token.redeem();
+                for (final VmInfo vmInfo : reply.getVms()) {
+                    final VmInstance vm = VmInstances.lookup(vmInfo.getInstanceId());
+                    vm.updateAddresses(vmInfo.getNetParams().getIpAddress(), vmInfo.getNetParams().getIgnoredPublicIp());
+                }
+                db.commit();
+                return true;
+            } catch (Exception ex) {
+                Logs.exhaust().error(ex, ex);
+                db.rollback();
+                throw new EucalyptusClusterException("String_Node_Str" + VmRunCallback.this.getRequest().getInstanceId() + "String_Node_Str" + ex.getMessage(), ex);
+            }
         }


Input:
private void setTestSizeEstimator(IMap map, final long oneEntryHeapCostInMegaBytes) {
    final MapProxyImpl mapProxy = (MapProxyImpl) map;
    final MapService mapService = mapProxy.getService();
    final NodeEngine nodeEngine = mapService.getNodeEngine();
    final InternalPartitionService partitionService = nodeEngine.getPartitionService();
    for (int i = 0; i < partitionService.getPartitionCount(); i++) {
        final Address owner = partitionService.getPartitionOwner(i);
        if (nodeEngine.getThisAddress().equals(owner)) {
            final PartitionContainer container = mapService.getPartitionContainer(i);
            if (container == null) {
                continue;
            }
            final RecordStore recordStore = container.getRecordStore(map.getName());
            final DefaultRecordStore defaultRecordStore = (DefaultRecordStore) recordStore;
            defaultRecordStore.setSizeEstimator(new SizeEstimator() {
                long size;
                public long getSize() {
                    return size;
                }
                public void add(long size) {
                    this.size += size;
                }
                public long getCost(Object record) {
                    return convertMegaBytesToBytes(oneEntryHeapCostInMegaBytes);
                }
                public void reset() {
                    size = 0;
                }
            });
        }
    }
}

Output:
     final MapProxyImpl mapProxy = (MapProxyImpl) map;
-    final MapService mapService = mapProxy.getService();
+    final MapService mapService = (MapService) mapProxy.getService();
     final NodeEngine nodeEngine = mapService.getNodeEngine();


Input:
protected void onChildTerminatedEvent(String eventId, String instanceId) {
    List<ApplicationChildContext> terminationList;
    boolean allDependentTerminated = false;
    ApplicationChildContext context = this.startupDependencyTree.findApplicationContextWithIdInPrimaryTree(eventId);
    context.setTerminated(true);
    terminationList = this.startupDependencyTree.getTerminationDependencies(eventId);
    if (terminationList != null) {
        allDependentTerminated = allDependentTerminated(terminationList);
    }
    List<ApplicationChildContext> parentContexts = this.startupDependencyTree.findAllParentContextWithId(eventId);
    boolean parentsTerminated = false;
    boolean allParentsActive = false;
    if (parentContexts != null) {
        parentsTerminated = allParentTerminated(parentContexts, instanceId);
        allParentsActive = allParentActive(parentContexts, instanceId);
    }
    if ((terminationList.isEmpty() || allDependentTerminated) && (parentContexts.isEmpty() || parentsTerminated || allParentsActive)) {
        try {
            this.startDependencyOnTermination(parentInstanceId);
        } catch (TopologyInConsistentException e) {
            log.error("String_Node_Str" + e);
        }
    } else {
        ServiceReferenceHolder.getInstance().getGroupStatusProcessorChain().process(this.id, this.appId, instanceId);
        log.info("String_Node_Str");
    }
}

Output:
         try {
-            this.startDependencyOnTermination(parentInstanceId);
+            this.startDependencyOnTermination();
         } catch (TopologyInConsistentException e) {


Input:
private void createSelect(Select select) {
    if (null != select && null != select.getColumnMap() && !select.getColumnMap().isEmpty()) {
        Set<Selector> selectors = select.getColumnMap().keySet();
        if (isfucntion(selectors, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
            for (Selector selector : selectors) {
                if (SelectorUtils.isFunction(selector, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
                    FunctionSelector functionSelector = (FunctionSelector) selector;
                    if (select.isDistinct() && isfucntion(selectors, "String_Node_Str")) {
                        FunctionSelector function = (FunctionSelector) selector;
                        Selector field = function.getFunctionColumns().getSelectorList().get(0);
                        requestBuilder.addAggregation(AggregationBuilders.cardinality(function.getAlias()).field(SelectorUtils.getSelectorFieldName(field)));
                    } else {
                        requestBuilder.addAggregation(buildAggregation((FunctionSelector) selector, functionSelector.getFunctionName().toLowerCase().toString()));
                    }
                }
            }
            requestBuilder.setSize(0);
            return;
        }
        for (Selector selector : selectors) {
            String fieldName = SelectorUtils.getSelectorFieldName(selector);
            if (null != fieldName) {
                requestBuilder.addField(fieldName);
            }
        }
    }
}

Output:
         Set<Selector> selectors = select.getColumnMap().keySet();
-        if (isfucntion(selectors, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
+        if (isFunction(selectors, "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str")) {
             for (Selector selector : selectors) {


Input:
public Type getType(String arg) {
    String type = arg.replaceAll("String_Node_Str", "String_Node_Str");
    int arrayCount = arg.contains("String_Node_Str") ? arg.replaceAll("String_Node_Str", "String_Node_Str").length() / 2 : 0;
    Type result = getRefTypeUnsafe(type);
    if (result == null) {
        switch(type) {
            case "String_Node_Str":
                result = LongType.v();
                break;
            case "String_Node_Str":
                result = ShortType.v();
                break;
            case "String_Node_Str":
                result = DoubleType.v();
                break;
            case "String_Node_Str":
                result = IntType.v();
                break;
            case "String_Node_Str":
                result = FloatType.v();
                break;
            case "String_Node_Str":
                result = ByteType.v();
                break;
            case "String_Node_Str":
                result = CharType.v();
                break;
            case "String_Node_Str":
                result = VoidType.v();
                break;
            case "String_Node_Str":
                result = BooleanType.v();
                break;
            default:
                throw new RuntimeException("String_Node_Str" + type + "String_Node_Str");
        }
    }
    if (arrayCount != 0) {
        result = ArrayType.v(result, arrayCount);
    }
    return result;
}

Output:
     if (result == null) {
-        switch(type) {
-            case "String_Node_Str":
-                result = LongType.v();
-                break;
-            case "String_Node_Str":
-                result = ShortType.v();
-                break;
-            case "String_Node_Str":
-                result = DoubleType.v();
-                break;
-            case "String_Node_Str":
-                result = IntType.v();
-                break;
-            case "String_Node_Str":
-                result = FloatType.v();
-                break;
-            case "String_Node_Str":
-                result = ByteType.v();
-                break;
-            case "String_Node_Str":
-                result = CharType.v();
-                break;
-            case "String_Node_Str":
-                result = VoidType.v();
-                break;
-            case "String_Node_Str":
-                result = BooleanType.v();
-                break;
-            default:
-                throw new RuntimeException("String_Node_Str" + type + "String_Node_Str");
-        }
+        if (type.equals("String_Node_Str"))
+            result = LongType.v();
+        else if (type.equals("String_Node_Str"))
+            result = ShortType.v();
+        else if (type.equals("String_Node_Str"))
+            result = DoubleType.v();
+        else if (type.equals("String_Node_Str"))
+            result = IntType.v();
+        else if (type.equals("String_Node_Str"))
+            result = FloatType.v();
+        else if (type.equals("String_Node_Str"))
+            result = ByteType.v();
+        else if (type.equals("String_Node_Str"))
+            result = CharType.v();
+        else if (type.equals("String_Node_Str"))
+            result = VoidType.v();
+        else if (type.equals("String_Node_Str"))
+            result = BooleanType.v();
+        else
+            throw new RuntimeException("String_Node_Str" + type + "String_Node_Str");
     }