Input:
private static void constructScheme() {
    Queue<Query> constructionQueries = new LinkedList<Query>();
    SchemeCreationPolicy policy = configuration.getCreationPolicy();
    Log.info("String_Node_Str", policy.toString());
    if (policy.equals(SchemeCreationPolicy.CREATE) || policy.equals(SchemeCreationPolicy.UPDATE)) {
        EntityDependencyGraph serialSchedule = new EntityDependencyGraph(scheme.getEntities());
        for (Entity e : serialSchedule.getDestroySchedule()) {
            if (policy.equals(SchemeCreationPolicy.CREATE)) {
                Query dT = DDLQueryGenerator.dropTableQuery(e);
                constructionQueries.offer(dT);
            }
        }
        for (Entity e : serialSchedule.getConstructSchedule()) {
            Query cT = DDLQueryGenerator.createTableQuery(e, policy.equals(SchemeCreationPolicy.UPDATE));
            constructionQueries.offer(cT);
            List<Field> compositeIndexFields = new ArrayList<Field>(2);
            List<Field> singleIndexFields = new ArrayList<Field>(2);
            for (Field f : e.getFields()) {
                if (f.getIndex() != null) {
                    if (f.isPrimaryKey() && !f.isAutoIncrement())
                        compositeIndexFields.add(f);
                    if (!f.isPrimaryKey()) {
                        singleIndexFields.add(f);
                    }
                }
            }
            if (policy.equals(SchemeCreationPolicy.CREATE)) {
                Query dCI = DDLQueryGenerator.dropCompositeIndexQuery(e);
                if (dCI != null)
                    constructionQueries.offer(dCI);
            }
            Query cCI = DDLQueryGenerator.createCompositeIndexQuery(e, compositeIndexFields, policy.equals(SchemeCreationPolicy.UPDATE));
            if (cCI != null)
                constructionQueries.offer(cCI);
            for (Field f : singleIndexFields) {
                if (policy.equals(SchemeCreationPolicy.CREATE)) {
                    Query dI = DDLQueryGenerator.dropIndexQuery(e, f);
                    constructionQueries.offer(dI);
                }
                Query cI = DDLQueryGenerator.createIndexQuery(e, f, policy.equals(SchemeCreationPolicy.UPDATE));
                constructionQueries.offer(cI);
            }
        }
        Log.info("String_Node_Str");
        for (Query q : constructionQueries) {
            getExecuter().executeOnly(q);
        }
        Log.info("String_Node_Str");
    }
}

Output:
     Log.info("String_Node_Str", policy.toString());
