Input:
private void checkJsTypeMethodsForOverloads(Map<String, MethodBinding> methodNamesAndSigs, Map<String, MethodBinding> noExports, ReferenceBinding binding) {
    if (isJsType(binding)) {
        for (MethodBinding mb : binding.methods()) {
            String methodName = String.valueOf(mb.selector);
            if (JdtUtil.getAnnotation(mb, JsInteropUtil.JSNOEXPORT_CLASS) != null) {
                noExports.put(methodName, mb);
                continue;
            }
            if (mb.isConstructor() || mb.isStatic()) {
                continue;
            }
            if (JdtUtil.getAnnotation(mb, JsInteropUtil.JSPROPERTY_CLASS) != null) {
                if (isGetter(methodName, mb) || isSetter(methodName, mb) || isHas(methodName, mb)) {
                    continue;
                }
            }
            if (methodNamesAndSigs.containsKey(methodName)) {
                if (!methodNamesAndSigs.get(methodName).areParameterErasuresEqual(mb)) {
                    if (noExports.containsKey(methodName) && noExports.get(methodName).areParameterErasuresEqual(mb)) {
                        continue;
                    }
                    errorOn(mb, ERR_JSTYPE_OVERLOADS_NOT_ALLOWED);
                }
            } else {
                methodNamesAndSigs.put(methodName, mb);
            }
        }
    }
    for (ReferenceBinding rb : binding.superInterfaces()) {
        checkJsTypeMethodsForOverloads(methodNamesAndSigs, noExports, rb);
    }
}