-    if (policy.equals(SchemeCreationPolicy.CREATE) || policy.equals(SchemeCreationPolicy.UPDATE)) {
+    if (policy.equals(SchemeCreationPolicy.CREATE) || policy.equals(SchemeCreationPolicy.CREATE_IF_NOT_EXISTS)) {
         EntityDependencyGraph serialSchedule = new EntityDependencyGraph(scheme.getEntities());


Input:
private static Collection<IXWidgetProvider> getXWidgetProviders() {
    ExtensionDefinedObjects<IXWidgetProvider> contributions = new ExtensionDefinedObjects<IXWidgetProvider>(Activator.PLUGIN_ID + "String_Node_Str", "String_Node_Str", "String_Node_Str");
    return contributions.getObjects();
}

Output:
 private static Collection<IXWidgetProvider> getXWidgetProviders() {
-    ExtensionDefinedObjects<IXWidgetProvider> contributions = new ExtensionDefinedObjects<IXWidgetProvider>(Activator.PLUGIN_ID + "String_Node_Str", "String_Node_Str", "String_Node_Str");
+    ExtensionDefinedObjects<IXWidgetProvider> contributions = new ExtensionDefinedObjects<IXWidgetProvider>(Activator.PLUGIN_ID + "String_Node_Str", "String_Node_Str", "String_Node_Str", true);
     return contributions.getObjects();


Input:
protected void doExecute(ConfigurationAdmin admin) throws Exception {
    Configuration[] configs = admin.listConfigurations(query);
    for (Configuration config : configs) {
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str" + config.getPid());
        if (config.getFactoryPid() != null) {
            System.out.println("String_Node_Str" + config.getFactoryPid());
        }
        System.out.println("String_Node_Str" + config.getBundleLocation());
        if (config.getProperties() != null) {
            System.out.println("String_Node_Str");
            Dictionary props = config.getProperties();
            for (Enumeration e = props.keys(); e.hasMoreElements(); ) {
                Object key = e.nextElement();
                System.out.println("String_Node_Str" + key + "String_Node_Str" + props.get(key));
            }
        }
    }
}

Output:
     Configuration[] configs = admin.listConfigurations(query);
-    for (Configuration config : configs) {
-        System.out.println("String_Node_Str");
-        System.out.println("String_Node_Str" + config.getPid());
-        if (config.getFactoryPid() != null) {
-            System.out.println("String_Node_Str" + config.getFactoryPid());
-        }
-        System.out.println("String_Node_Str" + config.getBundleLocation());
-        if (config.getProperties() != null) {
+    if (configs != null) {
+        for (Configuration config : configs) {
             System.out.println("String_Node_Str");


Input:
public Sound transform(Sound sound) {
    this.log(new LogEvent(LogLevel.VERBOSE, "String_Node_Str"));
    PacksList packsList = PacksList.getInstance();
    int threshold = 20000;
    int channelNum = sound.getChannelNum();
    Sound builtSound = new Sound(new long[sound.getSamples().length], sound.getNbBytesPerSample(), sound.getFreq(), channelNum);
    double[] freqs = new double[sound.getSamples().length / threshold + 1];
    this.log(new LogEvent(LogLevel.VERBOSE, "String_Node_Str"));
    Sound2Note.getSoundLoudestFreqs(freqs, sound, threshold);
    double lastFreq = freqs[0];
    int lastBegining = 0;
    for (int i = 0; i < freqs.length; i++) {
        this.log(new LogEvent(LogLevel.VERBOSE, "String_Node_Str" + i + "String_Node_Str" + freqs.length));
        if (Math.abs(freqs[i] - lastFreq) > freqs[i] / 100) {
            int length = (i - 1 - lastBegining) * threshold;
            Note n = packsList.defaultPack.get("String_Node_Str").getNearestNote((int) lastFreq);
            builtSound = builtSound.concat(true, n.getAttack((int) lastFreq, channelNum, length), n.getDecay((int) lastFreq, channelNum, length), n.getSustain((int) lastFreq, channelNum, length), n.getRelease((int) lastFreq, channelNum, length));
            lastBegining = i;
            lastFreq = freqs[i];
        }
    }
    return builtSound;
}

Output:
             int length = (i - 1 - lastBegining) * threshold;
-            Note n = packsList.defaultPack.get("String_Node_Str").getNearestNote((int) lastFreq);
-            builtSound = builtSound.concat(true, n.getAttack((int) lastFreq, channelNum, length), n.getDecay((int) lastFreq, channelNum, length), n.getSustain((int) lastFreq, channelNum, length), n.getRelease((int) lastFreq, channelNum, length));
+            Note note = this.pack.get(this.instrument).getNearestNote((int) lastFreq);
+            Sound attack = note.getAttack((int) lastFreq, channelNum, length);
+            Sound decay = note.getDecay((int) lastFreq, channelNum, length);
+            Sound sustain = note.getSustain((int) lastFreq, channelNum, length);
+            Sound release = note.getRelease((int) lastFreq, channelNum, length);
+            builtSound = builtSound.concat(true, usedarraylength, attack, decay, sustain, release);
+            usedarraylength += attack.getSamples().length + decay.getSamples().length + sustain.getSamples().length + release.getSamples().length;
             lastBegining = i;


Input:
private void resetBufferInfo() {
    Thread current = Thread.currentThread();
    buffers.remove(current);
}

Output:
     Thread current = Thread.currentThread();
-    buffers.remove(current);
+    BufferInfo bufferInfo = (BufferInfo) buffers.get(current);
+    try {
+        bufferInfo.buffer.close();
+    } catch (IOException e) {
+    }
+    bufferInfo.buffer = new ByteArrayOutputStream();
+    bufferInfo.skip = false;
 }


Input:
public void testMappedByIdExample1() {
    EntityManager em = createEntityManager();
    beginTransaction(em);
    Sargeant sargeant = new Sargeant();
    MasterCorporal masterCorporal = new MasterCorporal();
    MasterCorporalId masterCorporalId = new MasterCorporalId();
    try {
        sargeant.setName("String_Node_Str");
        em.persist(sargeant);
        masterCorporalId.setName("String_Node_Str");
        masterCorporal.setId(masterCorporalId);
        masterCorporal.setSargeant(sargeant);
        em.persist(masterCorporal);
        commitTransaction(em);
    } catch (RuntimeException e) {
        if (isTransactionActive(em)) {
            rollbackTransaction(em);
        }
        closeEntityManager(em);
        throw e;
    }
    em = createEntityManager();
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery<MasterCorporal> cq = qb.createQuery(MasterCorporal.class);
    Root<MasterCorporal> from = cq.from(MasterCorporal.class);
    cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
    Query query1 = em.createQuery(cq);
    MasterCorporal results1 = (MasterCorporal) query1.getSingleResult();
    qb = em.getCriteriaBuilder();
    cq = qb.createQuery(MasterCorporal.class);
    from = cq.from(MasterCorporal.class);
    cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
    Query query2 = em.createQuery(cq);
    MasterCorporal results2 = (MasterCorporal) query2.getSingleResult();
    MasterCorporal refreshedMasterCorporal = em.find(MasterCorporal.class, masterCorporalId);
    assertTrue("String_Node_Str", getServerSession().compareObjects(masterCorporal, refreshedMasterCorporal));
    assertTrue("String_Node_Str", refreshedMasterCorporal == results1);
    assertTrue("String_Node_Str", refreshedMasterCorporal == results2);
}

Output:
     em = createEntityManager();
-    CriteriaBuilder qb = em.getCriteriaBuilder();
-    CriteriaQuery<MasterCorporal> cq = qb.createQuery(MasterCorporal.class);
-    Root<MasterCorporal> from = cq.from(MasterCorporal.class);
-    cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
-    Query query1 = em.createQuery(cq);
-    MasterCorporal results1 = (MasterCorporal) query1.getSingleResult();
-    qb = em.getCriteriaBuilder();
-    cq = qb.createQuery(MasterCorporal.class);
-    from = cq.from(MasterCorporal.class);
-    cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
-    Query query2 = em.createQuery(cq);
-    MasterCorporal results2 = (MasterCorporal) query2.getSingleResult();
-    MasterCorporal refreshedMasterCorporal = em.find(MasterCorporal.class, masterCorporalId);
-    assertTrue("String_Node_Str", getServerSession().compareObjects(masterCorporal, refreshedMasterCorporal));
-    assertTrue("String_Node_Str", refreshedMasterCorporal == results1);
-    assertTrue("String_Node_Str", refreshedMasterCorporal == results2);
+    beginTransaction(em);
+    try {
+        CriteriaBuilder qb = em.getCriteriaBuilder();
+        CriteriaQuery<MasterCorporal> cq = qb.createQuery(MasterCorporal.class);
+        Root<MasterCorporal> from = cq.from(MasterCorporal.class);
+        cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
+        Query query1 = em.createQuery(cq);
+        MasterCorporal results1 = (MasterCorporal) query1.getSingleResult();
+        qb = em.getCriteriaBuilder();
+        cq = qb.createQuery(MasterCorporal.class);
+        from = cq.from(MasterCorporal.class);
+        cq.where(qb.and(qb.equal(from.get("String_Node_Str").get("String_Node_Str"), "String_Node_Str"), qb.equal(from.get("String_Node_Str").get("String_Node_Str"), sargeant.getSargeantId())));
+        Query query2 = em.createQuery(cq);
+        MasterCorporal results2 = (MasterCorporal) query2.getSingleResult();
+        MasterCorporal refreshedMasterCorporal = em.find(MasterCorporal.class, masterCorporalId);
+        assertTrue("String_Node_Str", getServerSession().compareObjects(masterCorporal, refreshedMasterCorporal));
+        assertTrue("String_Node_Str", refreshedMasterCorporal == results1);
+        assertTrue("String_Node_Str", refreshedMasterCorporal == results2);
+    } finally {
+        rollbackTransaction(em);
+        closeEntityManager(em);
+    }
 }


Input:
public String encryptWithSessionKey(String plaintext) throws CryptoHelperException {
    Log.i(TAG, "String_Node_Str");
    status = false;
    if (password == null) {
        String msg = "String_Node_Str";
        throw new CryptoHelperException(msg);
    }
    byte[] cipherSessionKey = {};
    byte[] ciphertext = {};
    SecretKey sessionKey = null;
    byte[] sessionKeyEncoded = null;
    String sessionKeyString = null;
    try {
        KeyGenerator keygen;
        keygen = KeyGenerator.getInstance("String_Node_Str");
        keygen.init(256);
        sessionKey = keygen.generateKey();
        sessionKeyEncoded = sessionKey.getEncoded();
        sessionKeyString = new String(sessionKeyEncoded);
    } catch (NoSuchAlgorithmException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    PBEKeySpec sessionPbeKeySpec = new PBEKeySpec(sessionKeyString.toCharArray());
    SecretKey sessionPbeKey = null;
    try {
        sessionPbeKey = keyFac.generateSecret(sessionPbeKeySpec);
    } catch (InvalidKeySpecException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    try {
        pbeCipher.init(Cipher.ENCRYPT_MODE, pbeKey, pbeParamSpec);
        cipherSessionKey = pbeCipher.doFinal(sessionKeyEncoded);
    } catch (IllegalBlockSizeException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (BadPaddingException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidKeyException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidAlgorithmParameterException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    try {
        pbeCipher.init(Cipher.ENCRYPT_MODE, sessionPbeKey, pbeParamSpec);
        ciphertext = pbeCipher.doFinal(plaintext.getBytes());
        status = true;
    } catch (IllegalBlockSizeException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (BadPaddingException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidKeyException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    } catch (InvalidAlgorithmParameterException e) {
        Log.e(TAG, "String_Node_Str" + e.toString());
    }
    String stringCipherSessionKey = toHexString(cipherSessionKey);
    String stringCiphertext = toHexString(ciphertext);
    Log.i(TAG, "String_Node_Str" + stringCipherSessionKey.length() + "String_Node_Str" + stringCipherSessionKey);
    return stringCipherSessionKey + stringCiphertext;
}

Output:
     Log.i(TAG, "String_Node_Str" + stringCipherSessionKey.length() + "String_Node_Str" + stringCipherSessionKey);
-    return stringCipherSessionKey + stringCiphertext;
+    StringBuilder sb = new StringBuilder(stringCipherVersion.length() + stringCipherSessionKey.length() + stringCiphertext.length());
+    sb.append(stringCipherVersion);
+    sb.append(stringCipherSessionKey);
+    sb.append(stringCiphertext);
+    return sb.toString();
 }


Input:
public boolean moveCards(Set<Card> cards, Zone toZone, Ability source, Game game, boolean tapped, boolean faceDown, boolean byOwner, ArrayList<UUID> appliedEffects) {
    if (cards.isEmpty()) {
        return true;
    }
    Set<Card> successfulMovedCards = new LinkedHashSet<>();
    Zone fromZone = null;
    switch(toZone) {
        case GRAVEYARD:
            fromZone = game.getState().getZone(cards.iterator().next().getId());
            successfulMovedCards = moveCardsToGraveyardWithInfo(cards, source, game, fromZone);
            break;
        case BATTLEFIELD:
            List<Permanent> permanents = new ArrayList<>();
            List<Permanent> permanentsEntered = new ArrayList<>();
            for (Card card : cards) {
                UUID controllingPlayerId = byOwner ? card.getOwnerId() : getId();
                fromZone = game.getState().getZone(card.getId());
                if (faceDown) {
                    card.setFaceDown(true, game);
                }
                ZoneChangeEvent event = new ZoneChangeEvent(card.getId(), source.getSourceId(), controllingPlayerId, fromZone, Zone.BATTLEFIELD, appliedEffects, tapped);
                if (!game.replaceEvent(event)) {
                    Permanent permanent = new PermanentCard(card, event.getPlayerId(), game);
                    permanents.add(permanent);
                    game.getPermanentsEntering().put(permanent.getId(), permanent);
                    card.checkForCountersToAdd(permanent, game);
                    permanent.setTapped(tapped);
                    permanent.setFaceDown(faceDown, game);
                }
                if (faceDown) {
                    card.setFaceDown(false, game);
                }
            }
            game.setScopeRelevant(true);
            for (Permanent permanent : permanents) {
                fromZone = game.getState().getZone(permanent.getId());
                if (permanent.entersBattlefield(source.getSourceId(), game, fromZone, true)) {
                    permanentsEntered.add(permanent);
                } else {
                    game.getPermanentsEntering().remove(permanent.getId());
                }
            }
            game.setScopeRelevant(false);
            for (Permanent permanent : permanentsEntered) {
                fromZone = game.getState().getZone(permanent.getId());
                if (((Card) permanent).removeFromZone(game, fromZone, source.getSourceId())) {
                    permanent.updateZoneChangeCounter(game);
                    game.getContinuousEffects().setController(permanent.getId(), permanent.getControllerId());
                    game.addPermanent(permanent);
                    permanent.setZone(Zone.BATTLEFIELD, game);
                    game.getPermanentsEntering().remove(permanent.getId());
                    game.setScopeRelevant(true);
                    successfulMovedCards.add(permanent);
                    game.addSimultaneousEvent(new ZoneChangeEvent(permanent, permanent.getControllerId(), fromZone, Zone.BATTLEFIELD));
                    if (!game.isSimulation()) {
                        game.informPlayers(this.getLogName() + "String_Node_Str" + (faceDown ? "String_Node_Str" : permanent.getLogName()) + "String_Node_Str" + fromZone.toString().toLowerCase(Locale.ENGLISH) + "String_Node_Str");
                    }
                } else {
                    game.getPermanentsEntering().remove(permanent.getId());
                }
            }
            game.applyEffects();
            break;
        case HAND:
            for (Card card : cards) {
                fromZone = game.getState().getZone(card.getId());
                boolean hideCard = fromZone.equals(Zone.LIBRARY) || (card.isFaceDown(game) && !fromZone.equals(Zone.STACK) && !fromZone.equals(Zone.BATTLEFIELD));
                if (moveCardToHandWithInfo(card, source == null ? null : source.getSourceId(), game, !hideCard)) {
                    successfulMovedCards.add(card);
                }
            }
            break;
        case EXILED:
            for (Card card : cards) {
                fromZone = game.getState().getZone(card.getId());
                boolean withName = (fromZone.equals(Zone.BATTLEFIELD) || fromZone.equals(Zone.STACK)) || !card.isFaceDown(game);
                if (moveCardToExileWithInfo(card, null, "String_Node_Str", source == null ? null : source.getSourceId(), game, fromZone, withName)) {
                    successfulMovedCards.add(card);
                }
            }
            break;
        case LIBRARY:
            for (Card card : cards) {
                fromZone = game.getState().getZone(card.getId());
                boolean hideCard = fromZone.equals(Zone.HAND) || fromZone.equals(Zone.LIBRARY);
                if (moveCardToLibraryWithInfo(card, source == null ? null : source.getSourceId(), game, fromZone, true, !hideCard)) {
                    successfulMovedCards.add(card);
                }
            }
            break;
        default:
            throw new UnsupportedOperationException("String_Node_Str" + toZone.toString() + "String_Node_Str");
    }
    game.fireEvent(new ZoneChangeGroupEvent(successfulMovedCards, source == null ? null : source.getSourceId(), this.getId(), fromZone, toZone));
    return successfulMovedCards.size() > 0;
}

Output:
             for (Card card : cards) {
-                fromZone = game.getState().getZone(card.getId());
+                if (card instanceof Spell) {
+                    fromZone = game.getState().getZone(((Spell) card).getSourceId());
+                } else {
+                    fromZone = game.getState().getZone(card.getId());
+                }
                 boolean hideCard = fromZone.equals(Zone.HAND) || fromZone.equals(Zone.LIBRARY);


Input:
public void testGetExternalizedText() throws Exception {
    openDesign("String_Node_Str");
    TableHandle tableHandle = (TableHandle) designHandle.getBody().get(0);
    PropertyHandle propHandle = tableHandle.getPropertyHandle(IStyleModel.MAP_RULES_PROP);
    ThreadResources.setLocale(new ULocale("String_Node_Str"));
    MapRuleHandle structHandle = (MapRuleHandle) propHandle.get(0);
    String value = structHandle.getExternalizedValue(MapRule.DISPLAY_ID_MEMBER, MapRule.DISPLAY_MEMBER);
    assertEquals("String_Node_Str", value);
    ThreadResources.setLocale(new ULocale("String_Node_Str"));
    structHandle = (MapRuleHandle) propHandle.get(0);
    value = structHandle.getExternalizedValue(MapRule.DISPLAY_ID_MEMBER, MapRule.DISPLAY_MEMBER);
    assertEquals("String_Node_Str", value);
}

Output:
     PropertyHandle propHandle = tableHandle.getPropertyHandle(IStyleModel.MAP_RULES_PROP);
-    ThreadResources.setLocale(new ULocale("String_Node_Str"));
+    ModuleOption option = new ModuleOption();
+    option.setLocale(new ULocale("String_Node_Str"));
+    design.setOptions(option);
     MapRuleHandle structHandle = (MapRuleHandle) propHandle.get(0);


Input:
public void init(TreeViewer viewer, IStructuredSelection selection) {
    visible = !selection.isEmpty();
    if (selection.isEmpty()) {
        setEnabled(false);
        return;
    }
    boolean enabled = true;
    this.setText(null);
    IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
    if (factory.isUserReadOnlyOnCurrentProject()) {
        visible = false;
    }
    if (factory.getRepositoryContext().isOffline() || factory.getRepositoryContext().isEditableAsReadOnly()) {
        visible = false;
    }
    for (Object o : (selection).toArray()) {
        if (visible) {
            RepositoryNode node = (RepositoryNode) o;
            if (!ProjectManager.getInstance().isInCurrentMainProject(node)) {
                visible = false;
                break;
            }
            switch(node.getType()) {
                case STABLE_SYSTEM_FOLDER:
                    visible = false;
                case SYSTEM_FOLDER:
                    visible = false;
                    break;
                case SIMPLE_FOLDER:
                    Object obj = node.getProperties(EProperties.LABEL);
                    String label = null;
                    IRepositoryViewObject folderObj = node.getObject();
                    ERepositoryStatus statusFolder = folderObj.getRepositoryStatus();
                    boolean isDeletedFolder = statusFolder == ERepositoryStatus.DELETED;
                    if (obj instanceof String) {
                        label = (String) obj;
                    }
                    if (node.getContentType() == ERepositoryObjectType.JOB_DOC || node.getContentType() == ERepositoryObjectType.JOBLET_DOC || RepositoryConstants.USER_DEFINED.equals(label)) {
                        visible = false;
                    } else {
                        if (isDeletedFolder) {
                            this.setText(DELETE_FOREVER_TITLE);
                            this.setToolTipText(DELETE_FOREVER_TOOLTIP);
                        } else {
                            this.setText(DELETE_LOGICAL_TITLE);
                            this.setToolTipText(DELETE_LOGICAL_TOOLTIP);
                        }
                        if (node.hasChildren()) {
                            visible = true;
                            enabled = true;
                        }
                    }
                    String selectName = selection.getFirstElement().toString();
                    if (node.getContentType() == ERepositoryObjectType.SQLPATTERNS && selectName.equals(label) && !selectName.contains("String_Node_Str")) {
                        visible = false;
                    }
                    break;
                case REPOSITORY_ELEMENT:
                    Object contentType = node.getProperties(EProperties.CONTENT_TYPE);
                    if (contentType == ERepositoryObjectType.JOB_DOC || contentType == ERepositoryObjectType.JOBLET_DOC) {
                        visible = false;
                        break;
                    }
                    if (contentType == ERepositoryObjectType.METADATA_CON_CDC) {
                        enabled = false;
                        visible = false;
                        break;
                    }
                    if (contentType == ERepositoryObjectType.SERVICESOPERATION) {
                        enabled = false;
                        visible = false;
                        break;
                    }
                    if (contentType == ERepositoryObjectType.SERVICESPORT) {
                        enabled = false;
                        visible = false;
                        break;
                    }
                    if (contentType == ERepositoryObjectType.METADATA_CON_TABLE) {
                        enabled = false;
                        visible = false;
                        break;
                    }
                    if (contentType == ERepositoryObjectType.METADATA_VALIDATION_RULES) {
                        RepositoryNode parent = node.getParent().getParent();
                        if (parent != null && ERepositoryObjectType.METADATA_CON_TABLE == parent.getObjectType()) {
                            enabled = false;
                            visible = false;
                            break;
                        }
                    }
                    IRepositoryViewObject repObj = node.getObject();
                    ERepositoryStatus status = repObj.getRepositoryStatus();
                    boolean isEditable = status.isPotentiallyEditable() || status.isEditable();
                    boolean isDeleted = status == ERepositoryStatus.DELETED;
                    ERepositoryObjectType nodeType = (ERepositoryObjectType) node.getProperties(EProperties.CONTENT_TYPE);
                    if (nodeType.isSubItem() && repObj instanceof ISubRepositoryObject) {
                        ISubRepositoryObject subRepositoryObject = (ISubRepositoryObject) repObj;
                        isDeleted = SubItemHelper.isDeleted(subRepositoryObject.getAbstractMetadataObject());
                    }
                    if (isDeleted) {
                        if (ERepositoryObjectType.METADATA_CON_COLUMN.equals(nodeType)) {
                            visible = false;
                            break;
                        }
                        if (ERepositoryObjectType.METADATA_CON_QUERY.equals(nodeType)) {
                            visible = false;
                            break;
                        }
                        if (getText() == null || DELETE_FOREVER_TITLE.equals(getText())) {
                            this.setText(DELETE_FOREVER_TITLE);
                            this.setToolTipText(DELETE_FOREVER_TOOLTIP);
                        } else {
                            visible = false;
                        }
                    } else {
                        ERepositoryObjectType repositoryObjectType = repObj.getRepositoryObjectType();
                        if (repositoryObjectType == ERepositoryObjectType.METADATA_CON_TABLE || repositoryObjectType == ERepositoryObjectType.METADATA_CON_QUERY || repositoryObjectType == ERepositoryObjectType.METADATA_CON_COLUMN) {
                            visible = false;
                        } else {
                            if (getText() == null || DELETE_LOGICAL_TITLE.equals(getText())) {
                                this.setText(DELETE_LOGICAL_TITLE);
                                this.setToolTipText(DELETE_LOGICAL_TOOLTIP);
                                if (!isEditable) {
                                    visible = true;
                                    enabled = false;
                                }
                            } else {
                                visible = false;
                            }
                        }
                    }
                    break;
                default:
                    break;
            }
        }
    }
    setEnabled(enabled);
}

Output:
                     String label = null;
-                    IRepositoryViewObject folderObj = node.getObject();
-                    ERepositoryStatus statusFolder = folderObj.getRepositoryStatus();
-                    boolean isDeletedFolder = statusFolder == ERepositoryStatus.DELETED;
+                    IPath path = RepositoryNodeUtilities.getPath(node);
+                    ERepositoryObjectType objectType = (ERepositoryObjectType) node.getProperties(EProperties.CONTENT_TYPE);
+                    FolderItem folderItem = factory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), objectType, path);
+                    boolean isDeletedFolder = folderItem.getState().isDeleted();
                     if (obj instanceof String) {


Input:
public double apply(final IDoubleSizedIterable a, final IDoubleSizedIterable b) {
    final IDoubleSizedIterator a_it = a.iterator();
    final IDoubleSizedIterator b_it = a.iterator();
    double acc = 0;
    while (a_it.hasNext() && b_it.hasNext()) {
        final double d = Math.abs(a_it.nextPrimitive() - b_it.nextPrimitive());
        if (!isNaN(d) && d > acc)
            acc = d;
    }
    return acc;
}

Output:
     final IDoubleSizedIterator a_it = a.iterator();
-    final IDoubleSizedIterator b_it = a.iterator();
+    final IDoubleSizedIterator b_it = b.iterator();
     double acc = 0;


Input:
protected void parseConfigVars(HttpServletRequest request, Collection parameterList) {
    this.configMap = new HashMap();
    if (this.displayTexts == null)
        this.displayTexts = new HashMap();
    String reportConfigName = ParameterAccessor.getConfigFileName(this.reportDesignName);
    if (reportConfigName == null)
        return;
    SessionHandle sessionHandle = new DesignEngine(null).newSessionHandle(ULocale.US);
    ReportDesignHandle handle = null;
    try {
        handle = sessionHandle.openDesign(reportConfigName);
        if (handle != null) {
            String displayTextParam = null;
            Iterator configVars = handle.configVariablesIterator();
            while (configVars != null && configVars.hasNext()) {
                ConfigVariableHandle configVar = (ConfigVariableHandle) configVars.next();
                if (configVar != null && configVar.getName() != null) {
                    String paramName = configVar.getName();
                    Object paramValue = configVar.getValue();
                    if (paramName.toLowerCase().startsWith(ParameterAccessor.PARAM_ISNULL) && paramValue != null) {
                        String nullParamName = getParameterName((String) paramValue, parameterList);
                        if (nullParamName != null)
                            this.configMap.put(nullParamName, null);
                        continue;
                    } else if ((displayTextParam = ParameterAccessor.isDisplayText(paramName)) != null) {
                        paramName = getParameterName(displayTextParam, parameterList);
                        if (paramName != null) {
                            this.displayTexts.put(paramName, paramValue);
                        }
                        continue;
                    }
                    paramName = getParameterName(paramName, parameterList);
                    ParameterDefinition parameter = BirtUtility.findParameterDefinition(parameterList, paramName);
                    if (paramValue != null && parameter != null) {
                        String typeVarName = configVar.getName() + "String_Node_Str" + IBirtConstants.PROP_TYPE;
                        ConfigVariable typeVar = handle.findConfigVariable(typeVarName);
                        String dataType = ParameterDataTypeConverter.ConvertDataType(parameter.getDataType());
                        String cachedDateType = null;
                        if (typeVar != null)
                            cachedDateType = typeVar.getValue();
                        if (cachedDateType == null || !cachedDateType.equalsIgnoreCase(dataType))
                            continue;
                        String exprVarName = configVar.getName() + "String_Node_Str" + IBirtConstants.PROP_EXPR;
                        ConfigVariable exprVar = handle.findConfigVariable(exprVarName);
                        String cachedExpr = null;
                        if (exprVar != null)
                            cachedExpr = exprVar.getValue();
                        if (cachedExpr == null)
                            cachedExpr = "String_Node_Str";
                        String expr = parameter.getValueExpr();
                        if (expr == null)
                            expr = "String_Node_Str";
                        if (!cachedExpr.equals(expr))
                            continue;
                        this.configMap.put(paramName, paramValue);
                    }
                }
            }
            handle.close();
        }
    } catch (Exception e) {
    }
}

Output:
                 ConfigVariableHandle configVar = (ConfigVariableHandle) configVars.next();
-                if (configVar != null && configVar.getName() != null) {
-                    String paramName = configVar.getName();
-                    Object paramValue = configVar.getValue();
-                    if (paramName.toLowerCase().startsWith(ParameterAccessor.PARAM_ISNULL) && paramValue != null) {
-                        String nullParamName = getParameterName((String) paramValue, parameterList);
-                        if (nullParamName != null)
-                            this.configMap.put(nullParamName, null);
-                        continue;
-                    } else if ((displayTextParam = ParameterAccessor.isDisplayText(paramName)) != null) {
-                        paramName = getParameterName(displayTextParam, parameterList);
-                        if (paramName != null) {
-                            this.displayTexts.put(paramName, paramValue);
-                        }
+                if (configVar != null) {
+                    String varName = configVar.getName();
+                    Object varValue = configVar.getValue();
+                    if (varName == null || varValue == null)
                         continue;


Input:
private List<CommentRow> createCommentRows(String giverEmail, String giverName) {
    List<CommentRow> rows = new ArrayList<CommentRow>();
    List<CommentAttributes> commentsForGiver = comments.get(giverEmail);
    for (int i = 0; i < commentsForGiver.size(); i++) {
        String recipientDetails = getRecipientNames(commentsForGiver.get(i).recipients);
        String creationTime = TimeHelper.formatTime(commentsForGiver.get(i).createdAt);
        Boolean isInstructorAllowedToModifyCommentInSection = commentModifyPermissions.get(giverEmail).get(i);
        String typeOfPeopleCanViewComment = getTypeOfPeopleCanViewComment(commentsForGiver.get(i));
        String editedAt = commentsForGiver.get(i).getEditedAtText(giverName.equals("String_Node_Str"));
        String showCommentsTo = getShowCommentsToForComment(commentsForGiver.get(i));
        String showGiverNameTo = getShowGiverNameToForComment(commentsForGiver.get(i));
        String showRecipientNameTo = getShowRecipientNameToForComment(commentsForGiver.get(i));
        VisibilityCheckboxes visibilityCheckboxes = createVisibilityCheckboxes(commentsForGiver.get(i));
        rows.add(new InstructorCommentsCommentRow(giverEmail, commentsForGiver.get(i), recipientDetails, creationTime, isInstructorAllowedToModifyCommentInSection, typeOfPeopleCanViewComment, editedAt, visibilityCheckboxes, showCommentsTo, showGiverNameTo, showRecipientNameTo));
    }
    return rows;
}

Output:
         String recipientDetails = getRecipientNames(commentsForGiver.get(i).recipients);
-        String creationTime = TimeHelper.formatTime(commentsForGiver.get(i).createdAt);
+        String creationTime = Const.SystemParams.COMMENTS_SIMPLE_DATE_FORMATTER.format(commentsForGiver.get(i).createdAt);
         Boolean isInstructorAllowedToModifyCommentInSection = commentModifyPermissions.get(giverEmail).get(i);


Input:
public String[] runESearch(String term, boolean logMessage) throws IOException {
    String[] env = new String[4];
    try {
        StringBuilder urlSb = new StringBuilder();
        urlSb.append("String_Node_Str");
        urlSb.append("String_Node_Str");
        urlSb.append(database);
        urlSb.append("String_Node_Str");
        urlSb.append(getToolName());
        urlSb.append("String_Node_Str");
        urlSb.append(getEmailAddress());
        urlSb.append("String_Node_Str");
        urlSb.append("String_Node_Str");
        urlSb.append("String_Node_Str");
        urlSb.append(term);
        if (logMessage) {
        }
        DocumentBuilderFactory docBuildFactory = DocumentBuilderFactory.newInstance();
        docBuildFactory.setIgnoringComments(true);
        Document doc = docBuildFactory.newDocumentBuilder().parse(new InputSource(new ByteArrayInputStream(WebAide.getURLContents(urlSb.toString()).getBytes())));
        env[0] = doc.getElementsByTagName("String_Node_Str").item(0).getTextContent();
        env[1] = doc.getElementsByTagName("String_Node_Str").item(0).getTextContent();
        env[2] = doc.getElementsByTagName("String_Node_Str").item(0).getTextContent();
        env[3] = doc.getElementsByTagName("String_Node_Str").item(0).getTextContent();
        if (logMessage) {
            log.info("String_Node_Str" + env[2] + "String_Node_Str");
        }
    } catch (MalformedURLException e) {
        throw new IOException(e);
    } catch (SAXException e) {
        throw new IOException(e);
    } catch (ParserConfigurationException e) {
        throw new IOException(e);
    }
    return env;
}

Output:
         docBuildFactory.setIgnoringComments(true);
-        Document doc = docBuildFactory.newDocumentBuilder().parse(new InputSource(new ByteArrayInputStream(WebAide.getURLContents(urlSb.toString()).getBytes())));
+        Document doc = docBuildFactory.newDocumentBuilder().parse(new InputSource(new ByteArrayInputStream(WebAide.getURLContents(urlSb.toString()).getBytes("String_Node_Str"))));
         env[0] = doc.getElementsByTagName("String_Node_Str").item(0).getTextContent();


Input:
public Set<Map.Entry<K, V>> entrySet() {
    final StringBuilder csp = Wires.acquireStringBuilder();
    long cid = proxyReturnWireConsumer(entrySet, read -> {
        final StringBuilder type = Wires.acquireAnotherStringBuilder(csp);
        read.type(type);
        return read.applyToMarshallable(w -> {
            final long cid0 = CoreFields.cid(w);
            cidToCsp.put(cid0, stringEvent(CoreFields.csp, csp, w).toString());
            return cid0;
        });
    });
    Function<ValueIn, Map.Entry<K, V>> conumer = valueIn -> valueIn.applyToMarshallable(r -> {
        final K k = r.read(() -> "String_Node_Str").object(kClass);
        final V v = r.read(() -> "String_Node_Str").object(vClass);
        return new Map.Entry<K, V>() {
            public K getKey() {
                return k;
            }
            public V getValue() {
                return v;
            }
            public V setValue(Object value) {
                throw new UnsupportedOperationException();
            }
        };
    });
    return new ClientWiredStatelessChronicleSet<>(channelName, hub, cid, conumer, csp.toString());
}

Output:
             final long cid0 = CoreFields.cid(w);
-            cidToCsp.put(cid0, stringEvent(CoreFields.csp, csp, w).toString());
+            cidToCsp.put(cid0, csp.toString());
             return cid0;


Input:
public long getCurrent() {
    Double d = new Double(getAverage());
    return d.longValue();
}

Output:
 public long getCurrent() {
-    Double d = new Double(getAverage());
-    return d.longValue();
+    return Double.valueOf(getAverage()).longValue();
 }


Input:
protected String getDaoBasePackageName() {
    String daoPackageName = element.getAttribute(DAO_PACKAGE_NAME);
    return StringUtils.hasText(daoPackageName) ? daoPackageName : parent.getDaoBasePackageName();
}

Output:
 protected String getDaoBasePackageName() {
-    String daoPackageName = element.getAttribute(DAO_PACKAGE_NAME);
+    String daoPackageName = getElement().getAttribute(DAO_PACKAGE_NAME);
     return StringUtils.hasText(daoPackageName) ? daoPackageName : parent.getDaoBasePackageName();


Input:
private void setupVmMessages(final ResourceToken token) {
    Integer vlan = null;
    List<String> networkNames = null;
    ArrayList<String> networkIndexes = Lists.newArrayList();
    if (token.getPrimaryNetwork() != null) {
        vlan = token.getPrimaryNetwork().getVlan();
        if (vlan < 0)
            vlan = 9;
        networkNames = Lists.newArrayList(token.getPrimaryNetwork().getNetworkName());
        for (Integer index : token.getPrimaryNetwork().getIndexes()) {
            networkIndexes.add(index.toString());
        }
    } else {
        vlan = -1;
        networkNames = Lists.newArrayList(Collections.nCopies(token.getAmount(), "String_Node_Str"));
        networkIndexes = Lists.newArrayList(Collections.nCopies(token.getAmount(), "String_Node_Str"));
    }
    final List<String> addresses = Lists.newArrayList(token.getAddresses());
    RunInstancesType request = this.allocInfo.getRequest();
    String rsvId = this.allocInfo.getReservationId();
    VmKeyInfo keyInfo = this.allocInfo.getKeyInfo();
    VmTypeInfo vmInfo = this.allocInfo.getVmTypeInfo();
    String userData = this.allocInfo.getRequest().getUserData();
    Request cb = null;
    int index = 0;
    try {
        for (ResourceToken childToken : this.cluster.getNodeState().splitToken(token)) {
            VirtualBootRecord root = vmInfo.lookupRoot();
            VmTypeInfo childVmInfo = vmInfo;
            if (root.isBlockStorage()) {
                childVmInfo = vmInfo.child();
                Volume vol = this.allocInfo.getPersistentVolumes().get(index);
                Dispatcher sc = ServiceDispatcher.lookup(Partitions.lookupService(Storage.class, vol.getPartition()));
                for (int i = 0; i < 60; i++) {
                    try {
                        DescribeStorageVolumesResponseType volState = sc.send(new DescribeStorageVolumesType(Lists.newArrayList(vol.getDisplayName())));
                        if ("String_Node_Str".equals(volState.getVolumeSet().get(0).getStatus())) {
                            break;
                        }
                    } catch (Exception ex) {
                        LOG.error(ex, ex);
                    }
                    for (String nodeTag : this.cluster.getNodeTags()) {
                        try {
                            AttachStorageVolumeResponseType scAttachResponse = sc.send(new AttachStorageVolumeType(this.cluster.getNode(nodeTag).getIqn(), vol.getDisplayName()));
                            childVmInfo.lookupRoot().setResourceLocation(scAttachResponse.getRemoteDeviceString());
                        } catch (Exception ex) {
                            LOG.error(ex, ex);
                        }
                    }
                }
            }
            cb = makeRunRequest(request, childToken, this.allocInfo.getOwnerFullName(), rsvId, keyInfo, childVmInfo, this.allocInfo.getBootSet().getMachine().getPlatform().name(), vlan, networkNames, userData);
            this.messages.addRequest(State.CREATE_VMS, cb);
            index++;
        }
    } catch (NoSuchTokenException ex) {
        throw new RuntimeException(ex);
    }
}

Output:
                     }
-                    for (String nodeTag : this.cluster.getNodeTags()) {
-                        try {
-                            AttachStorageVolumeResponseType scAttachResponse = sc.send(new AttachStorageVolumeType(this.cluster.getNode(nodeTag).getIqn(), vol.getDisplayName()));
-                            childVmInfo.lookupRoot().setResourceLocation(scAttachResponse.getRemoteDeviceString());
-                        } catch (Exception ex) {
-                            LOG.error(ex, ex);
-                        }
+                }
+                for (String nodeTag : this.cluster.getNodeTags()) {
+                    try {
+                        AttachStorageVolumeResponseType scAttachResponse = sc.send(new AttachStorageVolumeType(this.cluster.getNode(nodeTag).getIqn(), vol.getDisplayName()));
+                        childVmInfo.lookupRoot().setResourceLocation(scAttachResponse.getRemoteDeviceString());
+                    } catch (Exception ex) {
+                        LOG.error(ex, ex);
                     }


Input:
void buttonNewProcessHandler(ClickEvent e) {
    if (repId != null) {
        LastSelectedItemsSingleton selectedItems = LastSelectedItemsSingleton.getInstance();
        selectedItems.setSelectedItems(SelectedItemsList.create(IndexedRepresentation.class, repId));
        Tools.newHistory(CreateJob.RESOLVER, "String_Node_Str");
    }
}

Output:
 void buttonNewProcessHandler(ClickEvent e) {
-    if (repId != null) {
-        LastSelectedItemsSingleton selectedItems = LastSelectedItemsSingleton.getInstance();
-        selectedItems.setSelectedItems(SelectedItemsList.create(IndexedRepresentation.class, repId));
-        Tools.newHistory(CreateJob.RESOLVER, "String_Node_Str");
+    SelectedItems selected = (SelectedItems) filesList.getSelected();
+    if (ClientSelectedItemsUtils.isEmpty(selected)) {
+        selected = new SelectedItemsList<IndexedRepresentation>(Arrays.asList(repId), IndexedRepresentation.class.getName());
     }


Input:
protected ElementLayout createDefaultCaptionLayout(int pickingID) {
    ElementLayout captionLayout = new ElementLayout("String_Node_Str");
    captionLayout.setPixelSizeY(CAPTION_HEIGHT_PIXELS);
    captionLayout.setRatioSizeX(1);
    captionLayout.setRenderer(new LabelRenderer(view, this, createNodePickingTypeList()));
    return captionLayout;
}

Output:
     captionLayout.setRatioSizeX(1);
-    captionLayout.setRenderer(new LabelRenderer(view, this, createNodePickingTypeList()));
+    captionLayout.setRenderer(new LabelRenderer(view, view.getTextRenderer(), this, createNodePickingTypeList()));
     return captionLayout;


Input:
public void encodeEnd(FacesContext context, UIComponent component) throws IOException {
    if (!component.isRendered()) {
        return;
    }
    DataTable dataTable = (DataTable) component;
    Map<Integer, String> columnSortOrder = dataTable.getColumnSortOrderMap();
    int pageLength = dataTable.getPageLength();
    String orderString = "String_Node_Str";
    if (columnSortOrder != null) {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        for (Map.Entry<Integer, String> entry : columnSortOrder.entrySet()) {
            String separator = (i > 0) ? "String_Node_Str" : "String_Node_Str";
            sb.append(separator).append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append("String_Node_Str").append(entry.getValue()).append("String_Node_Str").append("String_Node_Str");
            i++;
        }
        orderString = sb.toString();
    }
    ResponseWriter rw = context.getResponseWriter();
    String clientIdRaw = dataTable.getClientId();
    String clientId = clientIdRaw.replace("String_Node_Str", "String_Node_Str");
    String widgetVar = dataTable.getWidgetVar();
    if (null == widgetVar) {
        widgetVar = BsfUtils.widgetVarName(clientIdRaw);
    }
    String lang = determineLanguage(context, dataTable);
    rw.endElement("String_Node_Str");
    endDisabledFieldset(dataTable, rw);
    String responsiveStyle = Responsive.getResponsiveStyleClass(dataTable, false);
    if (null != responsiveStyle && responsiveStyle.trim().length() > 0) {
        rw.endElement("String_Node_Str");
    }
    if (dataTable.isScrollHorizontally()) {
        rw.endElement("String_Node_Str");
    }
    Tooltip.activateTooltips(context, dataTable);
    rw.startElement("String_Node_Str", component);
    rw.writeText("String_Node_Str", null);
    String options = "String_Node_Str";
    options = addOptions("String_Node_Str" + dataTable.isFixedHeader(), options);
    options = addOptions("String_Node_Str" + dataTable.isResponsive(), options);
    options = addOptions("String_Node_Str" + dataTable.isPaginated(), options);
    if (!dataTable.isInfo()) {
        options = addOptions("String_Node_Str", options);
    }
    options = addOptions("String_Node_Str" + pageLength, options);
    options = addOptions("String_Node_Str" + getPageLengthMenu(dataTable), options);
    options = addOptions("String_Node_Str" + dataTable.isSearching(), options);
    options = addOptions("String_Node_Str" + orderString, options);
    options = addOptions("String_Node_Str" + dataTable.isSaveState(), options);
    options = addOptions("String_Node_Str", options);
    if (dataTable.isSelect()) {
        String json = "String_Node_Str";
        String items = dataTable.getSelectedItems();
        if ("String_Node_Str".equals(items) || "String_Node_Str".equals(items)) {
            json += "String_Node_Str";
        } else if ("String_Node_Str".equals(items) || "String_Node_Str".equals(items)) {
            json += "String_Node_Str";
        }
        if ("String_Node_Str".equalsIgnoreCase(dataTable.getSelectionMode())) {
            json += "String_Node_Str";
        } else {
            json += "String_Node_Str";
        }
        if (!dataTable.isSelectionInfo()) {
            json += "String_Node_Str";
        }
        if (dataTable.isDeselectOnBackdropClick()) {
            json += "String_Node_Str";
        }
        if (json.length() > 1) {
            json = "String_Node_Str" + json.substring(0, json.length() - 1) + "String_Node_Str";
        } else {
            json = "String_Node_Str";
        }
        options = addOptions(json, options);
    }
    options = addOptions(generateScrollOptions(dataTable), options);
    options = addOptions((BsfUtils.isStringValued(lang) ? "String_Node_Str" + lang + "String_Node_Str" : null), options);
    options = addOptions(generateColumnInfos(dataTable.getColumnInfo()), options);
    options = addOptions(dataTable.getCustomOptions(), options);
    options = addOptions(getButtons(dataTable), options);
    String selectCommand = "String_Node_Str";
    Object selectedRow = dataTable.getSelectedRow();
    if (null != selectedRow) {
        String selector = "String_Node_Str";
        if (selectedRow instanceof String) {
            try {
                Integer.parseInt((String) selectedRow);
                selector = (String) selectedRow;
            } catch (NumberFormatException itIsAString) {
                selector = "String_Node_Str" + selectedRow + "String_Node_Str";
            }
        } else if (selectedRow instanceof Number) {
            selector = selectedRow.toString();
        }
        selectCommand = widgetVar + "String_Node_Str" + selector + "String_Node_Str";
    }
    Object selectedColumn = dataTable.getSelectedColumn();
    if (null != selectedColumn) {
        String selector = "String_Node_Str";
        if (selectedColumn instanceof String) {
            try {
                Integer.parseInt((String) selectedColumn);
                selector = (String) selectedColumn;
            } catch (NumberFormatException itIsAString) {
                selector = "String_Node_Str" + selectedColumn + "String_Node_Str";
            }
        } else if (selectedColumn instanceof Number) {
            selector = selectedColumn.toString();
        }
        selectCommand += widgetVar + "String_Node_Str" + selector + "String_Node_Str";
    }
    if (selectCommand.length() > 0) {
        options = addOptions("String_Node_Str" + selectCommand + "String_Node_Str", options);
    }
    if (dataTable.getRowGroup() != null) {
        String rowGroup = dataTable.getRowGroup();
        try {
            Integer.parseInt(rowGroup);
            options = addOptions("String_Node_Str" + rowGroup + "String_Node_Str", options);
            rowGroup = "String_Node_Str" + rowGroup + "String_Node_Str";
        } catch (NumberFormatException itsJson) {
        }
        options = addOptions(rowGroup, options);
    }
    rw.writeText(widgetVar + "String_Node_Str" + clientId + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + clientIdRaw.replace("String_Node_Str", "String_Node_Str") + "String_Node_Str" + "String_Node_Str" + widgetVar + "String_Node_Str" + "String_Node_Str" + widgetVar + "String_Node_Str" + options + "String_Node_Str", null);
    if (dataTable.isMultiColumnSearch()) {
        String filter = "String_Node_Str";
        filter += "String_Node_Str";
        filter += "String_Node_Str";
        filter += "String_Node_Str";
        rw.writeText(widgetVar + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + filter + "String_Node_Str" + "String_Node_Str", null);
        rw.writeText("String_Node_Str" + widgetVar + "String_Node_Str", null);
        rw.writeText("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", null);
        rw.writeText("String_Node_Str", null);
        int col = 0;
        for (UIComponent column : dataTable.getChildren()) {
            if (!column.isRendered()) {
                continue;
            }
            String searchValue = null;
            if ((column instanceof DataTableColumn)) {
                searchValue = ((DataTableColumn) column).getSearchValue();
            } else {
                Object sv = column.getAttributes().get("String_Node_Str");
                if (sv != null && (!"String_Node_Str".equals(sv))) {
                    searchValue = sv.toString();
                }
            }
            if (null != searchValue) {
                rw.writeText("String_Node_Str" + col + "String_Node_Str" + searchValue + "String_Node_Str", null);
                rw.writeText("String_Node_Str" + col + "String_Node_Str" + searchValue + "String_Node_Str", null);
            }
            col++;
        }
    }
    rw.writeText("String_Node_Str", null);
    rw.endElement("String_Node_Str");
}

Output:
             }
-            if (null != searchValue) {
+            if (null != searchValue && searchValue.length() > 0) {
                 rw.writeText("String_Node_Str" + col + "String_Node_Str" + searchValue + "String_Node_Str", null);


Input:
public void acceptUpload(final HTTPRequestMethod method, Socket socket) {
    debug("String_Node_Str");
    HTTPUploader uploader = null;
    try {
        int queued = -1;
        String oldFileName = "String_Node_Str";
        HTTPRequestMethod currentMethod = method;
        while (true) {
            HttpRequestLine line = parseHttpRequest(socket);
            debug("String_Node_Str");
            String fileName = line._fileName;
            if (uploader != null && uploader.getState() != Uploader.BROWSE_HOST && !oldFileName.equalsIgnoreCase(fileName)) {
                RouterService.getCallback().removeUpload(uploader);
            }
            removeFromList(uploader);
            uploader = new HTTPUploader(currentMethod, fileName, socket, line._index, uploader);
            uploader.readHeader();
            debug(uploader + "String_Node_Str");
            boolean giveSlot = (oldFileName.equalsIgnoreCase(fileName) && queued == ACCEPTED);
            if (giveSlot == false && (currentMethod == HTTPRequestMethod.HEAD)) {
                giveSlot = true;
            }
            queued = doSingleUpload(uploader, socket, socket.getInetAddress().getHostAddress(), line._index, giveSlot);
            oldFileName = fileName;
            if ((!line.isHTTP11() || uploader.getCloseConnection()) && queued != QUEUED)
                return;
            debug(uploader + "String_Node_Str");
            int oldTimeout = socket.getSoTimeout();
            if (queued != QUEUED)
                socket.setSoTimeout(SettingsManager.instance().getPersistentHTTPConnectionTimeout());
            String word = IOUtils.readWord(socket.getInputStream(), 4);
            debug(uploader + "String_Node_Str");
            socket.setSoTimeout(oldTimeout);
            if (word.equals("String_Node_Str"))
                currentMethod = HTTPRequestMethod.GET;
            else if (word.equals("String_Node_Str"))
                currentMethod = HTTPRequestMethod.HEAD;
            else
                return;
        }
    } catch (IOException ioe) {
        debug("String_Node_Str");
    } catch (ArrayIndexOutOfBoundsException ae) {
        debug("String_Node_Str");
    } finally {
        synchronized (this) {
            removeFromList(uploader);
            boolean found = false;
            for (Iterator iter = _queuedUploads.iterator(); iter.hasNext(); ) {
                KeyValue kv = (KeyValue) iter.next();
                if (kv.getKey() == socket) {
                    found = true;
                    iter.remove();
                }
            }
            if (found)
                uploader.setState(Uploader.INTERRUPTED);
        }
        if (uploader != null && (uploader.getState() != uploader.BROWSE_HOST))
            RouterService.getCallback().removeUpload(uploader);
        debug("String_Node_Str");
        close(socket);
    }
}

Output:
             String fileName = line._fileName;
-            if (uploader != null && uploader.getState() != Uploader.BROWSE_HOST && !oldFileName.equalsIgnoreCase(fileName)) {
+            if (uploader != null && shouldShowInGUI(uploader) && !oldFileName.equalsIgnoreCase(fileName)) {
                 RouterService.getCallback().removeUpload(uploader);


Input:
public void setRunAppServerType(AppServerType aValue) {
    AppServerType oldValue = getRunAppServerType();
    projectPrivateProperties.setProperty(SERVER_TYPE_KEY, aValue.getId());
    projectPrivatePropertiesIsDirty = true;
    changeSupport.firePropertyChange(SERVER_TYPE_KEY, aValue, oldValue);
}

Output:
     AppServerType oldValue = getRunAppServerType();
-    projectPrivateProperties.setProperty(SERVER_TYPE_KEY, aValue.getId());
+    if (aValue != null) {
+        projectPrivateProperties.setProperty(SERVER_TYPE_KEY, aValue.getId());
+    } else {
+        projectPrivateProperties.remove(SERVER_TYPE_KEY);
+    }
     projectPrivatePropertiesIsDirty = true;


Input:
public static void unInstall() {
    if (!ENABLE_EXTENSION_INSTALL || !OSUtil.Linux.DesktopEnv.isGnome()) {
        return;
    }
    List<String> enabledExtensions = getEnabledExtensions();
    if (enabledExtensions.contains(UID)) {
        enabledExtensions.remove(UID);
        setEnabledExtensions(enabledExtensions);
        restartShell();
    }
}

Output:
 public static void unInstall() {
-    if (!ENABLE_EXTENSION_INSTALL || !OSUtil.Linux.DesktopEnv.isGnome()) {
+    if (!ENABLE_EXTENSION_INSTALL || !OSUtil.DesktopEnv.isGnome()) {
         return;


Input:
public void ScanFile(String input, int samplimit) {
    SAMFileReader sam = new SAMFileReader(new File(input));
    sam.setValidationStringency(SAMFileReader.ValidationStringency.SILENT);
    if (!sam.hasIndex()) {
        System.out.println("String_Node_Str");
        BAMIndexer b = new BAMIndexer(new File(input + "String_Node_Str"), sam.getFileHeader());
        sam.enableFileSource(true);
        sam.iterator().forEachRemaining((s) -> {
            b.processAlignment(s);
        });
        b.finish();
        sam.close();
        System.out.println("String_Node_Str");
        sam = new SAMFileReader(new File(input));
    }
    header = sam.getFileHeader();
    if (expectRG) {
        List<SAMReadGroupRecord> temp = header.getReadGroups();
        temp.forEach((e) -> rgList.add(e.getId()));
    } else
        rgList.add("String_Node_Str");
    SAMRecordIterator itr = sam.iterator();
    while (itr.hasNext()) {
        SAMRecord s = itr.next();
        String rgid;
        if (expectRG)
            rgid = s.getReadGroup().getId();
        else
            rgid = "String_Node_Str";
        int rFlags = s.getFlags();
        if ((rFlags & 0x4) == 0x4 || (rFlags & 0x8) == 0x8 || !((rFlags & 0x1) == 0x1))
            continue;
        if (s.getInferredInsertSize() == 0)
            continue;
        if (!insertSizes.containsKey(rgid))
            insertSizes.put(rgid, new ArrayList<>(samplimit));
        if (insertSizes.get(rgid).size() >= samplimit) {
            if (checkIfSamplingDone(samplimit))
                break;
        } else {
            insertSizes.get(rgid).add(Math.abs(s.getInferredInsertSize()));
        }
    }
    itr.close();
    sam.close();
}

Output:
         temp.forEach((e) -> rgList.add(e.getId()));
-    } else
+        log.log(Level.FINE, "String_Node_Str" + StrArray.Join((ArrayList<String>) rgList, "String_Node_Str"));
+    } else {
         rgList.add("String_Node_Str");


Input:
private void disc(final SnipeData v, Location<World> targetBlock, Direction axis) {
    double brushSize = v.getBrushSize();
    double brushSizeSquared = brushSize * brushSize;
    int minx = GenericMath.floor(targetBlock.getBlockX() - brushSize);
    int maxx = GenericMath.floor(targetBlock.getBlockX() + brushSize) + 1;
    int minz = GenericMath.floor(targetBlock.getBlockZ() - brushSize);
    int maxz = GenericMath.floor(targetBlock.getBlockZ() + brushSize) + 1;
    this.undo = new Undo(GenericMath.floor(Math.PI * (brushSize + 1) * (brushSize + 1)));
    for (int x = minx; x <= maxx; x++) {
        double xs = (minx - x) * (minx - x);
        for (int z = minz; z <= maxz; z++) {
            double zs = (minz - z) * (minz - z);
            if (xs + zs < brushSizeSquared) {
                if (axis == Direction.UP) {
                    perform(v, x, targetBlock.getBlockY(), z);
                } else if (axis == Direction.NORTH) {
                    perform(v, x, z, targetBlock.getBlockZ());
                } else if (axis == Direction.EAST) {
                    perform(v, targetBlock.getBlockX(), x, z);
                }
            }
        }
    }
    v.owner().storeUndo(this.undo);
    this.undo = null;
}

Output:
     double brushSizeSquared = brushSize * brushSize;
-    int minx = GenericMath.floor(targetBlock.getBlockX() - brushSize);
-    int maxx = GenericMath.floor(targetBlock.getBlockX() + brushSize) + 1;
-    int minz = GenericMath.floor(targetBlock.getBlockZ() - brushSize);
-    int maxz = GenericMath.floor(targetBlock.getBlockZ() + brushSize) + 1;
+    int tx = targetBlock.getBlockX();
+    int ty = targetBlock.getBlockY();
+    int tz = targetBlock.getBlockZ();
     this.undo = new Undo(GenericMath.floor(Math.PI * (brushSize + 1) * (brushSize + 1)));


Input:
public void onDestroy() {
    super.onDestroy();
    if (deviceConnectionWatcher != null) {
        deviceConnectionWatcher.stop();
    }
    deviceConnectionWatcher = null;
    if (midiInputDevice != null) {
        midiInputDevice.stop();
        midiInputDevice = null;
    }
    midiOutputDevice = null;
    deviceConnection = null;
    Toast.makeText(this, "String_Node_Str", Toast.LENGTH_SHORT).show();
}

Output:
     deviceConnectionWatcher = null;
-    if (midiInputDevice != null) {
-        midiInputDevice.stop();
-        midiInputDevice = null;
-    }
+    midiInputDevice = null;
     midiOutputDevice = null;


Input:
private String getS3path(String path) {
    if (s3prefix != null) {
        if (path.isEmpty()) {
            return s3prefix;
        } else {
            return s3prefix + DELIMITER + path;
        }
    }
    return path;
}

Output:
 private String getS3path(String path) {
-    if (s3prefix != null) {
+    if (s3prefix != null && !s3prefix.isEmpty()) {
         if (path.isEmpty()) {


Input:
private void populateQueryDefn(IQueryDefinition queryDefn, Iterator paramBindingIt, Iterator filterIt, Iterator bindingIt) throws AdapterException {
    try {
        while (bindingIt != null && bindingIt.hasNext()) {
            IComputedColumn column = this.modelAdaptor.adaptComputedColumn((ComputedColumnHandle) bindingIt.next());
            IBinding binding = new Binding(column.getName(), (ScriptExpression) column.getExpression());
            binding.setDataType(column.getDataType());
            queryDefn.addBinding(binding);
        }
        List parameterBindings = convertParamterBindings(paramBindingIt);
        if (parameterBindings != null)
            queryDefn.getInputParamBindings().addAll(parameterBindings);
        List filters = convertFilters(filterIt);
        if (filters != null)
            queryDefn.getFilters().addAll(filters);
    } catch (DataException e) {
        throw new AdapterException(e.getLocalizedMessage());
    }
}

Output:
         while (bindingIt != null && bindingIt.hasNext()) {
-            IComputedColumn column = this.modelAdaptor.adaptComputedColumn((ComputedColumnHandle) bindingIt.next());
-            IBinding binding = new Binding(column.getName(), (ScriptExpression) column.getExpression());
-            binding.setDataType(column.getDataType());
-            queryDefn.addBinding(binding);
+            queryDefn.addBinding(this.modelAdaptor.adaptBinding((ComputedColumnHandle) bindingIt.next()));
         }


Input:
private static boolean hasAttributesDifferencesAndPrintThemIfAny(final String word, final String type, final ArrayList<WeightedString> list0, final ArrayList<WeightedString> list1) {
    if (null == list1) {
        if (null == list0)
            return false;
        for (final WeightedString attribute0 : list0) {
            System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute0.mWord + "String_Node_Str" + attribute0.mFrequency);
        }
        return true;
    }
    boolean hasDifferences = false;
    if (null != list0) {
        for (final WeightedString attribute0 : list0) {
            if (!list1.contains(attribute0)) {
                hasDifferences = true;
                for (final WeightedString attribute1 : list1) {
                    if (attribute0.mWord.equals(attribute1.mWord)) {
                        System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute0.mWord + "String_Node_Str" + attribute0.mFrequency + "String_Node_Str" + attribute1.mFrequency);
                        list1.remove(attribute1);
                        break;
                    }
                    System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute0.mWord);
                }
            } else {
                list1.remove(attribute0);
            }
        }
    }
    for (final WeightedString attribute1 : list1) {
        hasDifferences = true;
        System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute1.mWord + "String_Node_Str" + attribute1.mFrequency);
    }
    return hasDifferences;
}

Output:
                     }
-                    System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute0.mWord);
+                }
+                if (!foundString) {
+                    System.out.println(type + "String_Node_Str" + word + "String_Node_Str" + attribute0.mWord + "String_Node_Str" + attribute0.mFrequency);
                 }


Input:
public Resources createBaseActivityResources(IBinder activityToken, String resDir, String[] splitResDirs, String[] overlayDirs, String[] libDirs, int displayId, Configuration overrideConfig, CompatibilityInfo compatInfo, ClassLoader classLoader) {
    try {
        Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "String_Node_Str");
        final ResourcesKey key = new ResourcesKey(resDir, splitResDirs, overlayDirs, libDirs, displayId, overrideConfig != null ? new Configuration(overrideConfig) : null, compatInfo);
        classLoader = classLoader != null ? classLoader : ClassLoader.getSystemClassLoader();
        if (DEBUG) {
            Slog.d(TAG, "String_Node_Str" + activityToken + "String_Node_Str" + key);
        }
        synchronized (this) {
            final ActivityResources activityResources = getOrCreateActivityResourcesStructLocked(activityToken);
            if (overrideConfig != null) {
                activityResources.overrideConfig.setTo(overrideConfig);
            } else {
                activityResources.overrideConfig.setToDefaults();
            }
        }
        updateResourcesForActivity(activityToken, overrideConfig);
        return getOrCreateResources(activityToken, key, classLoader);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
    }
}

Output:
         synchronized (this) {
-            final ActivityResources activityResources = getOrCreateActivityResourcesStructLocked(activityToken);
-            if (overrideConfig != null) {
-                activityResources.overrideConfig.setTo(overrideConfig);
-            } else {
-                activityResources.overrideConfig.setToDefaults();
-            }
+            getOrCreateActivityResourcesStructLocked(activityToken);
         }


Input:
public void keyguardDone(boolean authenticated, boolean wakeup) {
    mKeyguardDonePending = false;
    synchronized (this) {
        EventLog.writeEvent(70000, 2);
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + authenticated + "String_Node_Str");
        Message msg = mHandler.obtainMessage(KEYGUARD_DONE, authenticated ? 1 : 0, wakeup ? 1 : 0);
        mHandler.sendMessage(msg);
    }
}

Output:
 public void keyguardDone(boolean authenticated, boolean wakeup) {
-    mKeyguardDonePending = false;
+    if (DEBUG)
+        Log.d(TAG, "String_Node_Str" + authenticated + "String_Node_Str");
+    EventLog.writeEvent(70000, 2);
     synchronized (this) {


Input:
public void postInvoke(Request request, Response response) throws IOException, ServletException {
    Context context = request.getContext();
    if (context == null) {
        ((HttpServletResponse) response.getResponse()).sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, sm.getString("String_Node_Str"));
        return;
    }
    Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());
    HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
    Manager manager = context.getManager();
    String newsessionId = null;
    if (request instanceof org.apache.catalina.connector.Request) {
        Session sess;
        try {
            sess = ((org.apache.catalina.connector.Request) request).getSessionInternal();
        } catch (Exception ex) {
            sess = null;
        }
        if (sess != null) {
            newsessionId = sess.getIdInternal();
        }
    } else {
        HttpSession hsess;
        try {
            hsess = hreq.getSession();
        } catch (Exception ex) {
            hsess = null;
        }
        if (hsess != null) {
            newsessionId = hsess.getId();
        }
    }
    log("String_Node_Str" + newsessionId);
    if (newsessionId != null) {
        if (manager instanceof PersistentManager) {
            Session session = manager.findSession(newsessionId);
            Store store = ((PersistentManager) manager).getStore();
            if (store != null && session != null && session.isValid() && !isSessionStale(session, System.currentTimeMillis())) {
                store.save(session);
                ((PersistentManager) manager).removeSuper(session);
                session.recycle();
            } else {
                log("String_Node_Str" + store + "String_Node_Str" + session + "String_Node_Str" + session.isValid() + "String_Node_Str" + isSessionStale(session, System.currentTimeMillis()));
            }
        } else {
            log("String_Node_Str" + manager);
        }
    }
}

Output:
                 session.recycle();
-            } else {
+            } else if (session != null) {
                 log("String_Node_Str" + store + "String_Node_Str" + session + "String_Node_Str" + session.isValid() + "String_Node_Str" + isSessionStale(session, System.currentTimeMillis()));


Input:
public void cellEntered(String callId) {
    logger.info(callId + "String_Node_Str" + name + "String_Node_Str" + callId);
    VoiceManager vm = AppContext.getManager(VoiceManager.class);
    Player player = vm.getPlayer(callId);
    if (player == null) {
        logger.warning("String_Node_Str" + callId);
        return;
    }
    AudioGroup audioGroup = vm.getAudioGroup(name);
    if (audioGroup == null) {
        AudioGroupSetup ags = new AudioGroupSetup();
        ags.audioGroupListener = this;
        ags.spatializer = new FullVolumeSpatializer();
        ags.spatializer.setAttenuator(DefaultSpatializer.DEFAULT_MAXIMUM_VOLUME);
        audioGroup = vm.createAudioGroup(name, ags);
    }
    audioGroup.addPlayer(player, new AudioGroupPlayerInfo(true, AudioGroupPlayerInfo.ChatType.EXCLUSIVE));
    WonderlandClientSender sender = WonderlandContext.getCommsManager().getSender(AudioManagerConnectionType.CONNECTION_TYPE);
    sender.send(new ConeOfSilenceEnterExitMessage(cellID, true));
}

Output:
     WonderlandClientSender sender = WonderlandContext.getCommsManager().getSender(AudioManagerConnectionType.CONNECTION_TYPE);
-    sender.send(new ConeOfSilenceEnterExitMessage(cellID, true));
+    sender.send(new ConeOfSilenceEnterExitMessage(callId, true));
 }


Input:
protected IViewerReportDesignHandle getDesignHandle(HttpServletRequest request) throws Exception {
    IViewerReportDesignHandle design = null;
    IReportRunnable reportRunnable = null;
    IReportDocument reportDocumentInstance = null;
    boolean isDocumentExist = ParameterAccessor.isReportParameterExist(request, ParameterAccessor.PARAM_REPORT_DOCUMENT);
    boolean isReportExist = ParameterAccessor.isReportParameterExist(request, ParameterAccessor.PARAM_REPORT);
    if (isDocumentExist && !isReportExist) {
        boolean isValidDocument = ParameterAccessor.isValidFilePath(ParameterAccessor.getParameter(request, ParameterAccessor.PARAM_REPORT_DOCUMENT));
        if (isValidDocument) {
            reportDocumentInstance = ReportEngineService.getInstance().openReportDocument(this.reportDesignName, this.reportDocumentName, this.moduleOptions);
            if (reportDocumentInstance != null) {
                reportRunnable = reportDocumentInstance.getReportRunnable();
            } else {
                throw new ViewerException(ResourceConstants.GENERAL_EXCEPTION_DOCUMENT_FILE_ERROR, new String[] { this.reportDocumentName });
            }
        } else {
            throw new ViewerException(ResourceConstants.GENERAL_EXCEPTION_DOCUMENT_ACCESS_ERROR, new String[] { this.reportDocumentName });
        }
    } else if (isReportExist) {
        if (isDocumentExist && !ParameterAccessor.isValidFilePath(ParameterAccessor.getParameter(request, ParameterAccessor.PARAM_REPORT_DOCUMENT))) {
            throw new ViewerException(ResourceConstants.GENERAL_EXCEPTION_DOCUMENT_ACCESS_ERROR, new String[] { this.reportDocumentName });
        }
        reportDocumentInstance = ReportEngineService.getInstance().openReportDocument(this.reportDesignName, this.reportDocumentName, this.moduleOptions);
        if (ParameterAccessor.isValidFilePath(ParameterAccessor.getParameter(request, ParameterAccessor.PARAM_REPORT))) {
            try {
                reportRunnable = BirtUtility.getRunnableFromDesignFile(request, this.reportDesignName, this.moduleOptions);
                if (reportRunnable == null) {
                    throw new ViewerException(ResourceConstants.GENERAL_EXCEPTION_REPORT_FILE_ERROR, new String[] { this.reportDesignName });
                }
            } catch (EngineException e) {
                this.exception = e;
            }
        }
    }
    if (reportDocumentInstance != null) {
        this.documentInUrl = true;
        this.parameterMap = reportDocumentInstance.getParameterValues();
        if (!reportDocumentInstance.isComplete() && isReportExist)
            this.isDocumentProcessing = true;
        reportDocumentInstance.close();
    }
    if (reportRunnable != null) {
        design = new BirtViewerReportDesignHandle(IViewerReportDesignHandle.RPT_RUNNABLE_OBJECT, reportRunnable);
    }
    return design;
}

Output:
         if (isValidDocument) {
-            reportDocumentInstance = ReportEngineService.getInstance().openReportDocument(this.reportDesignName, this.reportDocumentName, this.moduleOptions);
+            try {
+                reportDocumentInstance = ReportEngineService.getInstance().openReportDocument(this.reportDesignName, this.reportDocumentName, this.moduleOptions);
+            } catch (Exception e) {
+            }
             if (reportDocumentInstance != null) {


Input:
public int getMinHeightPlusMargin() {
    return (int) ((getOriginalHeight() / getYScaleFactor()) + getMarginBottom());
}

Output:
 public int getMinHeightPlusMargin() {
-    return (int) ((getOriginalHeight() / getYScaleFactor()) + getMarginBottom());
+    return (int) (getOriginalHeight() * (1 - 1 / getYScaleFactor()) + getMarginBottom());
 }


Input:
public boolean onEventPreview(Event event) {
    Element target = DOM.eventGetTarget(event);
    boolean eventTargetsPopup = DOM.isOrHasChild(getElement(), target);
    int type = DOM.eventGetType(event);
    switch(type) {
        case Event.ONKEYDOWN:
            {
                return onKeyDownPreview((char) DOM.eventGetKeyCode(event), KeyboardListenerCollection.getKeyboardModifiers(event));
            }
        case Event.ONKEYUP:
            {
                return onKeyUpPreview((char) DOM.eventGetKeyCode(event), KeyboardListenerCollection.getKeyboardModifiers(event));
            }
        case Event.ONKEYPRESS:
            {
                return onKeyPressPreview((char) DOM.eventGetKeyCode(event), KeyboardListenerCollection.getKeyboardModifiers(event));
            }
        case Event.ONMOUSEDOWN:
        case Event.ONMOUSEUP:
        case Event.ONMOUSEMOVE:
        case Event.ONCLICK:
        case Event.ONDBLCLICK:
            {
                if (DOM.getCaptureElement() != null) {
                    return true;
                }
                if (!eventTargetsPopup && autoHide && (type == Event.ONCLICK)) {
                    hide(true);
                    return true;
                }
                break;
            }
        case Event.ONFOCUS:
            {
                if (modal && !eventTargetsPopup && (target != null)) {
                    blur(target);
                    return false;
                }
            }
    }
    return !modal || (modal && eventTargetsPopup);
}

Output:
                 }
-                if (!eventTargetsPopup && autoHide && (type == Event.ONCLICK)) {
+                if (!eventTargetsPopup && autoHide && (type == Event.ONMOUSEDOWN)) {
                     hide(true);


Input:
public synchronized String format(long value) {
    long date = value / 1000000;
    long sec = value / 1000000000;
    long ms = Math.abs(value) % 1000000000 / 1000000;
    long cs = Math.abs(value) % 1000000 / 1000;
    long ns = Math.abs(value) % 1000;
    if (value < 0 && ms + cs + ns > 0 && !fPattern.contains("String_Node_Str")) {
        date -= 1;
        long nanosec = 1000000000 - (1000000 * ms + 1000 * cs + ns);
        ms = nanosec / 1000000;
        cs = nanosec % 1000000 / 1000;
        ns = nanosec % 1000;
    }
    StringBuffer result = new StringBuffer(super.format(date));
    int loc = result.indexOf(fCloseBracket + "String_Node_Str" + fOpenBracket);
    while (loc != -1) {
        result.deleteCharAt(loc + fCloseBracket.length());
        loc = result.indexOf(fCloseBracket + "String_Node_Str" + fOpenBracket);
    }
    for (String pattern : fSupplPatterns) {
        int length = pattern.length();
        StringBuffer fmt = new StringBuffer(length);
        for (int i = 0; i < length; i++) {
            fmt.append("String_Node_Str");
        }
        DecimalFormat dfmt = new DecimalFormat(fmt.toString());
        String fmtVal = "String_Node_Str";
        switch(pattern.charAt(0)) {
            case 'T':
                if (value < 0 && sec == 0) {
                    result.insert(0, '-');
                }
                fmtVal = dfmt.format(sec);
                break;
            case 'S':
                fmtVal = dfmt.format(ms);
                break;
            case 'C':
                fmtVal = dfmt.format(cs);
                break;
            case 'N':
                fmtVal = dfmt.format(ns);
                break;
            default:
                break;
        }
        String ph = new StringBuffer(fOpenBracket + pattern + fCloseBracket).toString();
        loc = result.indexOf(ph);
        result.replace(loc, loc + length + fOpenBracket.length() + fCloseBracket.length(), fmtVal);
    }
    return result.toString();
}

Output:
     long sec = value / 1000000000;
-    long ms = Math.abs(value) % 1000000000 / 1000000;
-    long cs = Math.abs(value) % 1000000 / 1000;
-    long ns = Math.abs(value) % 1000;
-    if (value < 0 && ms + cs + ns > 0 && !fPattern.contains("String_Node_Str")) {
+    long ms = Math.abs((value % 1000000000) / 1000000);
+    long cs = Math.abs((value % 1000000) / 1000);
+    long ns = Math.abs(value % 1000);
+    if (value < 0 && ms + cs + ns > 0 && !super.toPattern().contains(fOpenBracket + "String_Node_Str")) {
         date -= 1;


Input:
protected void doFlush() {
    GL11.glNewList(displayList, GL11.GL_COMPILE);
    FloatBuffer vBuffer = BufferUtils.createFloatBuffer(vertexBuffer.size());
    vBuffer.clear();
    vBuffer.put(vertexBuffer.toArray());
    vBuffer.flip();
    GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
    GL11.glVertexPointer(4, 0, vBuffer);
    if (useNormals) {
        vBuffer.clear();
        vBuffer.put(normalBuffer.toArray());
        vBuffer.flip();
        GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY);
        GL11.glNormalPointer(0, vBuffer);
    }
    if (useTextures) {
        vBuffer.clear();
        vBuffer.put(uvBuffer.toArray());
        vBuffer.flip();
        GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
        GL11.glTexCoordPointer(2, 0, vBuffer);
    }
    GL11.glDrawArrays(renderMode, 0, numVertices);
    GL11.glEndList();
}

Output:
     if (useTextures) {
-        vBuffer.clear();
-        vBuffer.put(uvBuffer.toArray());
-        vBuffer.flip();
+        FloatBuffer temp = BufferUtils.createFloatBuffer(uvBuffer.size());
+        temp.put(uvBuffer.toArray());
+        temp.flip();
         GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);


Input:
public void die(boolean immediate) {
    checkThread();
    if (Config.LOGV)
        Log.v("String_Node_Str", "String_Node_Str" + this + "String_Node_Str" + mSurface);
    synchronized (this) {
        if (mAdded && !mFirst) {
            int viewVisibility = mView.getVisibility();
            boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
            if (mWindowAttributesChanged || viewVisibilityChanged) {
                try {
                    if ((relayoutWindow(mWindowAttributes, viewVisibility, false) & WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0) {
                        sWindowSession.finishDrawing(mWindow);
                    }
                } catch (RemoteException e) {
                }
            }
            mSurface.release();
        }
        if (mAdded) {
            mAdded = false;
            if (immediate) {
                dispatchDetachedFromWindow();
            } else if (mView != null) {
                sendEmptyMessage(DIE);
            }
        }
    }
}

Output:
 public void die(boolean immediate) {
-    checkThread();
-    if (Config.LOGV)
-        Log.v("String_Node_Str", "String_Node_Str" + this + "String_Node_Str" + mSurface);
-    synchronized (this) {
-        if (mAdded && !mFirst) {
-            int viewVisibility = mView.getVisibility();
-            boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
-            if (mWindowAttributesChanged || viewVisibilityChanged) {
-                try {
-                    if ((relayoutWindow(mWindowAttributes, viewVisibility, false) & WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0) {
-                        sWindowSession.finishDrawing(mWindow);
-                    }
-                } catch (RemoteException e) {
-                }
-            }
-            mSurface.release();
-        }
-        if (mAdded) {
-            mAdded = false;
-            if (immediate) {
-                dispatchDetachedFromWindow();
-            } else if (mView != null) {
-                sendEmptyMessage(DIE);
-            }
-        }
+    if (immediate) {
+        doDie();
+    } else {
+        sendEmptyMessage(DIE);
     }


Input:
private void doHandShaking(final SelectionKey key, SocketChannel socketChannel) throws IOException, InterruptedException {
    final Attached attached = (Attached) key.attachment();
    final TcpSocketChannelEntryWriter writer = attached.entryWriter;
    final TcpSocketChannelEntryReader reader = attached.entryReader;
    if (attached.remoteIdentifier == Byte.MIN_VALUE) {
        final byte remoteIdentifier = reader.identifierFromBuffer();
        if (remoteIdentifier == Byte.MIN_VALUE)
            return;
        attached.remoteIdentifier = remoteIdentifier;
        selectionKeysStore[remoteIdentifier] = key;
        activeKeys.set(remoteIdentifier);
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str", localIdentifier, remoteIdentifier);
        }
        final IdentifierListener identifierListener = replicationConfig.identifierListener;
        final SocketAddress remoteAddress = socketChannel.getRemoteAddress();
        boolean identifierIsUnique;
        if (identifierListener != null) {
            identifierIsUnique = identifierListener.isIdentifierUnique(remoteIdentifier, remoteAddress);
        } else {
            identifierIsUnique = remoteIdentifier != localIdentifier;
        }
        if (identifierIsUnique) {
            throw new IllegalStateException("String_Node_Str" + "String_Node_Str" + remoteIdentifier);
        }
        attached.remoteModificationIterator = replica.acquireModificationIterator(remoteIdentifier, attached);
        writer.writeRemoteBootstrapTimestamp(replica.lastModificationTime(remoteIdentifier));
        writer.writeRemoteHeartbeatInterval(heartBeatIntervalMillis);
    }
    if (attached.remoteBootstrapTimestamp == Long.MIN_VALUE) {
        attached.remoteBootstrapTimestamp = reader.remoteBootstrapTimestamp();
        if (attached.remoteBootstrapTimestamp == Long.MIN_VALUE)
            return;
    }
    if (!attached.hasRemoteHeartbeatInterval) {
        long value = reader.remoteHeartbeatIntervalFromBuffer();
        if (value == Long.MIN_VALUE)
            return;
        if (value < 0) {
            LOG.error("String_Node_Str" + value);
        }
        attached.remoteHeartbeatInterval = (long) (value * 1.25);
        selectorTimeout = Math.min(selectorTimeout, value);
        if (selectorTimeout < 0)
            LOG.info("String_Node_Str");
        attached.hasRemoteHeartbeatInterval = true;
        attached.handShakingComplete = true;
        attached.remoteModificationIterator.dirtyEntries(attached.remoteBootstrapTimestamp);
        reader.entriesFromBuffer();
    }
}

Output:
         final SocketAddress remoteAddress = socketChannel.getRemoteAddress();
-        boolean identifierIsUnique;
-        if (identifierListener != null) {
-            identifierIsUnique = identifierListener.isIdentifierUnique(remoteIdentifier, remoteAddress);
-        } else {
-            identifierIsUnique = remoteIdentifier != localIdentifier;
-        }
-        if (identifierIsUnique) {
+        if ((identifierListener != null && !identifierListener.isIdentifierUnique(remoteIdentifier, remoteAddress)) || remoteIdentifier == localIdentifier)
             throw new IllegalStateException("String_Node_Str" + "String_Node_Str" + remoteIdentifier);


Input:
public boolean calculateCooccurrences(List<String> selectedFiles, String seedFile, int windowSize, String outputPath, int threshold, boolean buildMatrix, IProgressMonitor monitor) {
    String currentLine = null;
    Queue<String> q = new LinkedList<String>();
    List<String> phrase = new ArrayList<String>();
    setOutputPath(outputPath);
    try {
        boolean ret = false;
        if (windowSize > 0) {
            ret = setSeedWords(seedFile);
        }
        if (ret) {
            doPhrases = true;
        }
        File[] listOfFiles = (File[]) selectedFiles.toArray(new File[selectedFiles.size()]);
        int seedWordCount = seedWords.size();
        int count;
        for (File f : listOfFiles) {
            monitor.subTask("String_Node_Str" + f.getName());
            appendLog("String_Node_Str" + f.getName());
            count = 0;
            if (f.getAbsolutePath().contains("String_Node_Str"))
                continue;
            List<String> words = new ArrayList<String>();
            if (!f.exists() || f.isDirectory())
                continue;
            BufferedReader br = new BufferedReader(new FileReader(f));
            int line_no = 0;
            while ((currentLine = br.readLine()) != null) {
                if (currentLine.isEmpty() || currentLine.equals("String_Node_Str"))
                    continue;
                line_no++;
                for (String word : currentLine.split("String_Node_Str")) {
                    if (word.isEmpty() || word.equals("String_Node_Str"))
                        continue;
                    word.replaceAll(delimiters, "String_Node_Str");
                    if (buildMatrix)
                        words.add(word);
                    if (doPhrases) {
                        if (count >= threshold || count >= seedWordCount) {
                            StringBuilder match = new StringBuilder();
                            for (String str : q) {
                                if (seedWords.containsKey(str))
                                    match.append('*');
                                match.append(str + ' ');
                            }
                            phrase.add(f.getName() + "String_Node_Str" + line_no + "String_Node_Str" + match.toString());
                            q.clear();
                            count = 0;
                            for (String s : seedWords.keySet()) {
                                seedWords.put(s, 1);
                            }
                        } else if (q.size() >= windowSize) {
                            String first = q.remove();
                            if (seedWords.containsKey(first)) {
                                if (seedWords.get(first) == 0) {
                                    count--;
                                    seedWords.put(first, 1);
                                }
                            }
                        }
                        q.add(word);
                        if (seedWords.containsKey(word)) {
                            if (seedWords.get(word) != 0) {
                                count++;
                                seedWords.put(word, 0);
                            }
                        }
                    }
                    if (buildMatrix) {
                        Map<String, Integer> vec = null;
                        if (wordMat.containsKey(word)) {
                            vec = wordMat.get(word);
                        } else {
                            vec = new HashMap<String, Integer>();
                            wordMat.put(word, vec);
                        }
                        for (String second : words) {
                            if (vec.containsKey(second)) {
                                vec.put(second, vec.get(second) + 1);
                            } else {
                                vec.put(second, 1);
                            }
                            Map<String, Integer> temp = wordMat.get(second);
                            if (temp.containsKey(word)) {
                                temp.put(word, temp.get(word) + 1);
                            } else {
                                temp.put(word, 1);
                            }
                        }
                    }
                }
            }
            br.close();
            monitor.worked(1);
        }
        if (buildMatrix) {
            monitor.subTask("String_Node_Str");
            writeWordMatrix();
        }
        monitor.worked(10);
        if (ret && phrase.size() > 0) {
            monitor.subTask("String_Node_Str");
            writePhrases(phrase);
        }
        monitor.worked(10);
        ConsoleView.printlInConsoleln(String.valueOf(phrase.size()));
        Date dateObj = new Date();
        TacitUtility.createRunReport(outputPath, "String_Node_Str", dateObj);
        return true;
    } catch (Exception e) {
        ConsoleView.printlInConsoleln("String_Node_Str" + e);
    }
    return false;
}

Output:
         }
-        File[] listOfFiles = (File[]) selectedFiles.toArray(new File[selectedFiles.size()]);
+        String[] listOfFiles = (String[]) selectedFiles.toArray(new String[selectedFiles.size()]);
         int seedWordCount = seedWords.size();


Input:
public void save(Project project) {
    ProjectInformation info = project.getLookup().lookup(ProjectInformation.class);
    if (info != null) {
        if (!titleTextField.getText().isEmpty() && !titleTextField.getText().equals(info.getName())) {
            ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);
            pc.renameProject(project, titleTextField.getText());
        }
    }
    ProjectMetaData metaData = project.getLookup().lookup(ProjectMetaData.class);
    if (metaData != null) {
        metaData.setTitle(nameTextField.getText());
        metaData.setAuthor(authorTextField.getText());
        metaData.setKeywords(keywordsTextField.getText());
        metaData.setDescription(descriptionTextArea.getText());
    }
}

Output:
     if (info != null) {
-        if (!titleTextField.getText().isEmpty() && !titleTextField.getText().equals(info.getName())) {
+        if (!nameTextField.getText().isEmpty() && !nameTextField.getText().equals(info.getName())) {
             ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);


Input:
public <T> T get(Class<T> clazz, IPentahoSession session, Map<String, String> properties) throws ObjectFactoryException {
    IPentahoObjectReference<T> highestRef = this.getObjectReference(clazz, session, properties);
    if (highestRef == null) {
        String msg = Messages.getInstance().getString("String_Node_Str", clazz.getSimpleName());
        throw new ObjectFactoryException(msg);
    }
    return highestRef.getObject();
}

Output:
     IPentahoObjectReference<T> highestRef = this.getObjectReference(clazz, session, properties);
-    if (highestRef == null) {
-        String msg = Messages.getInstance().getString("String_Node_Str", clazz.getSimpleName());
-        throw new ObjectFactoryException(msg);
+    if (highestRef != null) {
+        return highestRef.getObject();
     }