Output:
             if (JdtUtil.getAnnotation(mb, JsInteropUtil.JSPROPERTY_CLASS) != null) {
-                if (isGetter(methodName, mb) || isSetter(methodName, mb) || isHas(methodName, mb)) {
+                if (isGetter(methodName, mb) || isSetter(methodName, mb)) {
                     continue;


Input:
private boolean checkCardNumber(String sNumber) {
    if (sNumber == null || (sNumber.length() != 16 && sNumber.length() != 15)) {
        return false;
    }
    for (int i = 0; i < 16; i++) {
        char c = sNumber.charAt(i);
        if (c != '0' && c != '1' && c != '2' && c != '3' && c != '4' && c != '5' && c != '6' && c != '7' && c != '8' && c != '9') {
            return false;
        }
    }
    return true;
}

Output:
 private boolean checkCardNumber(String sNumber) {
-    if (sNumber == null || (sNumber.length() != 16 && sNumber.length() != 15)) {
-        return false;
-    }
-    for (int i = 0; i < 16; i++) {
-        char c = sNumber.charAt(i);
-        if (c != '0' && c != '1' && c != '2' && c != '3' && c != '4' && c != '5' && c != '6' && c != '7' && c != '8' && c != '9') {
-            return false;
-        }
-    }
-    return true;
+    return LuhnAlgorithm.checkCC(sNumber);
 }


Input:
public static RequestPath getRequestPathObject(HttpServletRequest req) {
    RequestPath rr = new RequestPath();
    String url = req.getPathInfo();
    if (null == url)
        url = req.getServletPath();
    rr.setUrl(url);
    if (null != url) {
        int lio = url.lastIndexOf('.');
        if (lio > 0) {
            rr.setPath(url.substring(0, lio));
            rr.setSuffix(url.substring(lio + 1));
        } else {
            rr.setPath(url);
            rr.setSuffix("String_Node_Str");
        }
    } else {
        rr.setPath("String_Node_Str");
        rr.setSuffix("String_Node_Str");
    }
    return rr;
}

Output:
     if (null != url) {
-        int lio = url.lastIndexOf('.');
+        int lio = 0;
+        if (!url.endsWith("String_Node_Str")) {
+            int ll = url.lastIndexOf('/');
+            lio = url.lastIndexOf('.');
+            if (lio < ll)
+                lio = -1;
+        }
         if (lio > 0) {


Input:
private void DrawMouseOverLabel(GL gl, float x, float y, float z, float[] fArMappingColor, float fOpacity, int iContentIndex) {
    textRenderer.setColor(0, 0, 0, 1);
    z = z + 3.0f;
    x = x + 0.1f;
    gl.glTranslatef(x, y, z);
    String sLabel = "String_Node_Str" + set.get(SELECTED_X_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex) + "String_Node_Str" + set.get(SELECTED_Y_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex);
    float fScaling = renderStyle.getSmallFontScalingFactor();
    if (isRenderedRemote())
        fScaling *= 1.5f;
    Rectangle2D bounds = textRenderer.getScaledBounds(gl, sLabel, fScaling, ScatterPlotRenderStyle.MIN_NUMBER_TEXT_SIZE);
    float boxLengh = (float) bounds.getWidth() + 0.2f;
    float boxHight = (float) bounds.getHeight();
    gl.glColor3f(1.0f, 1.0f, 0.0f);
    gl.glBegin(GL.GL_POLYGON);
    gl.glVertex3f(0.0f, -0.02f, -0.1f);
    gl.glVertex3f(0.0f, boxHight, -0.1f);
    gl.glVertex3f(boxLengh, boxHight, -0.1f);
    gl.glVertex3f(boxLengh, -0.02f, -0.1f);
    gl.glEnd();
    gl.glPushAttrib(GL.GL_CURRENT_BIT | GL.GL_LINE_BIT);
    textRenderer.begin3DRendering();
    textRenderer.draw3D(gl, sLabel, 0, 0, ScatterPlotRenderStyle.TEXT_ON_LABEL_Z, fScaling, ScatterPlotRenderStyle.MIN_AXIS_LABEL_TEXT_SIZE);
    textRenderer.end3DRendering();
    gl.glPopAttrib();
    gl.glTranslatef(-x, -y, -z);
}

Output:
     gl.glTranslatef(x, y, z);
-    String sLabel = "String_Node_Str" + set.get(SELECTED_X_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex) + "String_Node_Str" + set.get(SELECTED_Y_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex);
+    String sLabel = "String_Node_Str";
+    if (elementSelectionManager.checkStatus(ESelectionType.SELECTION, iContentIndex))
+        sLabel = "String_Node_Str" + set.get(SELECTED_X_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex) + "String_Node_Str" + set.get(SELECTED_Y_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex);
+    else
+        sLabel = "String_Node_Str" + set.get(SELECTED_X_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex) + "String_Node_Str" + set.get(SELECTED_Y_AXIS).getFloat(EDataRepresentation.RAW, iContentIndex);
     float fScaling = renderStyle.getSmallFontScalingFactor();


Input:
public void warpTo(String name, Player player) {
    if (warpList.containsKey(name)) {
        Warp warp = warpList.get(name);
        if (warp.playerCanWarp(player.getName())) {
            warp.warp(player);
            player.sendMessage(Color.AQUA + warp.welcomeMessage);
        } else {
            player.sendMessage(Color.RED + "String_Node_Str" + name + "String_Node_Str");
        }
    } else {
        player.sendMessage(Color.RED + "String_Node_Str" + name + "String_Node_Str");
    }
}

Output:
             warp.warp(player);
-            player.sendMessage(Color.AQUA + warp.welcomeMessage);
+            player.sendMessage(ChatColor.AQUA + warp.welcomeMessage);
         } else {


Input:
public void openRequest(ParticipantId loggedInUser, WaveId waveId, IdFilter waveletIdFilter, Collection<WaveClientRpc.WaveletVersion> knownWavelets, OpenListener openListener) {
    LOG.info("String_Node_Str" + loggedInUser + "String_Node_Str" + waveId + "String_Node_Str" + waveletIdFilter + "String_Node_Str" + knownWavelets);
    if (loggedInUser == null) {
        openListener.onFailure("String_Node_Str");
        return;
    }
    if (!knownWavelets.isEmpty()) {
        openListener.onFailure("String_Node_Str");
        return;
    }
    try {
        waveletInfo.initialiseWave(waveId);
    } catch (WaveServerException e) {
        LOG.severe("String_Node_Str" + waveId, e);
        openListener.onFailure("String_Node_Str");
        return;
    }
    String channelId = generateChannelID();
    UserManager userManager = waveletInfo.getUserManager(loggedInUser);
    synchronized (userManager) {
        WaveViewSubscription subscription = userManager.subscribe(waveId, waveletIdFilter, channelId, openListener);
        LOG.info("String_Node_Str" + loggedInUser + "String_Node_Str" + waveId + "String_Node_Str" + channelId);
        Set<WaveletId> waveletIds;
        try {
            waveletIds = waveletInfo.visibleWaveletsFor(subscription, loggedInUser);
        } catch (WaveServerException e1) {
            waveletIds = Sets.newHashSet();
            LOG.warning("String_Node_Str" + loggedInUser, e1);
        }
        for (WaveletId waveletId : waveletIds) {
            WaveletName waveletName = WaveletName.of(waveId, waveletId);
            waveletInfo.notifyAddedImplcitParticipant(waveletName, loggedInUser);
            CommittedWaveletSnapshot snapshotToSend;
            try {
                snapshotToSend = waveletProvider.getSnapshot(waveletName);
            } catch (WaveServerException e) {
                LOG.warning("String_Node_Str" + waveletName, e);
                openListener.onFailure("String_Node_Str");
                return;
            }
            LOG.info("String_Node_Str" + (snapshotToSend != null));
            if (snapshotToSend == null) {
                openListener.onUpdate(waveletName, snapshotToSend, DeltaSequence.empty(), null, null, channelId);
            } else {
                openListener.onUpdate(waveletName, snapshotToSend, DeltaSequence.empty(), snapshotToSend.committedVersion, null, channelId);
            }
        }
        WaveletName dummyWaveletName = createDummyWaveletName(waveId);
        if (waveletIds.size() == 0) {
            LOG.info("String_Node_Str" + dummyWaveletName);
            openListener.onUpdate(dummyWaveletName, null, DeltaSequence.empty(), null, null, channelId);
        }
        LOG.info("String_Node_Str" + dummyWaveletName);
        openListener.onUpdate(dummyWaveletName, null, DeltaSequence.empty(), null, true, null);
    }
}

Output:
     UserManager userManager = waveletInfo.getUserManager(loggedInUser);
-    synchronized (userManager) {
-        WaveViewSubscription subscription = userManager.subscribe(waveId, waveletIdFilter, channelId, openListener);
-        LOG.info("String_Node_Str" + loggedInUser + "String_Node_Str" + waveId + "String_Node_Str" + channelId);
-        Set<WaveletId> waveletIds;
+    WaveViewSubscription subscription = userManager.subscribe(waveId, waveletIdFilter, channelId, openListener);
+    LOG.info("String_Node_Str" + loggedInUser + "String_Node_Str" + waveId + "String_Node_Str" + channelId);
+    Set<WaveletId> waveletIds;
+    try {
+        waveletIds = waveletInfo.visibleWaveletsFor(subscription, loggedInUser);
+    } catch (WaveServerException e1) {
+        waveletIds = Sets.newHashSet();
+        LOG.warning("String_Node_Str" + loggedInUser, e1);
+    }
+    for (WaveletId waveletId : waveletIds) {
+        WaveletName waveletName = WaveletName.of(waveId, waveletId);
+        waveletInfo.notifyAddedImplcitParticipant(waveletName, loggedInUser);
+        CommittedWaveletSnapshot snapshotToSend;
         try {


Input:
public void testWinningRevIDOfDoc() throws Exception {
    if (!isSQLiteDB())
        return;
    SQLiteStore store = (SQLiteStore) database.getStore();
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("String_Node_Str", "String_Node_Str");
    properties.put("String_Node_Str", 1337);
    Map<String, Object> properties2a = new HashMap<String, Object>();
    properties2a.put("String_Node_Str", "String_Node_Str");
    properties2a.put("String_Node_Str", 1338);
    Map<String, Object> properties2b = new HashMap<String, Object>();
    properties2b.put("String_Node_Str", "String_Node_Str");
    properties2b.put("String_Node_Str", 1339);
    AtomicBoolean outIsDeleted = new AtomicBoolean(false);
    AtomicBoolean outIsConflict = new AtomicBoolean(false);
    Document doc = database.createDocument();
    UnsavedRevision newRev1 = doc.createRevision();
    newRev1.setUserProperties(properties);
    SavedRevision rev1 = newRev1.save();
    long docNumericId = store.getDocNumericID(doc.getId());
    assertTrue(docNumericId != 0);
    assertEquals(rev1.getId(), store.winningRevIDOfDocNumericID(docNumericId, outIsDeleted, outIsConflict));
    assertFalse(outIsConflict.get());
    outIsDeleted.set(false);
    outIsConflict.set(false);
    UnsavedRevision newRev2a = rev1.createRevision();
    newRev2a.setUserProperties(properties2a);
    SavedRevision rev2a = newRev2a.save();
    assertEquals(rev2a.getId(), store.winningRevIDOfDocNumericID(docNumericId, outIsDeleted, outIsConflict));
    assertFalse(outIsConflict.get());
    outIsDeleted.set(false);
    outIsConflict.set(true);
    UnsavedRevision newRev2b = rev1.createRevision();
    newRev2b.setUserProperties(properties2b);
    SavedRevision rev2b = newRev2b.save(true);
    store.winningRevIDOfDocNumericID(docNumericId, outIsDeleted, outIsConflict);
    assertTrue(outIsConflict.get());
}

Output:
         return;
-    SQLiteStore store = (SQLiteStore) database.getStore();
+    Method m = database.getClass().getDeclaredMethod("String_Node_Str");
+    m.setAccessible(true);
+    SQLiteStore store = (SQLiteStore) m.invoke(database);
     Map<String, Object> properties = new HashMap<String, Object>();


Input:
public Token next() throws IOException {
    Token candidate;
    while ((candidate = baseTokeniser.next()) != null) {
        Float floatValue = Float.valueOf(candidate.termText());
        String valueString = NumericEncoder.encode(floatValue.floatValue());
        Token floatToken = new Token(valueString, candidate.startOffset(), candidate.startOffset(), candidate.type());
        return floatToken;
    }
    return null;
}

Output:
     while ((candidate = baseTokeniser.next()) != null) {
-        Float floatValue = Float.valueOf(candidate.termText());
-        String valueString = NumericEncoder.encode(floatValue.floatValue());
-        Token floatToken = new Token(valueString, candidate.startOffset(), candidate.startOffset(), candidate.type());
-        return floatToken;
+        try {
+            Float floatValue = Float.valueOf(candidate.termText());
+            String valueString = NumericEncoder.encode(floatValue.floatValue());
+            Token floatToken = new Token(valueString, candidate.startOffset(), candidate.startOffset(), candidate.type());
+            return floatToken;
+        } catch (NumberFormatException e) {
+        }
     }


Input:
private ProcessWrapperImpl getFFmpegThumbnail(InputFile media, boolean resume, RendererConfiguration renderer) {
    String[] args = new String[14];
    args[0] = getFfmpegPath();
    File file = media.getFile();
    boolean dvrms = file != null && file.getAbsolutePath().toLowerCase().endsWith("String_Node_Str");
    if (dvrms && isNotBlank(configuration.getFfmpegAlternativePath())) {
        args[0] = configuration.getFfmpegAlternativePath();
    }
    args[1] = "String_Node_Str";
    if (resume) {
        args[2] = "String_Node_Str" + (int) getDurationInSeconds();
    } else {
        args[2] = "String_Node_Str" + configuration.getThumbnailSeekPos();
    }
    args[3] = "String_Node_Str";
    if (file != null) {
        args[4] = ProcessUtil.getShortFileNameIfWideChars(file.getAbsolutePath());
    } else {
        args[4] = "String_Node_Str";
    }
    args[5] = "String_Node_Str";
    args[6] = "String_Node_Str";
    int thumbnailWidth = 320;
    int thumbnailHeight = 180;
    double thumbnailRatio = 1.78;
    boolean isThumbnailPadding = true;
    if (renderer != null) {
        thumbnailWidth = renderer.getThumbnailWidth();
        thumbnailHeight = renderer.getThumbnailHeight();
        thumbnailRatio = renderer.getThumbnailRatio();
        isThumbnailPadding = renderer.isThumbnailPadding();
    }
    if (isThumbnailPadding) {
        args[7] = "String_Node_Str";
        args[8] = "String_Node_Str" + thumbnailRatio + "String_Node_Str" + thumbnailWidth + "String_Node_Str" + thumbnailRatio + "String_Node_Str" + thumbnailHeight + "String_Node_Str" + thumbnailWidth + "String_Node_Str" + thumbnailHeight + "String_Node_Str" + thumbnailWidth + "String_Node_Str" + thumbnailHeight + "String_Node_Str";
    } else {
        args[7] = "String_Node_Str";
        args[8] = "String_Node_Str" + thumbnailRatio + "String_Node_Str" + thumbnailWidth + "String_Node_Str" + thumbnailRatio + "String_Node_Str" + thumbnailHeight + "String_Node_Str";
    }
    args[9] = "String_Node_Str";
    args[10] = "String_Node_Str";
    args[11] = "String_Node_Str";
    args[12] = "String_Node_Str";
    args[13] = "String_Node_Str";
    if (!configuration.isThumbnailGenerationEnabled() || !renderer.isThumbnails() || (configuration.isUseMplayerForVideoThumbs() && !dvrms)) {
        args[2] = "String_Node_Str";
        for (int i = 5; i <= 13; i++) {
            args[i] = "String_Node_Str";
        }
    }
    OutputParams params = new OutputParams(configuration);
    params.maxBufferSize = 1;
    params.stdin = media.getPush();
    params.noexitcheck = true;
    final ProcessWrapperImpl pw = new ProcessWrapperImpl(args, params, false, true);
    synchronized (parsingLock) {
        parsing = true;
    }
    Runnable r = new Runnable() {
        public void run() {
            try {
                Thread.sleep(10000);
                synchronized (ffmpeg_failureLock) {
                    ffmpeg_failure = true;
                }
            } catch (InterruptedException e) {
            }
            pw.stopProcess();
            synchronized (parsingLock) {
                parsing = false;
            }
        }
    };
    Thread failsafe = new Thread(r, "String_Node_Str");
    failsafe.start();
    pw.runInSameThread();
    synchronized (parsingLock) {
        parsing = false;
    }
    return pw;
}

Output:
     if (resume) {
-        args[2] = "String_Node_Str" + (int) getDurationInSeconds();
+        args[2] = Integer.toString((int) getDurationInSeconds());
     } else {


Input:
public OWLAxiom rename(OWLAxiom axiom) {
    Map<OWLEntity, OWLEntity> renaming = new HashMap<OWLEntity, OWLEntity>();
    renamer = new OWLClassExpressionRenamer(df, renaming);
    axiom.accept(this);
    return renamedAxiom;
}

Output:
     Map<OWLEntity, OWLEntity> renaming = new HashMap<OWLEntity, OWLEntity>();
-    renamer = new OWLClassExpressionRenamer(df, renaming);
+    expressionRenamer = new OWLClassExpressionRenamer(df, renaming);
     axiom.accept(this);


Input:
protected void handleMapTryLock(String[] args) {
    String key = args[1];
    long time = (args.length > 2) ? Long.valueOf(args[2]) : 0;
    boolean locked;
    if (time == 0) {
        locked = getMap().tryLock(key);
    } else {
        try {
            locked = getMap().tryLock(key, time, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            locked = false;
        }
    }
    println(locked);
}

Output:
     String key = args[1];
-    long time = (args.length > 2) ? Long.valueOf(args[2]) : 0;
+    long time = (args.length > 2) ? Long.parseLong(args[2]) : 0;
     boolean locked;


Input:
public boolean apply(Game game, Ability source) {
    Player cursedPlayer = game.getPlayer(targetPointer.getFirst(game, source));
    Player controller = game.getPlayer(source.getControllerId());
    if (cursedPlayer != null && controller != null) {
        if (cursedPlayer.chooseUse(outcome, "String_Node_Str", source, game)) {
            FilterControlledPermanent filter = new FilterControlledPermanent();
            filter.add(Predicates.or(new CardTypePredicate(CardType.CREATURE), new CardTypePredicate(CardType.PLANESWALKER)));
            TargetPermanent target = new TargetPermanent(filter);
            if (cursedPlayer.choose(outcome, target, source.getId(), game)) {
                Permanent objectToBeSacrificed = game.getPermanent(target.getFirstTarget());
                if (objectToBeSacrificed != null) {
                    if (objectToBeSacrificed.sacrifice(source.getId(), game)) {
                        return true;
                    }
                }
            }
        }
        cursedPlayer.loseLife(5, game, false);
    }
    return false;
}

Output:
     if (cursedPlayer != null && controller != null) {
-        if (cursedPlayer.chooseUse(outcome, "String_Node_Str", source, game)) {
-            FilterControlledPermanent filter = new FilterControlledPermanent();
-            filter.add(Predicates.or(new CardTypePredicate(CardType.CREATURE), new CardTypePredicate(CardType.PLANESWALKER)));
-            TargetPermanent target = new TargetPermanent(filter);
-            if (cursedPlayer.choose(outcome, target, source.getId(), game)) {
-                Permanent objectToBeSacrificed = game.getPermanent(target.getFirstTarget());
-                if (objectToBeSacrificed != null) {
-                    if (objectToBeSacrificed.sacrifice(source.getId(), game)) {
-                        return true;
-                    }
+        FilterControlledPermanent filter = new FilterControlledPermanent("String_Node_Str");
+        filter.add(Predicates.or(new CardTypePredicate(CardType.CREATURE), new CardTypePredicate(CardType.PLANESWALKER)));
+        TargetPermanent target = new TargetPermanent(filter);
+        if (cursedPlayer.choose(Outcome.Sacrifice, target, source.getId(), game)) {
+            Permanent objectToBeSacrificed = game.getPermanent(target.getFirstTarget());
+            if (objectToBeSacrificed != null) {
+                if (objectToBeSacrificed.sacrifice(source.getId(), game)) {
+                    return true;
                 }


Input:
public void run(ProgressIndicator indicator) {
    try {
        final GitRepository gitRepository = getRepositoryForGerritProject(project, changeInfo.getProject());
        final String notLoaded = "String_Node_Str";
        String ref = changeInfo.getCurrentRevision();
        GitCommit gitCommit = new GitCommit(Hash.create(ref), notLoaded, notLoaded, 0, notLoaded, notLoaded, 0, notLoaded, notLoaded, Collections.<Hash>emptyList(), Collections.<Change>emptyList());
        cherryPick(gitRepository, gitCommit, git, platformFacade, project);
    } finally {
        ApplicationManager.getApplication().invokeLater(new Runnable() {
            public void run() {
                VirtualFileManager.getInstance().syncRefresh();
                platformFacade.getChangeListManager(project).unblockModalNotifications();
            }
        });
    }
}

Output:
         String ref = changeInfo.getCurrentRevision();
-        GitCommit gitCommit = new GitCommit(Hash.create(ref), notLoaded, notLoaded, 0, notLoaded, notLoaded, 0, notLoaded, notLoaded, Collections.<Hash>emptyList(), Collections.<Change>emptyList());
+        GitHeavyCommit gitCommit = new GitHeavyCommit(virtualFile, AbstractHash.create(ref), new SHAHash(ref), notLoaded, notLoaded, new Date(0), notLoaded, notLoaded, Collections.<String>emptySet(), Collections.<FilePath>emptyList(), notLoaded, notLoaded, Collections.<String>emptyList(), Collections.<String>emptyList(), Collections.<String>emptyList(), Collections.<Change>emptyList(), 0);
         cherryPick(gitRepository, gitCommit, git, platformFacade, project);


Input:
public void generateWrappedBuiltin(FnID wrapperID, FnID builtinID, FunctionType ft, List<Var> outArgs, List<Var> userInArgs, ExecTarget mode, boolean isParallel, boolean isTargetable) throws UserException {
    List<Var> realInArgs = new ArrayList<Var>();
    realInArgs.addAll(userInArgs);
    TaskProps props = new TaskProps();
    if (isParallel) {
        Var par = new Var(Types.V_INT, Var.VALUEOF_VAR_PREFIX + "String_Node_Str", Alloc.LOCAL, DefType.INARG, VarProvenance.optimizerTmp());
        realInArgs.add(par);
        props.put(TaskPropKey.PARALLELISM, par.asArg());
        throw new STCRuntimeError("String_Node_Str" + "String_Node_Str");
    }
    if (isTargetable) {
        Var location = new Var(Types.V_INT, Var.VALUEOF_VAR_PREFIX + "String_Node_Str", Alloc.LOCAL, DefType.INARG, VarProvenance.optimizerTmp());
        realInArgs.add(location);
        props.put(TaskPropKey.LOCATION, location.asArg());
        Var softLocation = new Var(Types.V_BOOL, Var.VALUEOF_VAR_PREFIX + "String_Node_Str", Alloc.LOCAL, DefType.INARG, VarProvenance.optimizerTmp());
        realInArgs.add(softLocation);
        props.put(TaskPropKey.SOFT_LOCATION, softLocation.asArg());
    }
    Function fn = new Function(wrapperID, realInArgs, outArgs, ExecTarget.syncControl());
    this.program.addFunction(fn);
    WaitMode waitMode;
    if (!mode.isDispatched() && !isParallel) {
        waitMode = WaitMode.WAIT_ONLY;
    } else {
        waitMode = WaitMode.TASK_DISPATCH;
    }
    Block mainBlock = fn.mainBlock();
    boolean mustMapOutFiles = !program.foreignFunctions().canInitOutputMapping(builtinID);
    Pair<List<WaitVar>, Map<Var, Var>> p;
    p = WrapUtil.buildWaitVars(mainBlock, mainBlock.statementIterator(), userInArgs, Var.NONE, outArgs, mustMapOutFiles);
    List<WaitVar> waitVars = p.val1;
    Map<Var, Var> filenameVars = p.val2;
    WaitStatement wait = new WaitStatement(wrapperID.uniqueName() + "String_Node_Str", waitVars, PassedVar.NONE, Var.NONE, waitMode, true, mode, props);
    mainBlock.addContinuation(wait);
    Block waitBlock = wait.getBlock();
    List<Statement> instBuffer = new ArrayList<Statement>();
    List<Arg> inVals = WrapUtil.fetchLocalOpInputs(waitBlock, userInArgs, instBuffer, false);
    List<Var> outVals = WrapUtil.createLocalOpOutputs(waitBlock, outArgs, filenameVars, instBuffer, false, mustMapOutFiles, true);
    instBuffer.add(new LocalFunctionCall(wrapperID, inVals, outVals, program.foreignFunctions()));
    WrapUtil.setLocalOpOutputs(waitBlock, outArgs, outVals, instBuffer, !mustMapOutFiles, true);
    waitBlock.addStatements(instBuffer);
}

Output:
     List<Var> outVals = WrapUtil.createLocalOpOutputs(waitBlock, outArgs, filenameVars, instBuffer, false, mustMapOutFiles, true);
-    instBuffer.add(new LocalFunctionCall(wrapperID, inVals, outVals, program.foreignFunctions()));
+    instBuffer.add(new LocalFunctionCall(builtinID, inVals, outVals, program.foreignFunctions()));
     WrapUtil.setLocalOpOutputs(waitBlock, outArgs, outVals, instBuffer, !mustMapOutFiles, true);


Input:
private void work() throws InaccessibleConfigurationFileException, DriverNotFoundException, SQLException {
    if (!working) {
        working = true;
        new SchemaSynchronizer().synchronize();
        new DataSynchronizer().synchronize();
        working = false;
    }
}

Output:
 private void work() throws InaccessibleConfigurationFileException, DriverNotFoundException, SQLException {
-    if (!working) {
-        working = true;
-        new SchemaSynchronizer().synchronize();
-        new DataSynchronizer().synchronize();
-        working = false;
+    new SchemaSynchronizer().synchronize();
+    new DataSynchronizer().synchronize();
+    try {
+        Thread.sleep(15000);
+    } catch (InterruptedException ex) {
+        Logger.getLogger(Daemon.class.getName()).log(Level.SEVERE, null, ex);
     }


Input:
private Template resolveTemplate(String templateName) {
    templateName = templateName.toLowerCase();
    if (!excludePatterns.isEmpty()) {
        for (Pattern p : excludePatterns) {
            if (p.matcher(templateName).matches()) {
                return null;
            }
        }
    }
    Template template = templateByName.get(templateName);
    if (template == null) {
        for (TemplateResolver resolver : mediaWikiLanguage.getTemplateProviders()) {
            template = resolver.resolveTemplate(templateName);
            if (template != null) {
                template = normalize(template);
                break;
            }
        }
        if (template == null) {
            template = new Template();
            template.setName(templateName);
            template.setTemplateMarkup("String_Node_Str");
        }
        templateByName.put(template.getName().toLowerCase(), template);
    }
    return template;
}

Output:
         }
-        templateByName.put(template.getName().toLowerCase(), template);
+        templateByName.put(template.getName(), template);
     }


Input:
public void resolvePadding() {
    final int resolvedLayoutDirection = getLayoutDirection();
    if (!isRtlCompatibilityMode()) {
        if (mBackground != null && mUseBackgroundPadding) {
            Rect padding = sThreadLocal.get();
            if (padding == null) {
                padding = new Rect();
                sThreadLocal.set(padding);
            }
            mBackground.getPadding(padding);
            mUserPaddingLeftInitial = padding.left;
            mUserPaddingRightInitial = padding.right;
        }
        switch(resolvedLayoutDirection) {
            case LAYOUT_DIRECTION_RTL:
                if (mUserPaddingStart != UNDEFINED_PADDING) {
                    mUserPaddingRight = mUserPaddingStart;
                } else {
                    mUserPaddingRight = mUserPaddingRightInitial;
                }
                if (mUserPaddingEnd != UNDEFINED_PADDING) {
                    mUserPaddingLeft = mUserPaddingEnd;
                } else {
                    mUserPaddingLeft = mUserPaddingLeftInitial;
                }
                break;
            case LAYOUT_DIRECTION_LTR:
            default:
                if (mUserPaddingStart != UNDEFINED_PADDING) {
                    mUserPaddingLeft = mUserPaddingStart;
                } else {
                    mUserPaddingLeft = mUserPaddingLeftInitial;
                }
                if (mUserPaddingEnd != UNDEFINED_PADDING) {
                    mUserPaddingRight = mUserPaddingEnd;
                } else {
                    mUserPaddingRight = mUserPaddingRightInitial;
                }
        }
        mUserPaddingBottom = (mUserPaddingBottom >= 0) ? mUserPaddingBottom : mPaddingBottom;
    }
    internalSetPadding(mUserPaddingLeft, mPaddingTop, mUserPaddingRight, mUserPaddingBottom);
    onRtlPropertiesChanged(resolvedLayoutDirection);
    mPrivateFlags2 |= PFLAG2_PADDING_RESOLVED;
}

Output:
     if (!isRtlCompatibilityMode()) {
-        if (mBackground != null && mUseBackgroundPadding) {
+        if (mBackground != null && (!mLeftPaddingDefined || !mRightPaddingDefined)) {
             Rect padding = sThreadLocal.get();


Input:
public void toString(String prefix, StringBuilder buffer) {
    this.packageDecl.toString("String_Node_Str", buffer);
    buffer.append('\n');
    if (Formatting.Package.newLine) {
        buffer.append('\n');
    }
    for (IImport iimport : this.imports) {
        iimport.toString("String_Node_Str", buffer);
        buffer.append('\n');
    }
    if (Formatting.Import.newLine) {
        buffer.append('\n');
    }
    for (IClass iclass : this.classes) {
        iclass.toString("String_Node_Str", buffer);
        if (Formatting.Class.newLine) {
            buffer.append('\n');
        }
    }
}

Output:
     }
-    for (IImport iimport : this.imports) {
-        iimport.toString("String_Node_Str", buffer);
-        buffer.append('\n');
-    }
-    if (Formatting.Import.newLine) {
-        buffer.append('\n');
+    if (!this.imports.isEmpty()) {
+        for (IImport iimport : this.imports) {
+            iimport.toString("String_Node_Str", buffer);
+            buffer.append('\n');
+        }
+        if (Formatting.Import.newLine) {
+            buffer.append('\n');
+        }
     }


Input:
public List<HttpDataService> execute() {
    List<HttpDataService> listData = null;
    preyConfig = PreyConfig.getPreyConfig(ctx);
    if (preyConfig.isThisDeviceAlreadyRegisteredWithPrey(true)) {
        PreyTelephonyManager preyTelephony = PreyTelephonyManager.getInstance(ctx);
        PreyConnectivityManager preyConnectivity = PreyConnectivityManager.getInstance(ctx);
        boolean connection = false;
        try {
            while (!connection) {
                connection = preyTelephony.isDataConnectivityEnabled() || preyConnectivity.isConnected();
                if (!connection) {
                    PreyLogger.d("String_Node_Str");
                    if (!PreyWifiManager.getInstance(ctx).isWifiEnabled())
                        PreyWifiManager.getInstance(ctx).setWifiEnabled(true);
                    if (!NetworkUtils.getNetworkUtils(ctx).isMobileDataEnabled())
                        NetworkUtils.getNetworkUtils(ctx).enableMobileData(true);
                    Thread.sleep(10000);
                }
            }
            List<JSONObject> jsonObject = getInstructions();
            PreyLogger.d("String_Node_Str" + version + "String_Node_Str" + body);
            if (jsonObject == null || jsonObject.size() == 0) {
                PreyLogger.d("String_Node_Str");
            } else {
                PreyLogger.d("String_Node_Str");
                runInstructions(jsonObject);
            }
        } catch (Exception e) {
            PreyLogger.e("String_Node_Str" + e.getMessage(), e);
        }
        PreyLogger.d("String_Node_Str");
    }
    return listData;
}

Output:
     }
-    return listData;
+    ctx.stopService(new Intent(ctx, PreyBetaRunnerService.class));
 }


Input:
public void onUpdate(final UpdateEvent event) {
    if (event.concern(UpdateEvent.PROJECT_DELETE)) {
        final PageRequest request = event.getParam(0);
        view.getTabBar().removeTab(new MenuTabId(request));
    }
}

Output:
 public void onUpdate(final UpdateEvent event) {
-    if (event.concern(UpdateEvent.PROJECT_DELETE)) {
+    if (event.concern(UpdateEvent.CONTACT_DELETE)) {
         final PageRequest request = event.getParam(0);


Input:
public void onActivityResult(final int requestCode, final int resultCode, final Intent intent) {
    ActivityCompat.invalidateOptionsMenu(getActivity());
    if (requestCode == ADD_RECORD_RESULT_CODE && resultCode == AddCoinapultAccountActivity.RESULT_COINAPULT) {
        UUID accountId = (UUID) intent.getSerializableExtra(AddAccountActivity.RESULT_KEY);
        CoinapultAccount account = (CoinapultAccount) _mbwManager.getWalletManager(false).getAccount(accountId);
        _mbwManager.setSelectedAccount(accountId);
        _focusedAccount = account;
        update();
        return;
    }
    if (requestCode == ADD_RECORD_RESULT_CODE && resultCode == Activity.RESULT_OK) {
        UUID accountid = (UUID) intent.getSerializableExtra(AddAccountActivity.RESULT_KEY);
        WalletAccount account = _mbwManager.getWalletManager(false).getAccount(accountid);
        if (account.isActive()) {
            _mbwManager.setSelectedAccount(accountid);
        }
        _focusedAccount = account;
        update();
        if (!(account instanceof ColuAccount)) {
            setNameForNewAccount(_focusedAccount);
        }
    } else if (requestCode == ADD_RECORD_RESULT_CODE && resultCode == AddAdvancedAccountActivity.RESULT_MSG) {
        new AlertDialog.Builder(getActivity()).setMessage(intent.getStringExtra(AddAccountActivity.RESULT_MSG)).setPositiveButton(R.string.button_ok, null).create().show();
    } else {
        super.onActivityResult(requestCode, resultCode, intent);
    }
}

Output:
         _mbwManager.setSelectedAccount(accountId);
-        _focusedAccount = account;
+        accountListAdapter.setFocusedAccount(account);
         update();


Input:
public ClassFileTransformer getTransformer(ClassLoader classLoader, String targetClassName) {
    if (transformerMap.isEmpty()) {
        return null;
    }
    ClassFileTransformer transformer = transformerMap.remove(new TransformerKey(classLoader, targetClassName));
    if (logger.isDebugEnabled()) {
        logger.info("String_Node_Str", classLoader, targetClassName, transformerMap.size());
    }
    return transformer;
}

Output:
     }
-    ClassFileTransformer transformer = transformerMap.remove(new TransformerKey(classLoader, targetClassName));
+    final TransformerKey key = new TransformerKey(classLoader, targetClassName);
+    final ClassFileTransformer transformer = transformerMap.remove(key);
     if (logger.isDebugEnabled()) {


Input:
public static Term[] toSortedSetArray(final Term... arg) {
    switch(arg.length) {
        case 0:
            return EmptyTermArray;
        case 1:
            return new Term[] { arg[0] };
        case 2:
            final Term a = arg[0];
            final Term b = arg[1];
            final int c = a.compareTo(b);
            if (Parameters.DEBUG) {
                final boolean equal = a.equals(b);
                if ((equal && (c != 0)) || (!equal && (c == 0))) {
                    throw new IllegalStateException("String_Node_Str" + a + "String_Node_Str" + b);
                }
            }
            if (c < 0)
                return new Term[] { a, b };
            else if (c > 0)
                return new Term[] { b, a };
            else if (c == 0)
                return new Term[] { a };
    }
    final NavigableSet<Term> s = new TreeSet();
    Collections.addAll(s, arg);
    return s.toArray(new Term[s.size()]);
}

Output:
     Collections.addAll(s, arg);
-    return s.toArray(new Term[s.size()]);
+    return s.toArray(new Term[0]);
 }


Input:
public Container getContainer(short x) {
    int i = this.binarySearch(0, nbKeys, x);
    if (i < 0)
        return null;
    return this.array[i].value;
}

Output:
 public Container getContainer(short x) {
-    int i = this.binarySearch(0, nbKeys, x);
+    int i = this.binarySearch(0, size, x);
     if (i < 0)


Input:
public void onAsyncFacilityQueryCompleted(List<Facility> result) {
    MyLog.i(TAG, "String_Node_Str" + result.size());
    final List<Overlay> overlays = mapView.getOverlays();
    overlays.clear();
    if (result.size() == 0) {
        MyLog.d(TAG, "String_Node_Str");
        overlays.add(locationOverlay);
    } else {
        overlays.add(new FaciltiesOverlayBuilder(drawableCache).buildOverlay(result, this));
        overlays.add(locationOverlay);
        if (state.routeInformation != null) {
            overlays.add(routeOverlayManager.getOrRestoreOverlay(state.routeInformation));
        }
    }
    MyLog.d(TAG, "String_Node_Str");
    mapView.invalidate();
    getSherlock().setProgressBarIndeterminateVisibility(false);
}

Output:
     overlays.clear();
-    if (result.size() == 0) {
-        MyLog.d(TAG, "String_Node_Str");
-        overlays.add(locationOverlay);
-    } else {
+    if (result.size() > 0) {
         overlays.add(new FaciltiesOverlayBuilder(drawableCache).buildOverlay(result, this));


Input:
public void init() {
    balance = new Balancer();
    soundGrid.add(balance, 1, 1);
    balance.setPrefSize(50, 20);
    balance.setMax(PLAYBACK.getBalanceMax());
    balance.setMin(PLAYBACK.getBalanceMin());
    balance.balanceProperty().bindBidirectional(PLAYBACK.balanceProperty());
    volume.setMin(PLAYBACK.getVolumeMin());
    volume.setMax(PLAYBACK.getVolumeMax());
    volume.setValue(PLAYBACK.getVolume());
    volume.valueProperty().bindBidirectional(PLAYBACK.volumeProperty());
    seeker.bindTime(PLAYBACK.totalTimeProperty(), PLAYBACK.currentTimeProperty());
    entireArea.getChildren().add(seeker);
    AnchorPane.setBottomAnchor(seeker, 0.0);
    AnchorPane.setLeftAnchor(seeker, 0.0);
    AnchorPane.setRightAnchor(seeker, 0.0);
    seeker.setChapterSnapDistance(GUI.snapDistance);
    p1.setOnMouseClicked(e -> rewind());
    f2.setOnMouseClicked(e -> previous());
    f3.setOnMouseClicked(e -> play_pause());
    f4.setOnMouseClicked(e -> next());
    f5.setOnMouseClicked(e -> forward());
    f6.setOnMouseClicked(e -> stop());
    playButtons.getChildren().setAll(p1, f2, f3, f4, f5, f6);
    Tooltip.install(addB, new Tooltip("String_Node_Str"));
    addB.setOnMouseClicked(e -> {
        if (e.getButton() == MouseButton.PRIMARY)
            PlaylistManager.addOrEnqueueFiles(true);
        else
            PlaylistManager.addOrEnqueueFolder(true);
    });
    entireArea.getChildren().add(addB);
    AnchorPane.setTopAnchor(addB, 5d);
    AnchorPane.setLeftAnchor(addB, 5d);
    loopB.setOnMouseClicked(e -> PLAYBACK.toggleLoopMode());
    loopB.setScaleX(1.3);
    infoBox.getChildren().add(1, loopB);
    muteB.setOnMouseClicked(e -> cycleMute());
    soundGrid.add(muteB, 0, 0);
    playingItemMonitoring = Player.playingtem.subscribeToUpdates(this::playingItemChanged);
    playingItemChanged(Player.playingtem.get());
    PLAYBACK.statusProperty().addListener(statusListener);
    statusChanged(PLAYBACK.getStatus());
    PLAYBACK.loopModeProperty().addListener(loopModeListener);
    loopModeChanged(PLAYBACK.getLoopMode());
    PLAYBACK.muteProperty().addListener(muteListener);
    muteChanged(PLAYBACK.getMute(), volume.getValue());
    PLAYBACK.totalTimeProperty().addListener(totalTimeListener);
    PLAYBACK.realTimeProperty().addListener(realTimeListener);
    PLAYBACK.currentTimeProperty().addListener(currTimeListener);
    currTimeListener.invalidated(null);
    ChangeListener<Number> volumeListener = (o, ov, nv) -> muteChanged(PLAYBACK.isMute(), nv.doubleValue());
    volume.valueProperty().addListener(volumeListener);
    entireArea.setOnDragOver(DragUtil.audioDragAccepthandler);
    entireArea.setOnDragDropped(e -> {
        if (DragUtil.hasAudio(e.getDragboard())) {
            List<Item> items = DragUtil.getAudioItems(e);
            e.setDropCompleted(true);
            e.consume();
            if (playDropped) {
                PlaylistManager.playPlaylist(new Playlist(items.stream().map(Item::getURI), true));
            } else {
                PlaylistManager.addItems(items);
            }
        }
    });
}

Output:
     AnchorPane.setRightAnchor(seeker, 0.0);
-    seeker.setChapterSnapDistance(GUI.snapDistance);
+    d1 = maintain(GUI.snapDistance, d -> d, seeker.chapterSnapDistance);
     p1.setOnMouseClicked(e -> rewind());


Input:
public org.hl7.fhir.dstu2.model.Encounter.EncounterClass convertEncounterClass(org.hl7.fhir.dstu3.model.Coding src) throws FHIRException {
    if (src == null)
        return null;
    if (src.getSystem().equals("String_Node_Str")) {
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.INPATIENT;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.AMBULATORY;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.EMERGENCY;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.HOME;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.FIELD;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.DAYTIME;
        if (src.getCode().equals("String_Node_Str"))
            return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.VIRTUAL;
    }
    return org.hl7.fhir.dstu2.model.Encounter.EncounterClass.NULL;
}

Output:
 public org.hl7.fhir.dstu2.model.Encounter.EncounterClass convertEncounterClass(org.hl7.fhir.dstu3.model.Coding src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public void testSoakTestWithRandomData() throws IOException, InterruptedException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    System.out.print("String_Node_Str");
    for (int j = 1; j < 10000; j++) {
        if (j % 100 == 0)
            System.out.print("String_Node_Str");
        Random rnd = new Random(j);
        if (rnd.nextInt(10) < 2)
            time++;
        final long t = time;
        final int key = rnd.nextInt(1000);
        addRandomDelay(executorService, rnd);
        if (rnd.nextBoolean()) {
            final CharSequence value = "String_Node_Str" + j;
            if (rnd.nextBoolean()) {
                map1.put(key, value);
                task.incrementAndGet();
                executorService.submit(new Runnable() {
                    public void run() {
                        map2.put0(key, value, true, (byte) 1, t);
                        task.decrementAndGet();
                    }
                });
            } else {
                map2.put(key, value);
                task.incrementAndGet();
                executorService.submit(new Runnable() {
                    public void run() {
                        map1.put0(key, value, true, (byte) 2, t);
                        task.decrementAndGet();
                    }
                });
            }
        } else {
            if (rnd.nextBoolean()) {
                map1.remove(key);
                task.incrementAndGet();
                executorService.submit(new Runnable() {
                    public void run() {
                        map2.remoteRemove(key, (byte) 1, t);
                        task.decrementAndGet();
                    }
                });
            } else {
                map2.remove(key);
                task.incrementAndGet();
                executorService.submit(new Runnable() {
                    public void run() {
                        map1.remoteRemove(key, (byte) 2, t);
                        task.decrementAndGet();
                    }
                });
            }
        }
    }
    while (task.get() > 0) {
    }
    Assert.assertEquals(new TreeMap(map1), new TreeMap(map2));
}

Output:
             if (rnd.nextBoolean()) {
-                map1.put(key, value);
+                map1.put(key, value, (byte) 1, t);
                 task.incrementAndGet();


Input:
public void actionPerformed(ActionEvent e) {
    if (expandButton.isSelected()) {
        expandButton.setIcon(View.getIcon("String_Node_Str"));
    }
    scrollPane.setVisible(expandButton.isSelected());
    scrollPane.setMinimumSize(new Dimension(getWidth(), 500));
    scrollPane.setSize(new Dimension(getWidth(), 500));
    revalidate();
    repaint();
}

Output:
 public void actionPerformed(ActionEvent e) {
-    if (expandButton.isSelected()) {
-        expandButton.setIcon(View.getIcon("String_Node_Str"));
-    }
+    expandButton.setIcon(expandButton.isSelected() ? expandIcon : collapseIcon);
     scrollPane.setVisible(expandButton.isSelected());


Input:
private boolean checkKeyValue(String oldValue, String newValue) {
    String errorMsg = null;
    boolean canModify = true;
    if (!Pattern.matches(SCHEMA_NAME_PATTERN, newValue)) {
        errorMsg = "String_Node_Str" + newValue + "String_Node_Str";
    } else {
        final Object input = schemaTreeViewer.getInput();
        if (input instanceof SchemasKeyData) {
            List<String> list = new ArrayList<String>();
            final List<SchemasKeyData> children = ((SchemasKeyData) input).getChildren();
            for (SchemasKeyData schema : children) {
                final String name = schema.getUniqueRecord();
                if (!name.equals(oldValue)) {
                    list.add(name);
                }
            }
            if (list.contains(newValue)) {
                errorMsg = "String_Node_Str" + newValue + "String_Node_Str";
            }
        }
    }
    if (errorMsg != null) {
        MessageDialog.openError(schemaTreeViewer.getTree().getShell(), "String_Node_Str", errorMsg);
        canModify = false;
    }
    return canModify;
}

Output:
                 if (!name.equals(oldValue)) {
-                    list.add(name);
+                    list.add(name.toUpperCase());
                 }


Input:
public Document objectToXML(Object object, XMLDescriptor descriptor, XMLRecord xmlRow, boolean isXMLRoot) {
    Document document = null;
    NamespaceResolver resolver = new NamespaceResolver();
    this.copyNamespaces(descriptor.getNamespaceResolver(), resolver);
    boolean shouldCallSetAttributeNS = false;
    boolean isRootDocumentFragment = false;
    if (xmlRow != null) {
        isRootDocumentFragment = (xmlRow.getDOM().getNodeType() == Node.DOCUMENT_FRAGMENT_NODE);
    }
    if (isXMLRoot) {
        String xmlRootUri = ((XMLRoot) object).getNamespaceURI();
        String xmlRootPrefix = null;
        if (xmlRow == null) {
            String recordName = ((XMLRoot) object).getLocalName();
            if (xmlRootUri != null) {
                xmlRootPrefix = resolver.resolveNamespaceURI(xmlRootUri);
                if (xmlRootPrefix == null) {
                    xmlRootPrefix = resolver.generatePrefix();
                    resolver.put(xmlRootPrefix, xmlRootUri);
                }
                recordName = xmlRootPrefix + "String_Node_Str" + recordName;
                shouldCallSetAttributeNS = true;
            }
            xmlRow = (XMLRecord) ((XMLObjectBuilder) descriptor.getObjectBuilder()).createRecordFor(((XMLRoot) object).getObject(), xmlContext.getDocumentPreservationPolicy(xmlContext.getSession(descriptor)), recordName, xmlRootUri);
            xmlRow.setMarshaller(this);
            if (!isRootDocumentFragment) {
                if (shouldCallSetAttributeNS) {
                    if (xmlRootPrefix != null) {
                        ((Element) xmlRow.getDOM()).setAttributeNS(XMLConstants.XMLNS_URL, XMLConstants.XMLNS + "String_Node_Str" + xmlRootPrefix, xmlRootUri);
                    }
                    shouldCallSetAttributeNS = false;
                }
            }
        }
        copyNamespaces(resolver, xmlRow.getNamespaceResolver());
        document = xmlRow.getDocument();
        Element docElement = document.getDocumentElement();
        xmlRow.getNamespaceResolver().put(XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.SCHEMA_INSTANCE_URL);
        boolean writeTypeAttribute = shouldWriteTypeAttribute(object, descriptor, isXMLRoot);
        if (writeTypeAttribute && (descriptor.getSchemaReference() != null) && (descriptor.getSchemaReference().getSchemaContext() != null)) {
            ((Element) xmlRow.getDOM()).setAttributeNS(XMLConstants.XMLNS_URL, XMLConstants.XMLNS + "String_Node_Str" + XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.SCHEMA_INSTANCE_URL);
            String typeValue = descriptor.getSchemaReference().getSchemaContext();
            typeValue = typeValue.substring(1);
            XMLField xsiTypefield = new XMLField("String_Node_Str");
            xsiTypefield.setNamespaceResolver(xmlRow.getNamespaceResolver());
            XPathEngine.getInstance().create(xsiTypefield, docElement, typeValue);
        }
        object = ((XMLRoot) object).getObject();
    }
    XMLObjectBuilder bldr = (XMLObjectBuilder) descriptor.getObjectBuilder();
    xmlRow = (XMLRecord) bldr.buildRow(xmlRow, object, xmlContext.getSession(object), isXMLRoot);
    xmlRow.setMarshaller(this);
    if (shouldCallSetAttributeNS && !isRootDocumentFragment) {
        ((Element) xmlRow.getDOM()).setAttributeNS(XMLConstants.XMLNS_URL, XMLConstants.XMLNS + "String_Node_Str" + XMLConstants.SCHEMA_INSTANCE_PREFIX, XMLConstants.SCHEMA_INSTANCE_URL);
    }
    document = xmlRow.getDocument();
    addSchemaLocations(document);
    return document;
}

Output:
     XMLObjectBuilder bldr = (XMLObjectBuilder) descriptor.getObjectBuilder();
-    xmlRow = (XMLRecord) bldr.buildRow(xmlRow, object, xmlContext.getSession(object), isXMLRoot);
+    xmlRow = (XMLRecord) bldr.buildRow(xmlRow, object, (AbstractSession) xmlContext.getSession(object), isXMLRoot);
     xmlRow.setMarshaller(this);


Input:
public void setStructure(Structure s) {
    if (jmolPanel == null) {
        System.err.println("String_Node_Str");
        return;
    }
    setTitle(s.getPDBCode());
    jmolPanel.setStructure(s);
    structure = s;
}

Output:
     if (jmolPanel == null) {
-        System.err.println("String_Node_Str");
+        logger.error("String_Node_Str");
         return;


Input:
public INDArray transposei() {
    if (isRowVector())
        return Nd4j.create(data, shape.length == 1 ? new int[] { shape[0], 1 } : ArrayUtil.reverseCopy(shape()), offset);
    else if (isColumnVector())
        return Nd4j.create(data, new int[] { 1, shape[0] }, offset);
    if (isMatrix()) {
        if (this instanceof IComplexNDArray) {
            IComplexNDArray arr = Nd4j.createComplex(columns(), rows());
            IComplexNDArray arrThis = (IComplexNDArray) this;
            for (int i = 0; i < arr.rows(); i++) {
                for (int j = 0; j < arr.columns(); j++) arr.put(i, j, arrThis.getComplex(j, i));
            }
            return arr;
        } else {
            INDArray arr = Nd4j.create(columns(), rows());
            for (int i = 0; i < arr.rows(); i++) {
                for (int j = 0; j < arr.columns(); j++) arr.put(i, j, getDouble(j, i));
            }
            return arr;
        }
    }
    INDArray arr = Nd4j.create(ArrayUtil.reverseCopy(shape()));
    for (int i = 0; i < arr.slices(); i++) {
        arr.putSlice(i, arr.slice(i).transpose());
    }
    return arr;
}

Output:
     if (isRowVector())
-        return Nd4j.create(data, shape.length == 1 ? new int[] { shape[0], 1 } : ArrayUtil.reverseCopy(shape()), offset);
+        return create(data, shape.length == 1 ? new int[] { shape[0], 1 } : ArrayUtil.reverseCopy(shape()), offset);
     else if (isColumnVector())


Input:
private Set<IStorage> resolveTraversal(IFile file, Set<URI> bounds, IStorageProviderAccessor storageAccessor) {
    final Set<IStorage> traversal = new LinkedHashSet<IStorage>();
    final Iterable<URI> dependencies = getDependenciesOf(file, bounds);
    for (URI uri : dependencies) {
        final IFile dependencyFile = getFileAt(uri);
        try {
            if (!storageAccessor.isInSync(dependencyFile)) {
                traversal.add(dependencyFile);
            }
        } catch (CoreException e) {
        }
    }
    return traversal;
}

Output:
     for (URI uri : dependencies) {
-        final IFile dependencyFile = getFileAt(uri);
-        try {
-            if (!storageAccessor.isInSync(dependencyFile)) {
-                traversal.add(dependencyFile);
-            }
-        } catch (CoreException e) {
-        }
+        traversal.add(getFileAt(uri));
     }


Input:
public void testValidation() throws Exception {
    BytesRef[] validIps = { new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str") };
    for (BytesRef ip : validIps) {
        assertEquals(true, IpType.isValid(ip));
    }
    BytesRef[] invalidIps = { new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str") };
    for (BytesRef ip : invalidIps) {
        assertEquals(false, IpType.isValid(ip));
    }
}

Output:
     }
-    BytesRef[] invalidIps = { new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str") };
+    BytesRef[] invalidIps = { new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str"), new BytesRef("String_Node_Str") };
     for (BytesRef ip : invalidIps) {


Input:
protected boolean initializeCamera(int width, int height) {
    Log.d(TAG, "String_Node_Str");
    boolean result = true;
    synchronized (this) {
        mCamera = null;
        if (mCameraIndex == CAMERA_ID_ANY) {
            Log.d(TAG, "String_Node_Str");
            try {
                mCamera = Camera.open();
            } catch (Exception e) {
                Log.e(TAG, "String_Node_Str" + e.getLocalizedMessage());
            }
            if (mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
                boolean connected = false;
                for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                    Log.d(TAG, "String_Node_Str" + Integer.valueOf(camIdx) + "String_Node_Str");
                    try {
                        mCamera = Camera.open(camIdx);
                        connected = true;
                    } catch (RuntimeException e) {
                        Log.e(TAG, "String_Node_Str" + camIdx + "String_Node_Str" + e.getLocalizedMessage());
                    }
                    if (connected)
                        break;
                }
            }
        } else {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
                int localCameraIndex = mCameraIndex;
                if (mCameraIndex == CAMERA_ID_BACK) {
                    Log.i(TAG, "String_Node_Str");
                    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
                    for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                        Camera.getCameraInfo(camIdx, cameraInfo);
                        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                            localCameraIndex = camIdx;
                            break;
                        }
                    }
                } else if (mCameraIndex == CAMERA_ID_FRONT) {
                    Log.i(TAG, "String_Node_Str");
                    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
                    for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                        Camera.getCameraInfo(camIdx, cameraInfo);
                        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                            localCameraIndex = camIdx;
                            break;
                        }
                    }
                }
                if (localCameraIndex == CAMERA_ID_BACK) {
                    Log.e(TAG, "String_Node_Str");
                } else if (localCameraIndex == CAMERA_ID_FRONT) {
                    Log.e(TAG, "String_Node_Str");
                } else {
                    Log.d(TAG, "String_Node_Str" + Integer.valueOf(localCameraIndex) + "String_Node_Str");
                    try {
                        mCamera = Camera.open(localCameraIndex);
                    } catch (RuntimeException e) {
                        Log.e(TAG, "String_Node_Str" + localCameraIndex + "String_Node_Str" + e.getLocalizedMessage());
                    }
                }
            }
        }
        if (mCamera == null)
            return false;
        try {
            Camera.Parameters params = mCamera.getParameters();
            Log.d(TAG, "String_Node_Str");
            List<android.hardware.Camera.Size> sizes = params.getSupportedPreviewSizes();
            if (sizes != null) {
                Size frameSize = calculateCameraFrameSize(sizes, new MagicCameraView.JavaCameraSizeAccessor(), width, height);
                params.setPreviewFormat(ImageFormat.NV21);
                Log.d(TAG, "String_Node_Str" + Integer.valueOf((int) frameSize.width) + "String_Node_Str" + Integer.valueOf((int) frameSize.height));
                params.setPreviewSize((int) frameSize.width, (int) frameSize.height);
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH && !android.os.Build.MODEL.equals("String_Node_Str"))
                    params.setRecordingHint(true);
                List<String> FocusModes = params.getSupportedFocusModes();
                if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
                    params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                }
                setPreviewFPS(30000, 30000);
                mCamera.setParameters(params);
                params = mCamera.getParameters();
                mFrameWidth = params.getPreviewSize().width;
                mFrameHeight = params.getPreviewSize().height;
                if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT))
                    mScale = Math.min(((float) height) / mFrameHeight, ((float) width) / mFrameWidth);
                else
                    mScale = 0;
                if (mFpsMeter != null) {
                    mFpsMeter.setResolution(mFrameWidth, mFrameHeight);
                }
                int size = mFrameWidth * mFrameHeight;
                size = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
                mBuffer = new byte[size];
                mCamera.addCallbackBuffer(mBuffer);
                mCamera.setPreviewCallbackWithBuffer(this);
                mFrameChain = new Mat[2];
                mFrameChain[0] = new Mat(mFrameHeight + (mFrameHeight / 2), mFrameWidth, CvType.CV_8UC1);
                mFrameChain[1] = new Mat(mFrameHeight + (mFrameHeight / 2), mFrameWidth, CvType.CV_8UC1);
                AllocateCache();
                mCameraFrame = new MagicCameraView.JavaCameraFrame[2];
                mCameraFrame[0] = new MagicCameraView.JavaCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight);
                mCameraFrame[1] = new MagicCameraView.JavaCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight);
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                    mSurfaceTexture = new SurfaceTexture(MAGIC_TEXTURE_ID);
                    mCamera.setPreviewTexture(mSurfaceTexture);
                } else
                    mCamera.setPreviewDisplay(null);
                Log.d(TAG, "String_Node_Str");
                mCamera.startPreview();
            } else
                result = false;
        } catch (Exception e) {
            result = false;
            e.printStackTrace();
        }
    }
    return result;
}

Output:
                 AllocateCache();
-                mCameraFrame = new MagicCameraView.JavaCameraFrame[2];
-                mCameraFrame[0] = new MagicCameraView.JavaCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight);
-                mCameraFrame[1] = new MagicCameraView.JavaCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight);
+                mCameraFrame = new MagicCameraView.MagicCameraFrame[2];
+                mCameraFrame[0] = new MagicCameraView.MagicCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight);
+                mCameraFrame[1] = new MagicCameraView.MagicCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight);
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {


Input:
private void parseObjectInto(ParseContext cx, JSONTokenizer tokenizer) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    boolean containerIsMap = Map.class.isAssignableFrom(cx.target.getClass());
    boolean containerIsDynAttrs = cx.target instanceof DynamicProperties;
    boolean first = true;
    while (true) {
        Token key;
        if (first) {
            key = tokenizer.expectNext(TokenType.STRING, TokenType.BRACE_CLOSE);
        } else {
            key = tokenizer.expectNext(TokenType.COMMA, TokenType.BRACE_CLOSE);
        }
        if (key.type() == TokenType.BRACE_CLOSE) {
            break;
        }
        if (!first) {
            key = tokenizer.expectNext(TokenType.STRING);
        }
        String jsonName = (String) key.value();
        if (jsonName.length() == 0) {
            throw new JSONParseException("String_Node_Str");
        }
        String name = null;
        tokenizer.expectNext(TokenType.COLON);
        Token valueToken = tokenizer.next();
        TokenType valueType = valueToken.type();
        boolean isProperty = false;
        boolean isIgnoredOnParse = false;
        JSONClassInfo classInfo = null;
        JSONPropertyInfo propertyInfo = null;
        if (!containerIsMap) {
            classInfo = TypeAnalyzer.getClassInfo(objectSupport, cx.target.getClass());
            propertyInfo = classInfo.getPropertyInfo(jsonName);
            if (propertyInfo != null) {
                name = propertyInfo.getJavaPropertyName();
            }
            isProperty = false;
            isIgnoredOnParse = false;
            if (name != null) {
                boolean writeable = propertyInfo.isWriteable();
                isIgnoredOnParse = (!writeable && propertyInfo.isReadOnly());
                if (propertyInfo.isLinkedProperty()) {
                    isIgnoredOnParse = true;
                }
                isProperty = writeable || isIgnoredOnParse;
            }
        }
        TypeConverter typeConverter = propertyInfo == null ? null : propertyInfo.getTypeConverter();
        if (!(isProperty || containerIsMap || containerIsDynAttrs || (propertyInfo != null && propertyInfo.canAdd()))) {
            throw new JSONParseException("String_Node_Str" + jsonName + "String_Node_Str" + cx.target.getClass());
        }
        if (name == null) {
            name = jsonName;
        }
        Class typeHint = getTypeHint(cx, cx.getParsePathInfo(jsonName), tokenizer, name, isProperty, valueType.isPrimitive());
        Object value;
        if (valueType.isPrimitive()) {
            value = valueToken.value();
        } else {
            Object newTarget = null;
            if (valueType == TokenType.BRACE_OPEN) {
                Class memberType = null;
                if (isProperty) {
                    JSONPropertyInfo propertyInfo2 = TypeAnalyzer.getClassInfo(objectSupport, cx.target.getClass()).getPropertyInfo(name);
                    if (propertyInfo2 != null) {
                        memberType = propertyInfo2.getTypeHint();
                    }
                }
                newTarget = createNewTargetInstance(typeHint, true);
                parseObjectInto(cx.push(newTarget, memberType, "String_Node_Str" + name), tokenizer);
            } else if (valueType == TokenType.BRACKET_OPEN) {
                if (isProperty || containerIsMap || containerIsDynAttrs) {
                    Class arrayTypeHint = typeHint;
                    if (isProperty) {
                        if (typeConverter != null && !List.class.isAssignableFrom(arrayTypeHint)) {
                            arrayTypeHint = List.class;
                        }
                    }
                    newTarget = createNewTargetInstance(arrayTypeHint, false);
                    JSONPropertyInfo propertyInfo2 = TypeAnalyzer.getClassInfo(objectSupport, cx.target.getClass()).getPropertyInfo(name);
                    Class memberType = null;
                    if (propertyInfo2 != null) {
                        memberType = propertyInfo2.getTypeHint();
                    }
                    parseArrayInto(cx.push(newTarget, memberType, "String_Node_Str" + name), tokenizer);
                } else {
                    if (propertyInfo.canAdd()) {
                        List temp = new ArrayList();
                        parseArrayInto(cx.push(temp, propertyInfo.getAdderType(), "String_Node_Str" + name), tokenizer);
                        for (Object o : temp) {
                            propertyInfo.add(cx.target, o);
                        }
                        continue;
                    } else {
                        throw new JSONParseException("String_Node_Str" + name + "String_Node_Str" + cx.target);
                    }
                }
            } else {
                throw new JSONParseException("String_Node_Str" + valueToken);
            }
            value = newTarget;
        }
        if (typeConverter != null && !isIgnoredOnParse) {
            value = typeConverter.fromJSON(value);
        }
        if (typeHint == null && propertyInfo != null) {
            typeHint = propertyInfo.getTypeOfProperty();
        }
        if (typeHint != null && !isIgnoredOnParse) {
            value = convertValueTo(value, typeHint);
        }
        if (isProperty) {
            if (!isIgnoredOnParse) {
                propertyInfo.setProperty(cx.target, value);
            }
        } else if (containerIsMap) {
            ((Map) cx.target).put(name, value);
        } else if (containerIsDynAttrs) {
            ((DynamicProperties) cx.target).setProperty(name, value);
        } else {
            throw new JSONParseException("String_Node_Str" + name + "String_Node_Str" + cx.target);
        }
        first = false;
    }
}

Output:
         }
-        Class typeHint = getTypeHint(cx, cx.getParsePathInfo(jsonName), tokenizer, name, isProperty, valueType.isPrimitive());
+        Class typeHint = getTypeHint(cx, cx.getParsePathInfo(jsonName), tokenizer, jsonName, isProperty, valueType.isPrimitive());
         Object value;


Input:
private void _deleteFolder(File folder) throws Exception {
    String[] childs = null;
    childs = folder.list();
    if (childs == null || childs.length <= 0) {
        folder.delete();
    }
    for (int i = 0; i < childs.length; i++) {
        String childName = childs[i];
        String childPath = folder.getPath() + File.separator + childName;
        File filePath = new File(childPath);
        if (filePath.exists() && filePath.isFile()) {
            filePath.delete();
        } else if (filePath.exists() && filePath.isDirectory()) {
            _deleteFolder(filePath);
        }
    }
    folder.delete();
}

Output:
     if (childs == null || childs.length <= 0) {
-        folder.delete();
-    }
-    for (int i = 0; i < childs.length; i++) {
-        String childName = childs[i];
-        String childPath = folder.getPath() + File.separator + childName;
-        File filePath = new File(childPath);
-        if (filePath.exists() && filePath.isFile()) {
-            filePath.delete();
-        } else if (filePath.exists() && filePath.isDirectory()) {
-            _deleteFolder(filePath);
+        boolean isDeleted = folder.delete();
+    } else {
+        for (int i = 0; i < childs.length; i++) {
+            String childName = childs[i];
+            String childPath = folder.getPath() + File.separator + childName;
+            File filePath = new File(childPath);
+            if (filePath.exists() && filePath.isFile()) {
+                filePath.delete();
+            } else if (filePath.exists() && filePath.isDirectory()) {
+                _deleteFolder(filePath);
+            }
         }


Input:
public void readExternal(DataInputStream in, PrototypeFactory pf) throws IOException, DeserializationException {
    expr = (IConditionExpr) ExtUtil.read(in, new ExtWrapTagged(), pf);
    contextRef = (TreeReference) ExtUtil.read(in, TreeReference.class, pf);
    targets = (Vector) ExtUtil.read(in, new ExtWrapList(TreeReference.class), pf);
}

Output:
     contextRef = (TreeReference) ExtUtil.read(in, TreeReference.class, pf);
-    targets = (Vector) ExtUtil.read(in, new ExtWrapList(TreeReference.class), pf);
+    originalContextRef = (TreeReference) ExtUtil.read(in, TreeReference.class, pf);
+    targets = (Vector<TreeReference>) ExtUtil.read(in, new ExtWrapList(TreeReference.class), pf);
 }


Input:
public int getSignatureMatch(String name, IValue instance, IArguments arguments) {
    if (name == null) {
        return 1;
    }
    if (!name.equals(this.qualifiedName)) {
        return 0;
    }
    if (arguments == null) {
        return 1;
    }
    int pOff = 0;
    int match = 1;
    int len = arguments.size();
    int mods = this.modifiers & Modifiers.INFIX;
    if (instance != null && mods == Modifiers.INFIX) {
        if (len != this.parameterCount - 1) {
            return 0;
        }
        IType t2 = this.parameters[0].type;
        int m = instance.getTypeMatch(t2);
        if (m == 0) {
            return 0;
        }
        match += m;
        pOff = 1;
    } else if (mods == Modifiers.STATIC && instance != null && instance.getValueType() != IValue.CLASS_ACCESS) {
        return 0;
    } else if ((this.modifiers & Modifiers.VARARGS) != 0) {
        int parCount = this.parameterCount - 1;
        if (len <= parCount) {
            return 0;
        }
        int m;
        Parameter varParam = this.parameters[parCount];
        varParam.index = parCount;
        for (int i = 0; i < parCount; i++) {
            Parameter par = this.parameters[i + pOff];
            par.index = i + pOff;
            m = arguments.getTypeMatch(par);
            if (m == 0) {
                return 0;
            }
            match += m;
        }
        for (int i = parCount; i < len; i++) {
            m = arguments.getVarargsTypeMatch(varParam);
            if (m == 0) {
                return 0;
            }
            match += m;
        }
        return match;
    } else if (len > this.parameterCount) {
        return 0;
    }
    for (int i = 0; i < this.parameterCount; i++) {
        Parameter par = this.parameters[i + pOff];
        par.index = i;
        int m = arguments.getTypeMatch(par);
        if (m == 0) {
            return 0;
        }
        match += m;
    }
    return match;
}

Output:
 public int getSignatureMatch(String name, IValue instance, IArguments arguments) {
-    if (name == null) {
-        return 1;
-    }
-    if (!name.equals(this.qualifiedName)) {
+    if (name != null && !name.equals(this.qualifiedName)) {
         return 0;


Input:
public int hashCode() {
    return type.hashCode() + 37 * Arrays.hashCode(properties);
}

Output:
 public int hashCode() {
-    return type.hashCode() + 37 * Arrays.hashCode(properties);
+    int code = 1;
+    if (properties != null) {
+        if (properties instanceof Property[]) {
+            for (final Property p : (Property[]) properties) {
+                code = 31 * code;
+                final Object value;
+                if (p instanceof AbstractAttribute<?>) {
+                    value = getAttributeValue((AbstractAttribute<?>) p);
+                } else if (p instanceof AbstractAssociation) {
+                    value = getAssociationValue((AbstractAssociation) p);
+                } else {
+                    continue;
+                }
+                if (value != null) {
+                    code += value.hashCode();
+                }
+            }
+        } else {
+            code = Arrays.hashCode(properties);
+        }
+    }
+    return type.hashCode() + code;
 }


Input:
private String getCompletedSingleSelect(Indicator indicator, String sqlGenericExpression, String colName, String table, List<String> whereExpression, String range) throws ParseException {
    String completedRange = replaceVariables(range, colName, table);
    String rangeColumn = "String_Node_Str" + completedRange + "String_Node_Str";
    String completedSqlString = replaceVariables(sqlGenericExpression, rangeColumn, table);
    List<String> allWheresForSingleSelect = new ArrayList<String>(whereExpression);
    allWheresForSingleSelect.add(completedRange);
    return addWhereToSqlStringStatement(allWheresForSingleSelect, completedSqlString);
}

Output:
     String rangeColumn = "String_Node_Str" + completedRange + "String_Node_Str";
-    String completedSqlString = replaceVariables(sqlGenericExpression, rangeColumn, table);
+    String completedSqlString = replaceVariablesLow(sqlGenericExpression, rangeColumn, table, rangeColumn);
     List<String> allWheresForSingleSelect = new ArrayList<String>(whereExpression);


Input:
private static Document buildDocument(int type, int id, String uri, String location) {
    Document doc = new Document();
    doc.add(new Field(LAST_INDEXED_FIELD, Long.toString(System.currentTimeMillis()), Field.Store.YES, Field.Index.UN_TOKENIZED));
    doc.add(new Field("String_Node_Str", Integer.toString(type), Field.Store.YES, Field.Index.NO));
    doc.add(new Field("String_Node_Str", Integer.toString(type), Field.Store.YES, Field.Index.NO));
    doc.add(new Field("String_Node_Str", Integer.toString(id), Field.Store.YES, Field.Index.NO));
    if (uri != null) {
        doc.add(new Field("String_Node_Str", uri, Field.Store.YES, Field.Index.TOKENIZED));
        doc.add(new Field("String_Node_Str", uri, Field.Store.YES, Field.Index.UN_TOKENIZED));
        doc.add(new Field("String_Node_Str", uri, Field.Store.NO, Field.Index.TOKENIZED));
    }
    if (location != null) {
        doc.add(new Field("String_Node_Str", location, Field.Store.NO, Field.Index.TOKENIZED));
        doc.add(new Field("String_Node_Str", location, Field.Store.NO, Field.Index.TOKENIZED));
    }
    return doc;
}

Output:
     doc.add(new Field("String_Node_Str", Integer.toString(type), Field.Store.YES, Field.Index.NO));
-    doc.add(new Field("String_Node_Str", Integer.toString(type), Field.Store.YES, Field.Index.NO));
+    doc.add(new Field("String_Node_Str", Integer.toString(type), Field.Store.YES, Field.Index.UN_TOKENIZED));
     doc.add(new Field("String_Node_Str", Integer.toString(id), Field.Store.YES, Field.Index.NO));


Input:
protected boolean respondToJoinRequest(String playerID) {
    if (getDataModel().getMemberList().isEmpty())
        return true;
    if (getDataModel().getMemberList().size() == 1)
        return true;
    double heuristic = 0;
    double vectorDistance;
    double maxDistance = Math.sqrt(2);
    double economic, social, esFaction = 0;
    double trustFaction = 0, trustSum = 0;
    int numKnownTrustValues = 0;
    for (String trustor : this.getDataModel().getMemberList()) {
        Double trustValue = this.getConn().getAgentById(trustor).getTrust(playerID);
        if (trustValue != null) {
            trustSum += trustValue;
            numKnownTrustValues++;
        }
    }
    if (numKnownTrustValues != 0) {
        trustFaction = trustSum / numKnownTrustValues;
    }
    economic = this.getConn().getAgentById(playerID).getEconomicBelief() - this.getDataModel().getCurrentEconomicPoisition();
    social = this.getConn().getAgentById(playerID).getSocialBelief() - this.getDataModel().getEstimatedSocialLocation();
    vectorDistance = Math.sqrt(Math.pow(economic, 2) + Math.pow(social, 2));
    esFaction = 1 - (vectorDistance / maxDistance);
    heuristic = 0.5 * trustFaction + 0.5 * esFaction;
    if (heuristic > 0.5) {
        return true;
    } else {
        return false;
    }
}

Output:
 protected boolean respondToJoinRequest(String playerID) {
-    if (getDataModel().getMemberList().isEmpty())
-        return true;
-    if (getDataModel().getMemberList().size() == 1)
-        return true;
-    double heuristic = 0;
-    double vectorDistance;
-    double maxDistance = Math.sqrt(2);
-    double economic, social, esFaction = 0;
-    double trustFaction = 0, trustSum = 0;
-    int numKnownTrustValues = 0;
-    for (String trustor : this.getDataModel().getMemberList()) {
-        Double trustValue = this.getConn().getAgentById(trustor).getTrust(playerID);
-        if (trustValue != null) {
-            trustSum += trustValue;
-            numKnownTrustValues++;
-        }
-    }
-    if (numKnownTrustValues != 0) {
-        trustFaction = trustSum / numKnownTrustValues;
-    }
-    economic = this.getConn().getAgentById(playerID).getEconomicBelief() - this.getDataModel().getCurrentEconomicPoisition();
-    social = this.getConn().getAgentById(playerID).getSocialBelief() - this.getDataModel().getEstimatedSocialLocation();
-    vectorDistance = Math.sqrt(Math.pow(economic, 2) + Math.pow(social, 2));
-    esFaction = 1 - (vectorDistance / maxDistance);
-    heuristic = 0.5 * trustFaction + 0.5 * esFaction;
-    if (heuristic > 0.5) {
-        return true;
-    } else {
-        return false;
-    }
+    return true;
 }


Input:
public Iterator<T> iterator() {
    return (numberToSkip >= list.size()) ? Iterators.<T>emptyIterator() : list.subList(numberToSkip, list.size()).iterator();
}

Output:
 public Iterator<T> iterator() {
-    return (numberToSkip >= list.size()) ? Iterators.<T>emptyIterator() : list.subList(numberToSkip, list.size()).iterator();
+    int toSkip = Math.min(list.size(), numberToSkip);
+    return list.subList(toSkip, list.size()).iterator();
 }


Input:
private List<Map<String, String>> fetchEvents() {
    GreenhouseOperations greenhouse = Prefs.getGreenhouseTemplate(getSharedPreferences(Prefs.PREFS, Context.MODE_PRIVATE));
    List<Event> upcomingEvents = greenhouse.getUpcomingEvents();
    List<Map<String, String>> eventList = new ArrayList<Map<String, String>>();
    for (Event event : upcomingEvents) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("String_Node_Str", event.getTitle());
        map.put("String_Node_Str", event.getGroupName());
        eventList.add(map);
    }
    return eventList;
}

Output:
 private List<Map<String, String>> fetchEvents() {
-    GreenhouseOperations greenhouse = Prefs.getGreenhouseTemplate(getSharedPreferences(Prefs.PREFS, Context.MODE_PRIVATE));
+    GreenhouseOperations greenhouse = Prefs.getGreenhouseOperations(getSharedPreferences(Prefs.PREFS, Context.MODE_PRIVATE));
     List<Event> upcomingEvents = greenhouse.getUpcomingEvents();


Input:
public void mouseEntered(MouseEvent e) {
    latestMousePositionX = e.getX();
    currentMousePositionX = latestMousePositionX;
    mouseInside = true;
}

Output:
 public void mouseEntered(MouseEvent e) {
-    latestMousePositionX = e.getX();
-    currentMousePositionX = latestMousePositionX;
+    if (currentState == TimelineState.IDLE) {
+        latestMousePositionX = e.getX();
+        currentMousePositionX = latestMousePositionX;
+    }
     mouseInside = true;


Input:
protected void saveReloadResult() {
    DqRepositoryViewService.saveOpenDataProvider(this.oldDataProvider);
}

Output:
 protected void saveReloadResult() {
-    DqRepositoryViewService.saveOpenDataProvider(this.oldDataProvider);
+    PrvResourceFileHelper.getInstance().save(oldDataProvider);
 }


Input:
public IStatus handleDrop(CommonDropAdapter aDropAdapter, DropTargetEvent aDropTargetEvent, Object target) {
    if (aDropAdapter.getCurrentTarget() == null || aDropTargetEvent.data == null) {
        return Status.CANCEL_STATUS;
    }
    IResource[] resources = null;
    TransferData currentTransfer = aDropAdapter.getCurrentTransfer();
    if (LocalSelectionTransfer.getTransfer().isSupportedType(currentTransfer)) {
        resources = getSelectedResources();
    } else if (ResourceTransfer.getInstance().isSupportedType(currentTransfer)) {
        resources = (IResource[]) aDropTargetEvent.data;
    }
    if ((target instanceof IFile)) {
        TdReport findReport = RepResourceFileHelper.getInstance().findReport(((IFile) target));
        if (resources != null && resources.length > 0) {
            List<Analysis> anaList = new ArrayList<Analysis>();
            for (IResource res : resources) {
                Analysis findAnalysis = AnaResourceFileHelper.getInstance().findAnalysis((IFile) res);
                if (findAnalysis != null) {
                    anaList.add(findAnalysis);
                }
            }
            ReportHelper.addAnalyses(anaList, findReport);
            RepResourceFileHelper.getInstance().save(findReport);
        }
    } else if ((target instanceof IFolder)) {
        IFolder folder = (IFolder) target;
        for (IResource res : resources) {
            if (res.getType() != IResource.FILE) {
                return null;
            }
            String name = res.getName();
            IFile fileRes = (IFile) res;
            IFile movedIFile = folder.getFile(name);
            List<ModelElement> oldDependencySuppliers = EObjectHelper.getDependencySuppliers(fileRes);
            EObjectHelper.removeDependencys(new IResource[] { fileRes });
            IContainer srcParent = fileRes.getParent();
            URI srcUri = URI.createPlatformResourceURI((fileRes).getFullPath().toString(), false);
            ResourceSet rs = EMFSharedResources.getSharedEmfUtil().getResourceSet();
            Resource resource = rs.getResource(srcUri, true);
            if (resource != null) {
                URI desUri = URI.createPlatformResourceURI(folder.getFullPath().toString(), false);
                EMFUtil.changeUri(resource, desUri);
            }
            try {
                fileRes.move(movedIFile.getFullPath(), true, null);
                srcParent.refreshLocal(IResource.DEPTH_INFINITE, null);
                folder.refreshLocal(IResource.DEPTH_INFINITE, null);
            } catch (CoreException e) {
                ExceptionHandler.process(e);
            }
            EObjectHelper.addDependenciesForFile(movedIFile, oldDependencySuppliers);
            for (ModelElement element : oldDependencySuppliers) {
                EMFSharedResources.getSharedEmfUtil().saveSingleResource(element.eResource());
            }
        }
    }
    ((DQRespositoryView) CorePlugin.getDefault().findView(DQRespositoryView.ID)).getCommonViewer().refresh();
    return null;
}

Output:
             try {
-                fileRes.move(movedIFile.getFullPath(), true, null);
+                fileRes.delete(true, null);
                 srcParent.refreshLocal(IResource.DEPTH_INFINITE, null);


Input:
protected HashMutableDirectedGraph getInvokeInfoFlowSummary(InvokeExpr ie, Stmt is, SootMethod context) {
    HashMutableDirectedGraph ret = null;
    SootMethodRef methodRef = ie.getMethodRef();
    String subSig = methodRef.resolve().getSubSignature();
    CallGraph cg = Scene.v().getCallGraph();
    for (Iterator<Edge> edges = cg.edgesOutOf(is); edges.hasNext(); ) {
        Edge e = edges.next();
        SootMethod target = e.getTgt().method();
        if (target.getSubSignature().equals(subSig)) {
            HashMutableDirectedGraph ifs = getMethodInfoFlowSummary(target, context.getDeclaringClass().isApplicationClass());
            if (ret == null)
                ret = ifs;
            else {
                for (Object node : ifs.getNodes()) {
                    if (!ret.containsNode(node))
                        ret.addNode(node);
                    for (Object succ : ifs.getSuccsOf(node)) ret.addEdge(node, succ);
                }
            }
        }
    }
    return ret;
}

Output:
         if (target.getSubSignature().equals(subSig)) {
-            HashMutableDirectedGraph ifs = getMethodInfoFlowSummary(target, context.getDeclaringClass().isApplicationClass());
+            HashMutableDirectedGraph<EquivalentValue> ifs = getMethodInfoFlowSummary(target, context.getDeclaringClass().isApplicationClass());
             if (ret == null)


Input:
public Volume apply(final String input) {
    try {
        Volume vol = null;
        try {
            vol = Entities.uniqueResult(Volume.named(ctx.getUserFullName().asAccountFullName(), input));
        } catch (NoSuchElementException e) {
            try {
                vol = Entities.uniqueResult(Volume.named(null, input));
            } catch (NoSuchElementException e2) {
                throw Exceptions.toUndeclared(new ClientComputeException("String_Node_Str", "String_Node_Str" + input + "String_Node_Str"));
            }
        }
        if (!RestrictedTypes.filterPrivileged().apply(vol)) {
            throw Exceptions.toUndeclared("String_Node_Str" + ctx.getUser().getName());
        }
        try {
            VmVolumeAttachment attachment = VmInstances.lookupVolumeAttachment(input);
            throw new IllegalStateException("String_Node_Str" + attachment);
        } catch (NoSuchElementException ex) {
        }
        if (State.FAIL.equals(vol.getState()) || State.ANNIHILATED.equals(vol.getState())) {
            Entities.delete(vol);
            return vol;
        } else {
            try {
                ServiceConfiguration sc = Topology.lookup(Storage.class, Partitions.lookupByName(vol.getPartition()));
                DeleteStorageVolumeResponseType scReply = AsyncRequests.sendSync(sc, new DeleteStorageVolumeType(vol.getDisplayName()));
                if (scReply.get_return()) {
                    Volumes.annihilateStorageVolume(vol);
                    return vol;
                } else {
                    throw Exceptions.toUndeclared("String_Node_Str");
                }
            } catch (Exception ex) {
                throw Exceptions.toUndeclared("String_Node_Str" + ex.getMessage(), ex);
            }
        }
    } catch (NoSuchElementException ex) {
        throw ex;
    } catch (TransactionException ex) {
        throw Exceptions.toUndeclared("String_Node_Str", ex);
    }
}

Output:
             VmVolumeAttachment attachment = VmInstances.lookupVolumeAttachment(input);
-            throw new IllegalStateException("String_Node_Str" + attachment);
+            throw Exceptions.toUndeclared(new ClientComputeException("String_Node_Str", "String_Node_Str" + attachment.getVmInstance().getDisplayName()));
         } catch (NoSuchElementException ex) {


Input:
private static void handlePossibleRecursiveExit(String called, int depth, String message) {
    int nProcessors = VM_Scheduler.numProcessors;
    int nProcessorAdjust = nProcessors - 1;
    if (depth > 1 && (depth <= maxSystemTroubleRecursionDepth + nProcessorAdjust + VM.maxSystemTroubleRecursionDepthBeforeWeStopVMSysWrite)) {
        ptsysWriteln("String_Node_Str", called, "String_Node_Str", depth > nProcessors ? "String_Node_Str" : "String_Node_Str", "String_Node_Str", called, "String_Node_Str", depth, "String_Node_Str", message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : called, message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : message);
    }
    if (depth > maxSystemTroubleRecursionDepth + nProcessorAdjust) {
        dieAbruptlyRecursiveSystemTrouble();
        if (VM.VerifyAssertions)
            VM._assert(VM.NOT_REACHED);
    }
}

Output:
     if (depth > 1 && (depth <= maxSystemTroubleRecursionDepth + nProcessorAdjust + VM.maxSystemTroubleRecursionDepthBeforeWeStopVMSysWrite)) {
-        ptsysWriteln("String_Node_Str", called, "String_Node_Str", depth > nProcessors ? "String_Node_Str" : "String_Node_Str", "String_Node_Str", called, "String_Node_Str", depth, "String_Node_Str", message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : called, message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : message);
+        if (showNumber) {
+            ptsysWriteln("String_Node_Str", called, "String_Node_Str", depth > nProcessors ? "String_Node_Str" : "String_Node_Str", "String_Node_Str", called, "String_Node_Str", depth, "String_Node_Str", message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : called, message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : message, number);
+        } else {
+            ptsysWriteln("String_Node_Str", called, "String_Node_Str", depth > nProcessors ? "String_Node_Str" : "String_Node_Str", "String_Node_Str", called, "String_Node_Str", depth, "String_Node_Str", message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : called, message == null ? "String_Node_Str" : "String_Node_Str", message == null ? "String_Node_Str" : message);
+        }
     }


Input:
public int force(String uri, String prefix) {
    for (int i = (size - 1); i >= 0; i--) {
        if ((nsUris[i].compareTo(uri) == 0) && (!prefixes[i].equals("String_Node_Str")))
            return i;
    }
    for (int i = size - 1; i >= 0; i--) {
        if (prefixes[i].equals(prefix)) {
            if (nsUris[i].equals(uri))
                return i;
            else
                break;
        }
    }
    return put(uri, prefix);
}

Output:
     for (int i = (size - 1); i >= 0; i--) {
-        if ((nsUris[i].compareTo(uri) == 0) && (!prefixes[i].equals("String_Node_Str")))
+        if (nsUris[i].compareTo(uri) == 0) {
+            prefixes[i] = prefix;
             return i;


Input:
private void saveGraph(EntitySaveGraph objectGraph) {
    Object parentEntity = objectGraph.getParentEntity();
    EntityMetadata metadata = getMetadata(objectGraph.getParentClass());
    if (parentEntity != null) {
        objectGraph.setParentId(getId(parentEntity, metadata));
        if (getSession().lookup(parentEntity.getClass(), objectGraph.getParentId()) == null) {
            Client pClient = getClient(metadata);
            pClient.persist(objectGraph, metadata);
            session.store(objectGraph.getParentId(), objectGraph.getParentEntity());
        }
    }
    Object childEntity = objectGraph.getChildEntity();
    if (childEntity != null) {
        persistChildEntity(objectGraph, childEntity);
    }
    for (Relation relation : metadata.getRelations()) {
        if (relation.isRelatedViaJoinTable()) {
            JoinTableMetadata jtMetadata = relation.getJoinTableMetadata();
            String joinTableName = jtMetadata.getJoinTableName();
            Set<String> joinColumns = jtMetadata.getJoinColumns();
            Set<String> inverseJoinColumns = jtMetadata.getInverseJoinColumns();
            String joinColumnName = (String) joinColumns.toArray()[0];
            String inverseJoinColumnName = (String) inverseJoinColumns.toArray()[0];
            EntityMetadata relMetadata = getMetadata(objectGraph.getChildClass());
            Client pClient = getClient(metadata);
            pClient.persistJoinTable(joinTableName, joinColumnName, inverseJoinColumnName, relMetadata, objectGraph);
        }
    }
}

Output:
         objectGraph.setParentId(getId(parentEntity, metadata));
-        if (getSession().lookup(parentEntity.getClass(), objectGraph.getParentId()) == null) {
-            Client pClient = getClient(metadata);
-            pClient.persist(objectGraph, metadata);
-            session.store(objectGraph.getParentId(), objectGraph.getParentEntity());
-        }
+        Client pClient = getClient(metadata);
+        pClient.persist(objectGraph, metadata);
+        session.store(objectGraph.getParentId(), objectGraph.getParentEntity());
     }


Input:
public IReportEventHandler createEventHandler(String itemType) {
    IConfigurationElement config = (IConfigurationElement) queryExtensions.get(itemType);
    if (config != null) {
        Object object = createObject(config, "String_Node_Str");
        if (object instanceof IReportItemQuery) {
            return (IReportEventHandler) object;
        }
    }
    return null;
}

Output:
         Object object = createObject(config, "String_Node_Str");
-        if (object instanceof IReportItemQuery) {
+        if (object instanceof IReportEventHandler) {
             return (IReportEventHandler) object;


Input:
public void onDecreaseViewDistance(DecreaseViewDistanceButton button, EntityRef entity) {
    int viewDistance = config.getRendering().getViewDistance().getIndex();
    int minViewDistance = 0;
    if (viewDistance != minViewDistance) {
        changeViewDistanceTo(ViewDistance.forIndex((config.getRendering().getViewDistance().getIndex() - 1)));
    }
    button.consume();
}

Output:
     if (viewDistance != minViewDistance) {
-        changeViewDistanceTo(ViewDistance.forIndex((config.getRendering().getViewDistance().getIndex() - 1)));
+        config.getRendering().setViewDistance(ViewDistance.forIndex((viewDistance - 1)));
     }


Input:
public void setXmlUnmarshaller(XMLUnmarshaller xmlUnmarshaller) {
    getSDOXMLHelperDelegate().setXmlUnmarshaller(xmlUnmarshaller);
}

Output:
 public void setXmlUnmarshaller(XMLUnmarshaller xmlUnmarshaller) {
-    getSDOXMLHelperDelegate().setXmlUnmarshaller(xmlUnmarshaller);
+    getXMLHelperDelegate().setXmlUnmarshaller(xmlUnmarshaller);
 }


Input:
private TextView setupFontIconView() {
    if (mFontIcon != null) {
        TextView fontIconView = new TextView(mContext);
        fontIconView.setTextColor(mDefaultIconColor);
        LayoutParams iconTextViewParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT, 1f);
        iconTextViewParams.rightMargin = mIconPaddingRight;
        iconTextViewParams.leftMargin = mIconPaddingLeft;
        iconTextViewParams.topMargin = mIconPaddingTop;
        iconTextViewParams.bottomMargin = mIconPaddingBottom;
        if (mTextView != null) {
            if (mIconPosition == POSITION_TOP || mIconPosition == POSITION_BOTTOM) {
                iconTextViewParams.gravity = Gravity.CENTER;
                fontIconView.setGravity(Gravity.CENTER);
            } else {
                fontIconView.setGravity(Gravity.CENTER_VERTICAL);
                iconTextViewParams.gravity = Gravity.CENTER_VERTICAL;
            }
        } else {
            iconTextViewParams.gravity = Gravity.CENTER;
            fontIconView.setGravity(Gravity.CENTER_VERTICAL);
        }
        fontIconView.setLayoutParams(iconTextViewParams);
        if (!isInEditMode()) {
            fontIconView.setTextSize(mFontIconSize);
            fontIconView.setText(mFontIcon);
            fontIconView.setTypeface(mIconTypeFace);
        } else {
            fontIconView.setText("String_Node_Str");
        }
        return fontIconView;
    }
    return null;
}

Output:
         fontIconView.setTextColor(mDefaultIconColor);
-        LayoutParams iconTextViewParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT, 1f);
+        LayoutParams iconTextViewParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
         iconTextViewParams.rightMargin = mIconPaddingRight;


Input:
private void performTeleport(PlayerMoveEvent event, PortalPlayerSession ps, MVDestination d) {
    SafeTTeleporter playerTeleporter = new SafeTTeleporter(this.plugin.getCore());
    TeleportResult result = playerTeleporter.safelyTeleport(event.getPlayer(), event.getPlayer(), d);
    if (result == TeleportResult.SUCCESS) {
        ps.playerDidTeleport(event.getTo());
        ps.setTeleportTime(new Date());
    }
}

Output:
 private void performTeleport(PlayerMoveEvent event, PortalPlayerSession ps, MVDestination d) {
-    SafeTTeleporter playerTeleporter = new SafeTTeleporter(this.plugin.getCore());
+    SafeTTeleporter playerTeleporter = this.plugin.getCore().getSafeTTeleporter();
     TeleportResult result = playerTeleporter.safelyTeleport(event.getPlayer(), event.getPlayer(), d);