Input:
public Cursor query(Uri url, String[] projectionIn, String selection, String[] selectionArgs, String sortOrder) throws IllegalStateException {
    SQLiteDatabase db = mOpenHelper.getReadableDatabase();
    int match = URI_MATCHER.match(url);
    if (match == -1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (match == URI_MATCH_SUGGEST || match == URI_MATCH_BOOKMARKS_SUGGEST) {
        String suggestSelection;
        String[] myArgs;
        if (selectionArgs[0] == null || selectionArgs[0].equals("String_Node_Str")) {
            suggestSelection = null;
            myArgs = null;
        } else {
            String like = selectionArgs[0] + "String_Node_Str";
            if (selectionArgs[0].startsWith("String_Node_Str") || selectionArgs[0].startsWith("String_Node_Str")) {
                myArgs = new String[1];
                myArgs[0] = like;
                suggestSelection = selection;
            } else {
                SUGGEST_ARGS[0] = "String_Node_Str" + like;
                SUGGEST_ARGS[1] = "String_Node_Str" + like;
                SUGGEST_ARGS[2] = "String_Node_Str" + like;
                SUGGEST_ARGS[3] = "String_Node_Str" + like;
                myArgs = SUGGEST_ARGS;
                suggestSelection = SUGGEST_SELECTION;
            }
        }
        Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS], SUGGEST_PROJECTION, suggestSelection, myArgs, null, null, ORDER_BY, (new Integer(MAX_SUGGESTION_LONG_ENTRIES)).toString());
        if (match == URI_MATCH_BOOKMARKS_SUGGEST || Regex.WEB_URL_PATTERN.matcher(selectionArgs[0]).matches()) {
            return new MySuggestionCursor(c, null, "String_Node_Str");
        } else {
            if (myArgs != null && myArgs.length > 1 && c.getCount() < (MAX_SUGGESTION_SHORT_ENTRIES - 1)) {
                ComponentName googleSearchComponent = new ComponentName("String_Node_Str", "String_Node_Str");
                SearchableInfo si = SearchManager.getSearchableInfo(googleSearchComponent, false);
                Cursor sc = SearchManager.getSuggestions(getContext(), si, selectionArgs[0]);
                return new MySuggestionCursor(c, sc, selectionArgs[0]);
            }
            return new MySuggestionCursor(c, null, selectionArgs[0]);
        }
    }
    String[] projection = null;
    if (projectionIn != null && projectionIn.length > 0) {
        projection = new String[projectionIn.length + 1];
        System.arraycopy(projectionIn, 0, projection, 0, projectionIn.length);
        projection[projectionIn.length] = "String_Node_Str";
    }
    StringBuilder whereClause = new StringBuilder(256);
    if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) {
        whereClause.append("String_Node_Str").append(url.getPathSegments().get(1)).append("String_Node_Str");
    }
    if (selection != null && selection.length() > 0) {
        if (whereClause.length() > 0) {
            whereClause.append("String_Node_Str");
        }
        whereClause.append('(');
        whereClause.append(selection);
        whereClause.append(')');
    }
    Cursor c = db.query(TABLE_NAMES[match % 10], projection, whereClause.toString(), selectionArgs, null, null, sortOrder, null);
    c.setNotificationUri(getContext().getContentResolver(), url);
    return c;
}

Output:
         }
-        Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS], SUGGEST_PROJECTION, suggestSelection, myArgs, null, null, ORDER_BY, (new Integer(MAX_SUGGESTION_LONG_ENTRIES)).toString());
+        Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS], SUGGEST_PROJECTION, suggestSelection, myArgs, null, null, ORDER_BY, MAX_SUGGESTION_LONG_ENTRIES_STRING);
         if (match == URI_MATCH_BOOKMARKS_SUGGEST || Regex.WEB_URL_PATTERN.matcher(selectionArgs[0]).matches()) {


Input:
public static CacheEventContext createCacheRemovedEvent(Data dataKey) {
    return createCacheRemovedEvent(dataKey, null, CacheRecord.EXPIRATION_TIME_NOT_AVAILABLE, null, MutableOperation.IGNORE_COMPLETION);
}

Output:
 public static CacheEventContext createCacheRemovedEvent(Data dataKey) {
-    return createCacheRemovedEvent(dataKey, null, CacheRecord.EXPIRATION_TIME_NOT_AVAILABLE, null, MutableOperation.IGNORE_COMPLETION);
+    return createCacheRemovedEvent(dataKey, null, CacheRecord.TIME_NOT_AVAILABLE, null, MutableOperation.IGNORE_COMPLETION);
 }


Input:
public static boolean selectAny(String query, Object... args) {
    Connection c = DBConnect.getDBConnection();
    PreparedStatement s = null;
    try {
        s = prepareStatement(c, query, args);
        return s.executeQuery().next();
    } catch (SQLException e) {
        throw new IOFailure("String_Node_Str" + query + "String_Node_Str" + args, e);
    } finally {
        closeStatementIfOpen(s);
    }
}

Output:
     } catch (SQLException e) {
-        throw new IOFailure("String_Node_Str" + query + "String_Node_Str" + args, e);
+        throw new IOFailure("String_Node_Str" + query + "String_Node_Str" + args + "String_Node_Str" + ExceptionUtils.getSQLExceptionCause(e), e);
     } finally {


Input:
public Set<User> execute() throws UserException, BimserverLockConflictException, BimserverDatabaseException {
    User actingUser = getUserByUoid(authorization.getUoid());
    Condition condition = new IsOfTypeCondition(StorePackage.eINSTANCE.getUser());
    condition = condition.and(new Not(new AttributeCondition(StorePackage.eINSTANCE.getUser_UserType(), new EnumLiteral(UserType.SYSTEM))));
    if (actingUser.getUserType() != UserType.ADMIN) {
        condition = condition.and(new AttributeCondition(StorePackage.eINSTANCE.getUser_State(), new EnumLiteral(ObjectState.ACTIVE)));
    }
    return CollectionUtils.mapToSet((Map<Long, User>) getDatabaseSession().query(condition, User.class, Query.getDefault()));
}

Output:
     }
-    return CollectionUtils.mapToSet((Map<Long, User>) getDatabaseSession().query(condition, User.class, Query.getDefault()));
+    return CollectionUtils.mapToSet(getDatabaseSession().query(condition, User.class, Query.getDefault()));
 }


Input:
public void inject2Instance(Object object, String key) {
    DisconfCenterItem disconfCenterItem = DisconfCenterStore.getInstance().getConfItemMap().get(key);
    if (disconfCenterItem == null) {
        LOGGER.error("String_Node_Str" + key + "String_Node_Str");
        return;
    }
    if (object != null) {
        disconfCenterItem.setObject(object);
    }
    try {
        if (object != null) {
            Object defaultValue = disconfCenterItem.getField().get(object);
            LOGGER.debug(disconfCenterItem.getKey() + "String_Node_Str");
            if (disconfCenterItem.getValue() == null) {
                disconfCenterItem.getField().set(object, defaultValue);
                disconfCenterItem.setValue(defaultValue);
            } else {
                disconfCenterItem.getField().set(object, disconfCenterItem.getValue());
            }
        } else {
            if (Modifier.isStatic(disconfCenterItem.getField().getModifiers())) {
                LOGGER.debug(disconfCenterItem.getKey() + "String_Node_Str");
                disconfCenterItem.getField().set(null, disconfCenterItem.getValue());
            }
        }
    } catch (Exception e) {
        LOGGER.error(e.toString(), e);
        return;
    }
}

Output:
     } catch (Exception e) {
-        LOGGER.error(e.toString(), e);
+        LOGGER.error("String_Node_Str" + key + "String_Node_Str" + e.toString(), e);
         return;


Input:
public final ReferenceBinding getGroovyLangMetaClassBinding() {
    CompilationUnitScope unitScope = compilationUnitScope();
    unitScope.recordQualifiedReference(GROOVY_LANG_METACLASS);
    return unitScope.environment.getResolvedType(GROOVY_LANG_METACLASS, this);
}

Output:
     CompilationUnitScope unitScope = compilationUnitScope();
-    unitScope.recordQualifiedReference(GROOVY_LANG_METACLASS);
-    return unitScope.environment.getResolvedType(GROOVY_LANG_METACLASS, this);
+    unitScope.recordQualifiedReference(GroovyCompilationUnitScope.GROOVY_LANG_METACLASS);
+    return unitScope.environment.getResolvedType(GroovyCompilationUnitScope.GROOVY_LANG_METACLASS, this);
 }


Input:
public void selectAttackers(Game game, UUID attackingPlayerId) {
    updateGameStatePriority("String_Node_Str", game);
    FilterCreatureForCombat filter = filterCreatureForCombat.copy();
    filter.add(new ControllerIdPredicate(attackingPlayerId));
    while (!abort) {
        if (passedAllTurns || passedTurn) {
            return;
        }
        game.fireSelectEvent(playerId, "String_Node_Str");
        waitForResponse();
        if (response.getBoolean() != null) {
            return;
        } else if (response.getInteger() != null) {
            if (response.getInteger() == -9999) {
                passedAllTurns = true;
            }
            passedTurn = true;
            return;
        } else if (response.getUUID() != null) {
            Permanent attacker = game.getPermanent(response.getUUID());
            if (attacker != null) {
                if (filterCreatureForCombat.match(attacker, null, playerId, game)) {
                    selectDefender(game.getCombat().getDefenders(), attacker.getId(), game);
                } else if (filterAttack.match(attacker, null, playerId, game) && game.getStack().isEmpty()) {
                    game.getCombat().removeAttacker(attacker.getId(), game);
                }
            }
        }
    }
}

Output:
                 } else if (filterAttack.match(attacker, null, playerId, game) && game.getStack().isEmpty()) {
-                    game.getCombat().removeAttacker(attacker.getId(), game);
+                    removeAttackerIfPossible(game, attacker);
                 }


Input:
public void run() {
    if (Policy.TRACING_ACTIONS) {
        System.out.println("String_Node_Str");
    }
    diagramViewer.setProperty(DeferredGraphicalViewer.PROPERTY_MARGIN_VISIBILITY, new Boolean(!isChecked()));
}

Output:
     }
-    diagramViewer.setProperty(DeferredGraphicalViewer.PROPERTY_MARGIN_VISIBILITY, new Boolean(!isChecked()));
+    diagramViewer.setProperty(DeferredGraphicalViewer.PROPERTY_MARGIN_VISIBILITY, Boolean.valueOf(!isChecked()));
 }


Input:
public void addRandom(int x, int y) {
    int type;
    if (y < this.board.getBoardHeight() - 1) {
        type = this.getRandomBlockType();
        while (this.board.getBlockAt(x, y + 1) != null && this.board.getBlockAt(x, y + 1).getType() == type) {
            type = this.getRandomBlockType();
        }
    } else {
        type = this.getRandomBlockType();
    }
    this.createBlock(x, y, type);
}

Output:
     int type;
-    if (y < this.board.getBoardHeight() - 1) {
+    if (y < this.board.getBoardHeight() * 2 - 1) {
         type = this.getRandomBlockType();


Input:
private static String replaceArguments(String data, Bindings bindings) throws ProcedureException {
    String[] names = bindings.getNames();
    Object value;
    for (int i = 0; i < names.length; i++) {
        if (bindings.getType(names[i]) == Bindings.ARGUMENT) {
            value = bindings.getValue(names[i], null);
            if (value == null) {
                value = "String_Node_Str";
            }
            data = data.replaceAll("String_Node_Str" + names[i], value.toString());
        }
    }
    return data;
}

Output:
             }
-            data = data.replaceAll("String_Node_Str" + names[i], value.toString());
+            data = StringUtils.replace(data, "String_Node_Str" + names[i], value.toString());
         }


Input:
public void success(T t, Response<T> response) {
    if (null != mEventDescription) {
        Log.d(LOG_TAG, "String_Node_Str" + mEventDescription + "String_Node_Str");
    }
    try {
        onEventSent();
        if (null != mApiCallback) {
            try {
                mApiCallback.onSuccess(t);
            } catch (Exception e) {
                Log.d(LOG_TAG, "String_Node_Str" + e.getMessage());
            }
        }
    } catch (Exception e) {
        Log.e(LOG_TAG, "String_Node_Str" + e.getMessage());
    }
}

Output:
             } catch (Exception e) {
-                Log.d(LOG_TAG, "String_Node_Str" + e.getMessage());
+                Log.e(LOG_TAG, "String_Node_Str" + e.getMessage());
+                mApiCallback.onUnexpectedError(e);
             }


Input:
public DebugInformation getDebugInformation() {
    DebugInformation info = new DebugInformation();
    info.add("String_Node_Str", this.currentGoal);
    return info;
}

Output:
     DebugInformation info = new DebugInformation();
-    info.add("String_Node_Str", this.currentGoal);
+    info.add("String_Node_Str", this.currentGoal.getAction(0));
     return info;


Input:
public static void branchExecuted(int fileIndex, int line, int branchIndex) {
    if (terminated)
        return;
    CoverageData coverageData = CoverageData.instance();
    PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
    CallPoint callPoint = null;
    if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line, branchIndex)) {
        callPoint = CallPoint.create(new Throwable());
    }
    fileData.registerExecution(line, branchIndex, callPoint);
}

Output:
         return;
-    CoverageData coverageData = CoverageData.instance();
-    PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
-    CallPoint callPoint = null;
-    if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line, branchIndex)) {
-        callPoint = CallPoint.create(new Throwable());
+    synchronized (TestRun.class) {
+        CoverageData coverageData = CoverageData.instance();
+        PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
+        CallPoint callPoint = null;
+        if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line, branchIndex)) {
+            callPoint = CallPoint.create(new Throwable());
+        }
+        fileData.registerExecution(line, branchIndex, callPoint);
     }


Input:
void ensureColumnExist(String schema, String table, ImmutablePair<String, PropertyType> keyValue) {
    final Map<String, PropertyType> cachedColumns = this.tables.get(schema + "String_Node_Str" + table);
    final Map<String, PropertyType> uncommitedColumns;
    if (cachedColumns == null) {
        uncommitedColumns = this.uncommittedTables.get(schema + "String_Node_Str" + table);
    } else {
        uncommitedColumns = cachedColumns;
    }
    Objects.requireNonNull(uncommitedColumns, "String_Node_Str");
    if (!uncommitedColumns.containsKey(keyValue.left)) {
        if (!this.schemaLock.isHeldByCurrentThread()) {
            this.schemaLock.lock();
        }
        if (!uncommitedColumns.containsKey(keyValue.left)) {
            addColumn(schema, table, keyValue);
            uncommitedColumns.put(keyValue.left, keyValue.right);
            this.uncommittedTables.put(schema + "String_Node_Str" + table, uncommitedColumns);
        }
    }
}

Output:
     final Map<String, PropertyType> cachedColumns = this.tables.get(schema + "String_Node_Str" + table);
-    final Map<String, PropertyType> uncommitedColumns;
+    Map<String, PropertyType> uncommitedColumns;
     if (cachedColumns == null) {


Input:
public static VirtualDevice prepareDiskDevice(VirtualMachineMO vmMo, int controllerKey, Pair<String, ManagedObjectReference>[] vmdkDatastorePathChain, int deviceNumber, int contextNumber) throws Exception {
    assert (vmdkDatastorePathChain != null);
    assert (vmdkDatastorePathChain.length >= 1);
    VirtualDisk disk = new VirtualDisk();
    VirtualDiskFlatVer2BackingInfo backingInfo = new VirtualDiskFlatVer2BackingInfo();
    backingInfo.setDatastore(vmdkDatastorePathChain[0].second());
    backingInfo.setFileName(vmdkDatastorePathChain[0].first());
    backingInfo.setDiskMode(VirtualDiskMode.PERSISTENT.toString());
    if (vmdkDatastorePathChain.length > 1) {
        Pair<String, ManagedObjectReference>[] parentDisks = new Pair[vmdkDatastorePathChain.length - 1];
        for (int i = 0; i < vmdkDatastorePathChain.length - 1; i++) parentDisks[i] = vmdkDatastorePathChain[i + 1];
        setParentBackingInfo(backingInfo, parentDisks);
    }
    disk.setBacking(backingInfo);
    if (controllerKey < 0)
        controllerKey = vmMo.getIDEDeviceControllerKey();
    if (deviceNumber < 0)
        deviceNumber = vmMo.getNextDeviceNumber(controllerKey);
    disk.setControllerKey(controllerKey);
    disk.setKey(-contextNumber);
    disk.setUnitNumber(deviceNumber);
    VirtualDeviceConnectInfo connectInfo = new VirtualDeviceConnectInfo();
    connectInfo.setConnected(true);
    connectInfo.setStartConnected(true);
    disk.setConnectable(connectInfo);
    return disk;
}

Output:
     backingInfo.setFileName(vmdkDatastorePathChain[0].first());
-    backingInfo.setDiskMode(VirtualDiskMode.PERSISTENT.toString());
+    backingInfo.setDiskMode(VirtualDiskMode.PERSISTENT.value());
     if (vmdkDatastorePathChain.length > 1) {


Input:
private void checkState() {
    if (this.properties.getBoolean(KARAKU_JPA_ENABLED, true)) {
        this.enabled = true;
    } else {
        log.info("String_Node_Str");
        this.enabled = false;
        log.info("String_Node_Str");
        this.liquibase = false;
        return;
    }
    if (this.properties.getBoolean("String_Node_Str", true)) {
        this.liquibase = true;
    } else {
        log.info("String_Node_Str");
        this.liquibase = false;
    }
}

Output:
     } else {
-        log.info("String_Node_Str");
+        LOG.info("String_Node_Str");
         this.enabled = false;


Input:
public boolean equals(Object obj) {
    Role other = (Role) obj;
    if (other == null) {
        return false;
    }
    if (compareValues(getName(), other.getName()) && compareValues(getRoleid(), other.getRoleid()) && compareValues(getDescription(), other.getDescription())) {
        return true;
    }
    return false;
}

Output:
 public boolean equals(Object obj) {
-    Role other = (Role) obj;
-    if (other == null) {
+    if (this == obj) {
+        return true;
+    }
+    if (obj == null || getClass() != obj.getClass()) {
         return false;


Input:
public int size() {
    return count;
}

Output:
 public int size() {
-    return count;
+    return ranges.size();
 }


Input:
public void writeToNBT(NBTTagCompound data) {
    data.setDouble("String_Node_Str", xCoord);
    data.setDouble("String_Node_Str", yCoord);
    data.setDouble("String_Node_Str", zCoord);
    data.setFloat("String_Node_Str", getSpeed());
    NBTTagCompound itemStackTag = new NBTTagCompound();
    getItemStack().writeToNBT(itemStackTag);
    data.setTag("String_Node_Str", itemStackTag);
    data.setBoolean("String_Node_Str", toCenter);
    data.setByte("String_Node_Str", (byte) input.ordinal());
    data.setByte("String_Node_Str", (byte) output.ordinal());
    data.setByte("String_Node_Str", color != null ? (byte) color.ordinal() : -1);
    if (extraData != null) {
        data.setTag("String_Node_Str", extraData);
    }
}

Output:
 public void writeToNBT(NBTTagCompound data) {
-    data.setDouble("String_Node_Str", xCoord);
-    data.setDouble("String_Node_Str", yCoord);
-    data.setDouble("String_Node_Str", zCoord);
+    data.setDouble("String_Node_Str", pos.xCoord);
+    data.setDouble("String_Node_Str", pos.yCoord);
+    data.setDouble("String_Node_Str", pos.zCoord);
     data.setFloat("String_Node_Str", getSpeed());


Input:
public IBuildJobHandler getBuildJobHandler() {
    if (buildJobHandler == null) {
        buildJobHandler = BuildJobFactory.createBuildJobHandler(getProcessItem(), getContextName(), version, getExportChoiceMap(), "String_Node_Str");
    }
    return buildJobHandler;
}

Output:
 public IBuildJobHandler getBuildJobHandler() {
-    if (buildJobHandler == null) {
+    if (buildJobHandler == null && getBuildProject()) {
         buildJobHandler = BuildJobFactory.createBuildJobHandler(getProcessItem(), getContextName(), version, getExportChoiceMap(), "String_Node_Str");


Input:
public void delete(JvmDataReq request) {
    new DeleteSql(getSqlTemplate()).delete(getTableName()).whereSql(buildWhereSql(request));
}

Output:
 public void delete(JvmDataReq request) {
-    new DeleteSql(getSqlTemplate()).delete(getTableName()).whereSql(buildWhereSql(request));
+    new DeleteSql(getSqlTemplate()).delete(getTableName()).whereSql(buildWhereSql(request)).doDelete();
 }


Input:
public void startRequest(DIRRequest rq) {
    try {
        final address_mappings_setRequest request = (address_mappings_setRequest) rq.getRequestMessage();
        final AddressMappingSet mappings = request.getAddress_mappings();
        String uuid = null;
        if (mappings.size() == 0) {
            rq.sendException(new InvalidArgumentException("String_Node_Str"));
            return;
        }
        for (AddressMapping am : mappings) {
            if (uuid == null)
                uuid = am.getUuid();
            if (!am.getUuid().equals(uuid)) {
                rq.sendException(new InvalidArgumentException("String_Node_Str"));
                return;
            }
        }
        assert (uuid != null);
        assert (database != null);
        AddressMappingSet dbData = new AddressMappingSet();
        byte[] data = database.directLookup(DIRRequestDispatcher.DB_NAME, DIRRequestDispatcher.INDEX_ID_ADDRMAPS, uuid.getBytes());
        long currentVersion = 0;
        if (data != null) {
            ReusableBuffer buf = ReusableBuffer.wrap(data);
            dbData.deserialize(buf);
            if (dbData.size() > 0) {
                currentVersion = dbData.get(0).getVersion();
            }
        }
        if (mappings.get(0).getVersion() != currentVersion) {
            rq.sendException(new ConcurrentModificationException());
            return;
        }
        currentVersion++;
        mappings.get(0).setVersion(currentVersion);
        ONCRPCBufferWriter writer = new ONCRPCBufferWriter(mappings.calculateSize());
        mappings.serialize(writer);
        byte[] newData = writer.getBuffers().get(0).array();
        BabuDBInsertGroup ig = database.createInsertGroup(DIRRequestDispatcher.DB_NAME);
        ig.addInsert(DIRRequestDispatcher.INDEX_ID_ADDRMAPS, uuid.getBytes(), newData);
        database.directInsert(ig);
        address_mappings_setResponse response = new address_mappings_setResponse(currentVersion);
        rq.sendSuccess(response);
    } catch (BabuDBException ex) {
        Logging.logMessage(Logging.LEVEL_ERROR, this, ex);
        rq.sendInternalServerError();
    }
}

Output:
         Logging.logMessage(Logging.LEVEL_ERROR, this, ex);
-        rq.sendInternalServerError();
+        rq.sendInternalServerError(ex);
     }


Input:
public void execute(Hero hero, String action) {
    if (action == AC_SET || action == AC_RETURN) {
        if (Dungeon.bossLevel()) {
            hero.spend(LloydsBeacon.TIME_TO_USE);
            GLog.w(Messages.get(this, "String_Node_Str"));
            return;
        }
        for (int i = 0; i < Level.NEIGHBOURS8.length; i++) {
            if (Actor.findChar(hero.pos + Level.NEIGHBOURS8[i]) != null) {
                GLog.w(Messages.get(this, "String_Node_Str"));
                return;
            }
        }
    }
    if (action == AC_ZAP) {
        curUser = hero;
        int chargesToUse = Dungeon.depth > 20 ? 2 : 1;
        if (!isEquipped(hero))
            GLog.i(Messages.get(Artifact.class, "String_Node_Str"));
        else if (charge < chargesToUse)
            GLog.i(Messages.get(this, "String_Node_Str"));
        else {
            GameScene.selectCell(zapper);
        }
    } else if (action == AC_SET) {
        returnDepth = Dungeon.depth;
        returnPos = hero.pos;
        hero.spend(LloydsBeacon.TIME_TO_USE);
        hero.busy();
        hero.sprite.operate(hero.pos);
        Sample.INSTANCE.play(Assets.SND_BEACON);
        GLog.i(Messages.get(this, "String_Node_Str"));
    } else if (action == AC_RETURN) {
        if (returnDepth == Dungeon.depth) {
            ScrollOfTeleportation.appear(hero, returnPos);
            Dungeon.level.press(returnPos, hero);
            Dungeon.observe();
        } else {
            Buff buff = Dungeon.hero.buff(TimekeepersHourglass.timeFreeze.class);
            if (buff != null)
                buff.detach();
            for (Mob mob : Dungeon.level.mobs.toArray(new Mob[0])) if (mob instanceof DriedRose.GhostHero)
                mob.destroy();
            InterlevelScene.mode = InterlevelScene.Mode.RETURN;
            InterlevelScene.returnDepth = returnDepth;
            InterlevelScene.returnPos = returnPos;
            Game.switchScene(InterlevelScene.class);
        }
    } else {
        super.execute(hero, action);
    }
}

Output:
         int chargesToUse = Dungeon.depth > 20 ? 2 : 1;
-        if (!isEquipped(hero))
+        if (!isEquipped(hero)) {
             GLog.i(Messages.get(Artifact.class, "String_Node_Str"));


Input:
private InetAddress getSystemConfiguredAddress() throws UnknownHostException {
    final String localAddress = System.getProperty("String_Node_Str");
    if (localAddress != null) {
        if ("String_Node_Str".equals(localAddress.trim()) || "String_Node_Str".equals(localAddress.trim())) {
            return pickLoopbackAddress();
        } else {
            return InetAddress.getByName(localAddress.trim());
        }
    }
    return null;
}

Output:
     if (localAddress != null) {
-        if ("String_Node_Str".equals(localAddress.trim()) || "String_Node_Str".equals(localAddress.trim())) {
+        localAddress = localAddress.trim();
+        if ("String_Node_Str".equals(localAddress) || "String_Node_Str".equals(localAddress)) {
             return pickLoopbackAddress();


Input:
private List<InvoiceLine> createInvoiceLine(Invoice invoice, StockMoveLine stockMoveLine) throws AxelorException {
    Product product = stockMoveLine.getProduct();
    if (product == null)
        throw new AxelorException(String.format("String_Node_Str", stockMoveLine.getStockMove().getStockMoveSeq()), IException.CONFIGURATION_ERROR);
    InvoiceLineGenerator invoiceLineGenerator = new InvoiceLineGenerator(invoice, product, product.getName(), stockMoveLine.getPrice(), product.getDescription(), stockMoveLine.getQty(), stockMoveLine.getUnit(), null, product.getInvoiceLineType(), stockMoveLine.getProductVariant(), BigDecimal.ZERO, 0, null, false) {

        public List<InvoiceLine> creates() throws AxelorException {
            InvoiceLine invoiceLine = this.createInvoiceLine();
            List<InvoiceLine> invoiceLines = new ArrayList<InvoiceLine>();
            invoiceLines.add(invoiceLine);
            return invoiceLines;
        }
    };
    return invoiceLineGenerator.creates();
}

Output:
         throw new AxelorException(String.format("String_Node_Str", stockMoveLine.getStockMove().getStockMoveSeq()), IException.CONFIGURATION_ERROR);
-    InvoiceLineGenerator invoiceLineGenerator = new InvoiceLineGenerator(invoice, product, product.getName(), stockMoveLine.getPrice(), product.getDescription(), stockMoveLine.getQty(), stockMoveLine.getUnit(), null, product.getInvoiceLineType(), stockMoveLine.getProductVariant(), BigDecimal.ZERO, 0, null, false) {
+    Task task = null;
+    if (invoice.getProject() != null) {
+        task = invoice.getProject().getDefaultTask();
+    }
+    InvoiceLineGenerator invoiceLineGenerator = new InvoiceLineGenerator(invoice, product, product.getName(), stockMoveLine.getPrice(), product.getDescription(), stockMoveLine.getQty(), stockMoveLine.getUnit(), task, product.getInvoiceLineType(), stockMoveLine.getProductVariant(), BigDecimal.ZERO, 0, null, false) {


Input:
private void logEvent(InfluxDBEvent e) {
    boolean useLocalTime = e.useLocalTime();
    long now = System.currentTimeMillis();
    boolean multipoint = false;
    int pointCount = 1;
    JSONArray columns = new JSONArray();
    JSONArray points = new JSONArray();
    Object[] values = e.getValues();
    if (useLocalTime)
        columns.add("String_Node_Str");
    Collections.addAll(columns, e.getColumns());
    if (values[0] instanceof Object[]) {
        multipoint = true;
        pointCount = values.length;
    }
    if (multipoint) {
        for (int i = 0; i < pointCount; i++) {
            JSONArray point = new JSONArray();
            if (useLocalTime)
                point.add(now);
            Collections.addAll(point, values[i]);
            points.add(point);
        }
    } else {
        JSONArray point = new JSONArray();
        if (useLocalTime)
            point.add(System.currentTimeMillis());
        Collections.addAll(point, values);
        points.add(point);
    }
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("String_Node_Str", e.getName());
    jsonObject.put("String_Node_Str", columns);
    jsonObject.put("String_Node_Str", points);
    JSONArray jsonArray = new JSONArray();
    jsonArray.add(jsonObject);
    final String jsonString = jsonArray.toJSONString();
    executor.execute(new Runnable() {
        public void run() {
            sendPost(jsonString);
        }
    });
}

Output:
                 point.add(now);
-            Collections.addAll(point, values[i]);
+            Collections.addAll(point, (Object[]) values[i]);
             points.add(point);


Input:
public Response createDeploymentTest(final String csar, final String servicetemplate, final Integer id) {
    final CSARContent csarContent = this.csarService.findById(csar);
    if (!this.csarService.hasServiceTemplate(csarContent.getCSARID(), servicetemplate)) {
        logger.info("String_Node_Str" + servicetemplate + "String_Node_Str");
        throw new NotFoundException("String_Node_Str" + servicetemplate + "String_Node_Str");
    }
    final ServiceTemplateInstance sti = new ServiceTemplateInstanceRepository().find(Long.valueOf(id)).orElse(null);
    if (sti == null) {
        logger.info("String_Node_Str" + id + "String_Node_Str" + servicetemplate + "String_Node_Str");
        throw new NotFoundException("String_Node_Str" + id + "String_Node_Str" + servicetemplate + "String_Node_Str");
    }
    final DeploymentTest result = this.deploymentTestService.run(csarContent.getCSARID(), sti);
    final URI location = this.uriInfo.getAbsolutePathBuilder().path(String.valueOf(result.getId())).build();
    return Response.created(UriUtil.encode(location)).build();
}

Output:
     if (sti == null) {
-        logger.info("String_Node_Str" + id + "String_Node_Str" + servicetemplate + "String_Node_Str");
-        throw new NotFoundException("String_Node_Str" + id + "String_Node_Str" + servicetemplate + "String_Node_Str");
+        logger.info("String_Node_Str" + id + "String_Node_Str" + this.serviceTemplateId + "String_Node_Str");
+        throw new NotFoundException("String_Node_Str" + id + "String_Node_Str" + this.serviceTemplateId + "String_Node_Str");
     }


Input:
public Map<ECustomVersionGroup, Set<LibraryFile>> getImportLibLibraries() {
    Map<ECustomVersionGroup, Set<LibraryFile>> libMap = new HashMap<ECustomVersionGroup, Set<LibraryFile>>();
    if (isFromExistVersion) {
        IHadoopService hadoopService = null;
        if (GlobalServiceRegister.getDefault().isServiceRegistered(IHadoopService.class)) {
            hadoopService = (IHadoopService) GlobalServiceRegister.getDefault().getService(IHadoopService.class);
        }
        if (hadoopService != null) {
            for (ECustomVersionGroup group : existVersionSelectionMap.keySet()) {
                if (existVersionSelectionMap.get(group)) {
                    if (types != null) {
                        HashSet libInSameGroup = new HashSet<LibraryFile>();
                        for (ECustomVersionType type : types) {
                            if (type.getGroup() == group) {
                                if (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type) {
                                    type = ECustomVersionType.HDFS;
                                }
                                Set<String> hadoopLibraries = hadoopService.getHadoopLibrariesByType(type, getDistribution(), getVersion());
                                Set<LibraryFile> convertToLibraryFile = customLibUtil.convertToLibraryFile(hadoopLibraries);
                                libInSameGroup.addAll(convertToLibraryFile);
                            }
                        }
                        libMap.put(group, libInSameGroup);
                    }
                }
            }
        }
    } else if (isFromZip) {
        Set<ECustomVersionGroup> groups = new HashSet<ECustomVersionGroup>();
        for (ECustomVersionGroup group : fromZipSelectionMap.keySet()) {
            if (fromZipSelectionMap.get(group)) {
                groups.add(group);
            }
        }
        return customLibUtil.readZipFile(zipLocation, groups);
    }
    return libMap;
}

Output:
                             if (type.getGroup() == group) {
-                                if (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type) {
-                                    type = ECustomVersionType.HDFS;
+                                Set<String> hadoopLibraries = new HashSet<String>();
+                                if (ECustomVersionType.PIG == type) {
+                                    hadoopLibraries = getLibrariesForPig();
+                                } else {
+                                    if (ECustomVersionType.HCATALOG == type || ECustomVersionType.OOZIE == type) {
+                                        type = ECustomVersionType.HDFS;
+                                    }
+                                    hadoopLibraries = hadoopService.getHadoopLibrariesByType(type, getDistribution(), getVersion());
                                 }


Input:
private void downloadWithTor(boolean useTor, Uri uri, String title, String desc, File targetFile) {
    initNotificationManager();
    String nTag = indexItem.getExpansionId();
    int nId = 0;
    if (fileName.contains(scal.io.liger.Constants.MAIN)) {
        nId = Integer.parseInt(indexItem.getExpansionFileVersion());
    } else if (fileName.contains(scal.io.liger.Constants.PATCH)) {
        nId = Integer.parseInt(indexItem.getPatchFileVersion());
    }
    OkHttpClient httpClient = new OkHttpClient();
    if (useTor) {
        if (checkTor(context)) {
            Timber.d("String_Node_Str" + scal.io.liger.Constants.TOR_PROXY_HOST + "String_Node_Str" + scal.io.liger.Constants.TOR_PROXY_PORT);
            SocketAddress torSocket = new InetSocketAddress(scal.io.liger.Constants.TOR_PROXY_HOST, scal.io.liger.Constants.TOR_PROXY_PORT);
            Proxy torProxy = new Proxy(Proxy.Type.HTTP, torSocket);
            httpClient.setProxy(torProxy);
        } else {
            Timber.e("String_Node_Str");
            if (context instanceof Activity) {
                Utils.toastOnUiThread((Activity) context, "String_Node_Str", true);
            }
            StorymakerQueueManager.checkQueueFinished(context, targetFile.getName());
            return;
        }
    }
    httpClient.setRetryOnConnectionFailure(false);
    httpClient.setConnectTimeout(3000, TimeUnit.MILLISECONDS);
    String actualFileName = targetFile.getName().substring(0, targetFile.getName().lastIndexOf("String_Node_Str"));
    Timber.d("String_Node_Str" + uri.toString());
    try {
        Request request = new Request.Builder().url(uri.toString()).build();
        File partFile = new File(targetFile.getPath().replace("String_Node_Str", "String_Node_Str"));
        if (partFile.exists()) {
            long partBytes = partFile.length();
            Timber.d("String_Node_Str" + partFile.getPath() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + Long.toString(partBytes) + "String_Node_Str");
            request = new Request.Builder().url(uri.toString()).addHeader("String_Node_Str", "String_Node_Str" + Long.toString(partBytes) + "String_Node_Str").build();
        } else {
            Timber.d("String_Node_Str" + partFile.getPath() + "String_Node_Str");
        }
        Response response = httpClient.newCall(request).execute();
        int statusCode = response.code();
        if ((statusCode == 200) || (statusCode == 206)) {
            Timber.d("String_Node_Str" + statusCode);
            Date startTime = new Date();
            long queueId = 0 - startTime.getTime();
            StorymakerQueueManager.addToQueue(context, queueId, targetFile.getName(), queueDao);
            targetFile.getParentFile().mkdirs();
            Timber.d("String_Node_Str");
            BufferedInputStream responseInput = new BufferedInputStream(response.body().byteStream());
            try {
                FileOutputStream targetOutput = new FileOutputStream(targetFile);
                byte[] buf = new byte[1024];
                int i;
                int oldPercent = 0;
                long thisTime;
                long lastTime = -1;
                int lastPercent = 0;
                while ((i = responseInput.read(buf)) > 0) {
                    int nPercent = StorymakerDownloadHelper.getDownloadPercent(context, fileName, installedDao);
                    thisTime = System.currentTimeMillis();
                    if (oldPercent == nPercent) {
                    } else {
                        if (nPercent % 10 == 0 && nPercent != lastPercent) {
                            if (lastTime == -1 || (thisTime - lastTime) > 1000) {
                                lastPercent = nPercent;
                                oldPercent = nPercent;
                                lastTime = thisTime;
                                Notification nProgress = new Notification.Builder(context).setContentTitle(mAppTitle + "String_Node_Str").setContentText(indexItem.getTitle() + "String_Node_Str" + (nPercent / 10.0) + "String_Node_Str").setSmallIcon(android.R.drawable.arrow_down_float).setProgress(100, (nPercent / 10), false).setWhen(startTime.getTime()).build();
                                nManager.notify(nTag, nId, nProgress);
                            }
                        }
                    }
                    targetOutput.write(buf, 0, i);
                }
                targetOutput.close();
                responseInput.close();
                Timber.d("String_Node_Str" + targetFile);
            } catch (ConnectTimeoutException cte) {
                Timber.e("String_Node_Str" + actualFileName + "String_Node_Str");
                cte.printStackTrace();
            } catch (SocketTimeoutException ste) {
                Timber.e("String_Node_Str" + actualFileName + "String_Node_Str");
                ste.printStackTrace();
            } catch (IOException ioe) {
                Timber.e("String_Node_Str" + actualFileName + "String_Node_Str");
                ioe.printStackTrace();
            }
            StorymakerQueueManager.removeFromQueue(context, queueId, queueDao);
            nManager.cancel(nTag, nId);
            if (!handleFile(targetFile)) {
                Timber.e("String_Node_Str" + actualFileName);
            }
        } else {
            Timber.e("String_Node_Str" + actualFileName + "String_Node_Str" + statusCode);
            StorymakerQueueManager.checkQueueFinished(context, targetFile.getName());
        }
    } catch (IOException ioe) {
        Timber.e("String_Node_Str" + actualFileName + "String_Node_Str");
        ioe.printStackTrace();
        StorymakerQueueManager.checkQueueFinished(context, targetFile.getName());
    }
}

Output:
     try {
-        Request request = new Request.Builder().url(uri.toString()).build();
+        Request request = new Request.Builder().url(uri.toString()).addHeader("String_Node_Str", "String_Node_Str").build();
         File partFile = new File(targetFile.getPath().replace("String_Node_Str", "String_Node_Str"));


Input:
private Proc doLaunch(boolean quiet, FilePath pwd, String... commands) throws IOException {
    waitUntilContainerIsReady();
    final CountDownLatch started = new CountDownLatch(1);
    final CountDownLatch finished = new CountDownLatch(1);
    final AtomicBoolean alive = new AtomicBoolean(false);
    PrintStream printStream = launcher.getListener().getLogger();
    OutputStream stream = printStream;
    if (quiet) {
        stream = new NullOutputStream();
        printStream = new PrintStream(stream, false, StandardCharsets.UTF_8.toString());
    }
    ExitCodeOutputStream exitCodeOutputStream = new ExitCodeOutputStream();
    stream = new TeeOutputStream(exitCodeOutputStream, stream);
    String msg = "String_Node_Str" + containerName + "String_Node_Str" + podName + "String_Node_Str";
    LOGGER.log(Level.FINEST, msg);
    printStream.println(msg);
    Execable<String, ExecWatch> execable = client.pods().inNamespace(namespace).withName(podName).inContainer(containerName).redirectingInput().writingOutput(stream).writingError(stream).withTTY().usingListener(new ExecListener() {

        public void onOpen(Response response) {
            alive.set(true);
            started.countDown();
        }
        public void onFailure(Throwable t, Response response) {
            alive.set(false);
            t.printStackTrace(launcher.getListener().getLogger());
            started.countDown();
            LOGGER.log(Level.FINEST, "String_Node_Str", finished);
            if (finished.getCount() == 0) {
                LOGGER.log(Level.WARNING, "String_Node_Str");
            }
            finished.countDown();
        }
        public void onClose(int i, String s) {
            alive.set(false);
            started.countDown();
            LOGGER.log(Level.FINEST, "String_Node_Str", finished);
            if (finished.getCount() == 0) {
                LOGGER.log(Level.WARNING, "String_Node_Str");
            }
            finished.countDown();
        }
    });
    ExecWatch watch;
    try {
        watch = execable.exec();
    } catch (KubernetesClientException e) {
        if (e.getCause() instanceof InterruptedException) {
            throw new IOException("String_Node_Str", e);
        } else {
            throw e;
        }
    }
    try {
        started.await();
    } catch (InterruptedException e) {
        closeWatch(watch);
        throw new IOException("String_Node_Str", e);
    }
    try {
        if (pwd != null) {
            watch.getInput().write(String.format("String_Node_Str", pwd, NEWLINE).getBytes(StandardCharsets.UTF_8));
        }
        if (environmentExpander != null) {
            EnvVars envVars = new EnvVars();
            environmentExpander.expand(envVars);
            for (Map.Entry<String, String> entry : envVars.entrySet()) {
                watch.getInput().write(String.format("String_Node_Str", entry.getKey(), entry.getValue(), NEWLINE).getBytes(StandardCharsets.UTF_8));
            }
        }
        doExec(watch, printStream, commands);
        ContainerExecProc proc = new ContainerExecProc(watch, alive, finished, exitCodeOutputStream::getExitCode);
        closables.add(proc);
        return proc;
    } catch (InterruptedException ie) {
        throw new InterruptedIOException(ie.getMessage());
    } catch (Exception e) {
        closeWatch(watch);
        throw e;
    }
}

Output:
     printStream.println(msg);
-    Execable<String, ExecWatch> execable = client.pods().inNamespace(namespace).withName(podName).inContainer(containerName).redirectingInput().writingOutput(stream).writingError(stream).withTTY().usingListener(new ExecListener() {
+    Execable<String, ExecWatch> execable = client.pods().inNamespace(namespace).withName(podName).inContainer(containerName).redirectingInput().writingOutput(stream).writingError(stream).usingListener(new ExecListener() {


Input:
public void testFacesConfigHappyPath() {
    new AbstractFacesConfigTestCase(TestUtils.STUBBED_RESOURCEPATH, new StringStreamProvider(TestUtils.getFacesConfig(CORRECT))) {
    };
}

Output:
 public void testFacesConfigHappyPath() {
-    new AbstractFacesConfigTestCase(TestUtils.STUBBED_RESOURCEPATH, new StringStreamProvider(TestUtils.getFacesConfig(CORRECT))) {
-    };
+    StreamProvider streamProvider = new StringStreamProvider(TestUtils.getFacesConfig(CORRECT));
+    new AbstractFacesConfigTestCase(TestUtils.STUBBED_RESOURCEPATH, streamProvider) {
+    }.testClassDefinitions();
 }


Input:
private Object[] toObject(int[] types) {
    Object[] obj = new Object[types.length];
    for (int i = 0; i < types.length; i++) {
        obj[i] = new Integer(types[i]);
    }
    return obj;
}

Output:
     for (int i = 0; i < types.length; i++) {
-        obj[i] = new Integer(types[i]);
+        obj[i] = Integer.valueOf(types[i]);
     }


Input:
public V put(K key, V value) {
    if (key == null) {
        throw new NullPointerException();
    }
    if (super.containsKey(key)) {
        int i = orderedKeys.indexOf(key);
        if (i == -1) {
            throw new IllegalStateException("String_Node_Str" + key);
        }
        orderedKeys.setElementAt(key, i);
    } else {
        orderedKeys.addElement(key);
    }
    return super.put(key, value);
}

Output:
     }
-    if (super.containsKey(key)) {
-        int i = orderedKeys.indexOf(key);
-        if (i == -1) {
-            throw new IllegalStateException("String_Node_Str" + key);
-        }
-        orderedKeys.setElementAt(key, i);
-    } else {
+    V v = super.put(key, value);
+    if (super.size() > orderedKeys.size()) {
         orderedKeys.addElement(key);


Input:
public void delMisc(final int i) {
    isDirty = true;
    if (!misc.isEmpty() && (i > -1)) {
        misc.remove(i);
        calcMiscCost();
    }
}

Output:
     isDirty = true;
-    if (!misc.isEmpty() && (i > -1)) {
+    if (!misc.isEmpty() && (i > -1) && (i < misc.size())) {
         misc.remove(i);


Input:
private static <T> void validateConfigType(Map<String, Object> config, List<Map<String, Map<String, List<T>>>> list, List<String> warningMsgList) {
    if (warningMsgList != null) {
        String configType = "String_Node_Str";
        List<String> grayList = new ArrayList<String>();
        boolean found = false;
        for (Entry<String, Object> configTypeEntry : config.entrySet()) {
            configType = configTypeEntry.getKey();
            found = false;
            for (Map<String, Map<String, List<T>>> listTypeMap : list) {
                if (listTypeMap.containsKey(configType)) {
                    found = true;
                }
            }
            if (!found) {
                grayList.add(configType);
            }
        }
        if (!found) {
            StringBuffer errorMsg = new StringBuffer();
            String be = "String_Node_Str";
            errorMsg.append(Constants.CLUSTER_CONFIG_TYPE_NOT_RAGULARLY_BEFORE);
            for (String grayConfigType : grayList) {
                errorMsg.append(grayConfigType);
                errorMsg.append("String_Node_Str");
            }
            if (grayList.size() > 1) {
                be = "String_Node_Str";
            }
            errorMsg.replace(errorMsg.length() - 2, errorMsg.length(), be + Constants.CLUSTER_CONFIG_TYPE_NOT_RAGULARLY_AFTER);
            warningMsgList.add(errorMsg.toString());
        }
    }
}

Output:
 private static <T> void validateConfigType(Map<String, Object> config, List<Map<String, Map<String, List<T>>>> list, List<String> warningMsgList) {
-    if (warningMsgList != null) {
+    if ((config.size() > 0) && (warningMsgList != null)) {
         String configType = "String_Node_Str";


Input:
private SortedSet<String> getResources(QueryTree<N> tree) {
    SortedSet<String> resources = new TreeSet<String>();
    query = tree.toSPARQLQueryString();
    query = getDistinctQuery(query);
    if (logger.isInfoEnabled()) {
        logger.info("String_Node_Str" + query);
    }
    String result = cache.executeSelectQuery(endpoint, getLimitedQuery(query));
    ResultSetRewindable rs = SparqlQuery.convertJSONtoResultSet(result);
    String uri;
    QuerySolution qs;
    while (rs.hasNext()) {
        qs = rs.next();
        uri = qs.getResource("String_Node_Str").getURI();
        resources.add(uri);
    }
    return resources;
}

Output:
     query = tree.toSPARQLQueryString();
-    query = getDistinctQuery(query);
+    query = getLimitedQuery(query);
     if (logger.isInfoEnabled()) {


Input:
protected Function<ResourceResponse, ResourceResponse, NeverThrowsException> formatResponseNoException(final Context context, final Request request) {
    return new Function<ResourceResponse, ResourceResponse, NeverThrowsException>() {
        public String resourcePath = getResourcePath(context, request).toString();

        public ResourceResponse apply(final ResourceResponse raw) {
            final JsonValue formatted = json(object());
            final Map<String, Object> properties = new LinkedHashMap<>();
            final Map<String, Object> repoProperties = raw.getContent().get(REPO_FIELD_PROPERTIES).asMap();
            final String ref;
            if (isRevereseRelationship && raw.getContent().get(REPO_FIELD_FIRST_ID).asString().equals(resourcePath)) {
                ref = raw.getContent().get(REPO_FIELD_SECOND_ID).asString();
            } else {
                ref = raw.getContent().get(REPO_FIELD_FIRST_ID).asString();
            }
            if (repoProperties != null) {
                properties.putAll(repoProperties);
            }
            properties.put(FIELD_CONTENT_ID, raw.getId());
            properties.put(FIELD_CONTENT_REVISION, raw.getRevision());
            formatted.put(SchemaField.FIELD_REFERENCE, ref);
            formatted.put(SchemaField.FIELD_PROPERTIES, properties);
            return newResourceResponse(null, null, formatted);
        }
    };
}

Output:
     return new Function<ResourceResponse, ResourceResponse, NeverThrowsException>() {
-        public String resourcePath = getResourcePath(context, request).toString();
+        public String resourceFullPath = getResourceFullPath(context, request).toString();


Input:
public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
    super.onLoadingComplete(imageUri, view, loadedImage);
    Palette.generateAsync(loadedImage, new PaletteListener(loadedImage, listener));
}

Output:
     super.onLoadingComplete(imageUri, view, loadedImage);
-    Palette.generateAsync(loadedImage, new PaletteListener(loadedImage, listener));
+    new Palette.Builder(loadedImage).maximumColorCount(3).generate(new Palette.PaletteAsyncListener() {
+        public void onGenerated(Palette palette) {
+            if (listener != null) {
+                listener.onImageLoaded(loadedImage, palette);
+            }
+        }
+    });
 }


Input:
public static void init(MasterServices master) throws IOException {
    try {
        AccessControlLists.init(master);
    } catch (TableExistsException excp) {
    }
}

Output:
 public static void init(MasterServices master) throws IOException {
-    try {
-        AccessControlLists.init(master);
-    } catch (TableExistsException excp) {
+    Class<AccessControlLists> accessControlListsClass = AccessControlLists.class;
+    String cName = accessControlListsClass.getName();
+    Class<?>[] params = new Class[1];
+    params[0] = MasterServices.class;
+    for (String mname : new String[] { "String_Node_Str", "String_Node_Str" }) {
+        try {
+            try {
+                Method m = accessControlListsClass.getDeclaredMethod(mname, params);
+                if (m != null) {
+                    try {
+                        try {
+                            m.invoke(null, master);
+                            logInfo("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str");
+                        } catch (InvocationTargetException e) {
+                            Throwable cause = e;
+                            boolean tableExistsExceptionFound = false;
+                            if (e != null) {
+                                Throwable ecause = e.getTargetException();
+                                if (ecause != null) {
+                                    cause = ecause;
+                                    if (ecause instanceof TableExistsException) {
+                                        tableExistsExceptionFound = true;
+                                    }
+                                }
+                            }
+                            if (!tableExistsExceptionFound) {
+                                logError("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str", cause);
+                                throw new IOException(cause);
+                            }
+                        }
+                        return;
+                    } catch (IllegalArgumentException e) {
+                        logError("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str", e);
+                        throw new IOException(e);
+                    } catch (IllegalAccessException e) {
+                        logError("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str", e);
+                        throw new IOException(e);
+                    }
+                }
+            } catch (NoSuchMethodException nsme) {
+                logInfo("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str");
+            }
+        } catch (SecurityException e) {
+            logError("String_Node_Str" + mname + "String_Node_Str" + cName + "String_Node_Str", e);
+            throw new IOException(e);
+        }
     }


Input:
public static void loadLibrary(String name) {
    try {
        System.loadLibrary(name);
    } catch (UnsatisfiedLinkError error) {
        URL classURL = NativeHelper.class.getResource("String_Node_Str");
        if (classURL == null || !"String_Node_Str".equalsIgnoreCase(classURL.getProtocol())) {
            throw error;
        }
        String path = null;
        String[] components = classURL.getPath().split(File.separator);
        for (int i = 0; i < components.length; i++) {
            if (i < components.length - 2 && "String_Node_Str".equals(components[i]) && "String_Node_Str".equals(components[i + 1]) && "String_Node_Str".equals(components[i + 2])) {
                path = String.join("String_Node_Str", Arrays.copyOf(components, i + 1));
            }
        }
        if (path == null) {
            throw error;
        }
        String libName = System.mapLibraryName("String_Node_Str");
        System.load(path + "String_Node_Str" + libName);
    }
}

Output:
         }
-        String path = null;
-        String[] components = classURL.getPath().split(File.separator);
-        for (int i = 0; i < components.length; i++) {
-            if (i < components.length - 2 && "String_Node_Str".equals(components[i]) && "String_Node_Str".equals(components[i + 1]) && "String_Node_Str".equals(components[i + 2])) {
-                path = String.join("String_Node_Str", Arrays.copyOf(components, i + 1));
-            }
-        }
-        if (path == null) {
+        String path = classURL.getPath();
+        path = path.replace(File.separator, "String_Node_Str");
+        int pos = path.lastIndexOf("String_Node_Str");
+        if (pos < 0) {
             throw error;


Input:
protected void doPropagate() {
    if (getDevice().getWorld().isRemote)
        return;
    if (getDevice() instanceof IRedConductor) {
        if (((IRedConductor) getDevice()).hasLoss(getSide())) {
            try {
                new LossyPropagator(getDevice(), getSide()).propagate();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else {
            try {
                new LosslessPropagator(getDevice(), getSide()).propagate();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return;
    } else if (getDevice() instanceof GateBase<?, ?, ?, ?, ?, ?>) {
        IGateConnection c = ((GateBase<?, ?, ?, ?, ?, ?>) getDevice()).getConnection(getSide());
        if (c != null) {
            if (c instanceof GateConnectionAnalogue) {
                try {
                    new LossyPropagator(getDevice(), getSide()).propagate();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            } else if (c instanceof GateConnectionDigital) {
                try {
                    new LosslessPropagator(getDevice(), getSide()).propagate();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            return;
        }
    }
    try {
        new LosslessPropagator(getDevice(), getSide()).propagate();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

Output:
         if (c != null) {
-            if (c instanceof GateConnectionAnalogue) {
+            if (con != null && con.getB() instanceof IRedConductor && ((IRedConductor) con.getB()).hasLoss(con.getSideB())) {
                 try {


Input:
public static float getDistance(BoundingVolume bounds, float fieldOfView, float minDistance, float maxDistance) {
    float alongRadius = 1.0f;
    float crossRadius = 1.0f;
    if (bounds instanceof BoundingSphere) {
        alongRadius = crossRadius = ((BoundingSphere) bounds).radius;
    } else if (bounds instanceof BoundingBox) {
        alongRadius = ((BoundingBox) bounds).xExtent;
        crossRadius = ((BoundingBox) bounds).zExtent;
    }
    double eyeDist = alongRadius / Math.tan(fieldOfView / 2.0);
    eyeDist += crossRadius;
    if (minDistance != -1) {
        eyeDist = Math.max(eyeDist, minDistance);
    }
    if (maxDistance != -1) {
        eyeDist = Math.min(eyeDist, maxDistance);
    }
    return (float) eyeDist;
}

Output:
     }
-    double eyeDist = alongRadius / Math.tan(fieldOfView / 2.0);
+    double eyeDist = alongRadius / Math.tan(Math.toRadians(fieldOfView / 2.0));
     eyeDist += crossRadius;


Input:
private void validateChildren(List<UIComponent> children, UIApplication uiApp, WebuiRequestContext context) {
    for (UIComponent uiChild : children) {
        if (uiChild instanceof UIFormInputBase) {
            UIFormInputBase uiInput = (UIFormInputBase) uiChild;
            if (!checkVisible(uiInput))
                continue;
            List<Validator> validators = uiInput.getValidators();
            if (validators == null)
                continue;
            try {
                for (Validator validator : validators) validator.validate(uiInput);
            } catch (MessageException ex) {
                uiApp.addMessage(ex.getDetailMessage());
                context.setProcessRender(true);
            } catch (Exception ex) {
                uiApp.addMessage(new ApplicationMessage(ex.getMessage(), null));
                context.setProcessRender(true);
            }
        } else if (uiChild instanceof UIFormInputSet) {
            UIFormInputSet uiInputSet = (UIFormInputSet) uiChild;
            validateChildren(uiInputSet.getChildren(), uiApp, context);
        } else if (uiChild instanceof UIFormInputContainer) {
            UIFormInputContainer uiInput = (UIFormInputContainer) uiChild;
            List<Validator> validators = uiInput.getValidators();
            if (validators == null)
                continue;
            try {
                for (Validator validator : validators) validator.validate(uiInput);
            } catch (MessageException ex) {
                uiApp.addMessage(ex.getDetailMessage());
                context.setProcessRender(true);
            } catch (Exception ex) {
                uiApp.addMessage(new ApplicationMessage(ex.getMessage(), null));
                context.setProcessRender(true);
            }
        }
    }
}

Output:
             UIFormInputBase uiInput = (UIFormInputBase) uiChild;
-            if (!checkVisible(uiInput))
+            if (!uiInput.isValid())
                 continue;


Input:
public Precompilation newInstance(TreeLogger logger) throws UnableToCompleteException {
    Precompilation toReturn;
    try {
        toReturn = Util.readStreamAsObject(jarFile.getInputStream(zipEntry), Precompilation.class);
    } catch (IOException e) {
        toReturn = null;
    } catch (ClassNotFoundException e) {
        logger.log(TreeLogger.ERROR, "String_Node_Str", e);
        throw new UnableToCompleteException();
    }
    if (toReturn == null) {
        logger.log(TreeLogger.ERROR, "String_Node_Str");
        throw new UnableToCompleteException();
    }
    return toReturn;
}

Output:
     try {
-        toReturn = Util.readStreamAsObject(jarFile.getInputStream(zipEntry), Precompilation.class);
+        return Util.readStreamAsObject(jarFile.getInputStream(zipEntry), Precompilation.class);
     } catch (IOException e) {


Input:
public boolean performNextAttack() {
    boolean doContinue = false;
    AttackData data = attackData.get(state);
    SentinelHttpMessage httpMessage;
    try {
        httpMessage = attack(data);
    } catch (ConnectionTimeoutException ex) {
        state++;
        return false;
    }
    switch(state) {
        case 0:
            doContinue = true;
            if (checkTag(httpMessage.getRes().getResponseStr(), XssIndicator.getInstance().getBaseIndicator())) {
                inputReflectedInTag = true;
            } else {
                inputReflectedInTag = false;
            }
            break;
        case 14:
            doContinue = false;
            break;
        default:
            doContinue = true;
            break;
    }
    state++;
    return doContinue;
}

Output:
             break;
-        case 14:
+        case 11:
             doContinue = false;


Input:
public static void exportGame(String exportFileName, boolean allowOverwrite) {
    File dir = new File("String_Node_Str");
    dir.mkdir();
    dir = new File("String_Node_Str");
    dir.mkdir();
    boolean overwrite = false;
    if (dir.isDirectory()) {
        File[] directoryListing = dir.listFiles((path, filename) -> filename.endsWith("String_Node_Str"));
        if (directoryListing != null) {
            for (File child : directoryListing) {
                if (child.getName().equals(exportFileName + "String_Node_Str")) {
                    if (!allowOverwrite) {
                        Main.game.flashMessage(Colour.GENERIC_BAD, "String_Node_Str");
                        return;
                    } else {
                        overwrite = true;
                    }
                }
            }
        }
    }
    try {
        if (timeLog) {
            timeStart = System.nanoTime();
            System.out.println(timeStart);
        }
        DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
        Document doc = docBuilder.newDocument();
        Element game = doc.createElement("String_Node_Str");
        doc.appendChild(game);
        Element informationNode = doc.createElement("String_Node_Str");
        game.appendChild(informationNode);
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", Main.VERSION_NUMBER);
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", String.valueOf(Main.game.minutesPassed));
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", String.valueOf(Main.game.debugMode));
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", String.valueOf(Main.game.imperialMeasurements));
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", Main.game.currentWeather.toString());
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", String.valueOf(Main.game.nextStormTime));
        CharacterUtils.addAttribute(doc, informationNode, "String_Node_Str", String.valueOf(Main.game.weatherTimeRemaining));
        Element dateNode = doc.createElement("String_Node_Str");
        informationNode.appendChild(dateNode);
        CharacterUtils.addAttribute(doc, dateNode, "String_Node_Str", String.valueOf(Main.game.startingDate.getYear()));
        CharacterUtils.addAttribute(doc, dateNode, "String_Node_Str", String.valueOf(Main.game.startingDate.getMonthValue()));
        CharacterUtils.addAttribute(doc, dateNode, "String_Node_Str", String.valueOf(Main.game.startingDate.getDayOfMonth()));
        CharacterUtils.addAttribute(doc, dateNode, "String_Node_Str", String.valueOf(Main.game.startingDate.getHour()));
        CharacterUtils.addAttribute(doc, dateNode, "String_Node_Str", String.valueOf(Main.game.startingDate.getMinute()));
        Main.game.dialogueFlags.saveAsXML(game, doc);
        Element eventLogNode = doc.createElement("String_Node_Str");
        game.appendChild(eventLogNode);
        for (EventLogEntry event : Main.game.getEventLog().subList(Math.max(0, Main.game.getEventLog().size() - 50), Main.game.getEventLog().size())) {
            event.saveAsXML(eventLogNode, doc);
        }
        Element slaveryEventLogNode = doc.createElement("String_Node_Str");
        game.appendChild(slaveryEventLogNode);
        for (int day : Main.game.getSlaveryEventLog().keySet()) {
            Element element = doc.createElement("String_Node_Str");
            slaveryEventLogNode.appendChild(element);
            CharacterUtils.addAttribute(doc, element, "String_Node_Str", String.valueOf(day));
            for (SlaveryEventLogEntry event : Main.game.getSlaveryEventLog().get(day)) {
                event.saveAsXML(element, doc);
            }
        }
        Element mapNode = doc.createElement("String_Node_Str");
        game.appendChild(mapNode);
        for (World world : Main.game.getWorlds().values()) {
            if (world != null) {
                world.saveAsXML(mapNode, doc);
            }
        }
        Element characterNode = doc.createElement("String_Node_Str");
        game.appendChild(characterNode);
        Main.game.getPlayer().saveAsXML(characterNode, doc);
        for (GameCharacter character : Main.game.getNPCMap().values()) {
            characterNode = doc.createElement("String_Node_Str");
            game.appendChild(characterNode);
            character.saveAsXML(characterNode, doc);
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer1 = tf.newTransformer();
        transformer1.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "String_Node_Str");
        StringWriter writer = new StringWriter();
        transformer1.transform(new DOMSource(doc), new StreamResult(writer));
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.INDENT, "String_Node_Str");
        transformer.setOutputProperty("String_Node_Str", "String_Node_Str");
        DOMSource source = new DOMSource(doc);
        String saveLocation = "String_Node_Str" + exportFileName + "String_Node_Str";
        StreamResult result = new StreamResult(new File(saveLocation));
        transformer.transform(source, result);
        if (!exportFileName.startsWith("String_Node_Str")) {
            if (overwrite) {
                Main.game.addEvent(new EventLogEntry(Main.game.getMinutesPassed(), "String_Node_Str", saveLocation), false);
                Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", Main.game.getCurrentDialogueNode()), Colour.GENERIC_GOOD, "String_Node_Str");
            } else {
                Main.game.addEvent(new EventLogEntry(Main.game.getMinutesPassed(), "String_Node_Str", saveLocation), false);
                Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", Main.game.getCurrentDialogueNode()), Colour.GENERIC_GOOD, "String_Node_Str");
            }
        }
        if (timeLog) {
            System.out.println("String_Node_Str" + (System.nanoTime() - timeStart) / 1000000000f);
        }
    } catch (ParserConfigurationException pce) {
        pce.printStackTrace();
    } catch (TransformerException tfe) {
        tfe.printStackTrace();
    }
}

Output:
                 Main.game.addEvent(new EventLogEntry(Main.game.getMinutesPassed(), "String_Node_Str", saveLocation), false);
-                Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", Main.game.getCurrentDialogueNode()), Colour.GENERIC_GOOD, "String_Node_Str");
+                Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", Main.game.getCurrentDialogueNode()), false, Colour.GENERIC_GOOD, "String_Node_Str");
             } else {


Input:
void doOffer(Request req) {
    if (req.value == null) {
        throw new RuntimeException("String_Node_Str" + req.local);
    }
    if (req.value.size() == 0) {
        throw new RuntimeException("String_Node_Str" + req.local);
    }
    Q q = getQ(req.name);
    if (q.blCurrentPut == null) {
        q.setCurrentPut();
    }
    if (q.quickSize() >= q.maxSizePerJVM) {
        if (req.hasEnoughTimeToSchedule()) {
            req.scheduled = true;
            final Request reqScheduled = (req.local) ? req : req.hardCopy();
            if (reqScheduled.local) {
                if (reqScheduled.attachment == null) {
                    throw new RuntimeException("String_Node_Str");
                }
            }
            q.scheduleOffer(reqScheduled);
        } else {
            req.response = Boolean.FALSE;
        }
        return;
    }
    q.offer(req);
    req.response = Boolean.TRUE;
}

Output:
     }
-    q.offer(req);
+    q.offer(req, false);
     req.response = Boolean.TRUE;


Input:
public Period getNextPeriod(Period period) throws AxelorException {
    Period nextPeriod = all().filter("String_Node_Str", period.getToDate(), period.getCompany(), PeriodRepository.STATUS_OPENED).fetchOne();
    if (nextPeriod == null || nextPeriod.getStatusSelect() == PeriodRepository.STATUS_CLOSED) {
        throw new AxelorException(String.format(I18n.get(IExceptionMessage.PERIOD_1), period.getCompany().getName()), IException.CONFIGURATION_ERROR);
    }
    LOG.debug("String_Node_Str", nextPeriod);
    return period;
}

Output:
     LOG.debug("String_Node_Str", nextPeriod);
-    return period;
+    return nextPeriod;
 }


Input:
private void processDisconnectAndTimeout(VMOperationListener listener, String resultMessage) {
    UserVmVO vm = listener.getVm();
    VMOperationParam param = listener.getParam();
    AsyncJobManager asyncMgr = getAsyncJobMgr();
    EventVO event = new EventVO();
    event.setUserId(param.getUserId());
    event.setAccountId(vm.getAccountId());
    event.setType(EventTypes.EVENT_VM_DESTROY);
    event.setParameters("String_Node_Str" + vm.getId() + "String_Node_Str" + vm.getHostName() + "String_Node_Str" + vm.getServiceOfferingId() + "String_Node_Str" + vm.getTemplateId() + "String_Node_Str" + vm.getDataCenterId());
    event.setDescription("String_Node_Str" + vm.getHostName() + "String_Node_Str" + resultMessage);
    event.setLevel(EventVO.LEVEL_ERROR);
    boolean jobStatusUpdated = false;
    try {
        asyncMgr.completeAsyncJob(getJob().getId(), AsyncJobResult.STATUS_FAILED, 0, resultMessage);
        jobStatusUpdated = true;
        asyncMgr.getExecutorContext().getEventDao().persist(event);
    } catch (Exception e) {
        if (!jobStatusUpdated)
            asyncMgr.completeAsyncJob(getJob().getId(), AsyncJobResult.STATUS_FAILED, 0, resultMessage);
        s_logger.error("String_Node_Str" + e.getMessage(), e);
    } finally {
        asyncMgr.releaseSyncSource(this);
    }
}

Output:
     event.setType(EventTypes.EVENT_VM_DESTROY);
-    event.setParameters("String_Node_Str" + vm.getId() + "String_Node_Str" + vm.getHostName() + "String_Node_Str" + vm.getServiceOfferingId() + "String_Node_Str" + vm.getTemplateId() + "String_Node_Str" + vm.getDataCenterId());
-    event.setDescription("String_Node_Str" + vm.getHostName() + "String_Node_Str" + resultMessage);
+    event.setParameters("String_Node_Str" + vm.getId() + "String_Node_Str" + vm.getName() + "String_Node_Str" + vm.getServiceOfferingId() + "String_Node_Str" + vm.getTemplateId() + "String_Node_Str" + vm.getDataCenterId());
+    event.setDescription("String_Node_Str" + vm.getName() + "String_Node_Str" + resultMessage);
     event.setLevel(EventVO.LEVEL_ERROR);


Input:
protected void runOneIteration() throws Exception {
    LOG.trace("String_Node_Str", instanceId);
    ImmutableMap.Builder<String, Long> sizes = ImmutableMap.builder();
    for (StreamSpecification streamSpec : streamMetaStore.listStreams()) {
        sizes.put(streamSpec.getName(), streamWriterSizeCollector.getTotalCollected(streamSpec.getName()));
    }
    heartbeatPublisher.sendHeartbeat(new StreamWriterHeartbeat(System.currentTimeMillis(), instanceId, sizes.build()));
}

Output:
     }
-    heartbeatPublisher.sendHeartbeat(new StreamWriterHeartbeat(System.currentTimeMillis(), instanceId, sizes.build()));
+    StreamWriterHeartbeat heartbeat = new StreamWriterHeartbeat(System.currentTimeMillis(), instanceId, sizes.build());
+    LOG.trace("String_Node_Str", heartbeat);
+    heartbeatPublisher.sendHeartbeat(heartbeat);
 }


Input:
public boolean isHomeFor(PublicCompanyI company) {
    boolean result = homes != null && homes.get(company) != null;
    return result;
}

Output:
 public boolean isHomeFor(PublicCompanyI company) {
-    boolean result = homes != null && homes.get(company) != null;
+    boolean result = homes != null && homes.containsKey(company);
     return result;


Input:
protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) {
    if (element == null)
        return;
    Complex t;
    if (Utilities.noString(parentType))
        t = parent;
    else {
        t = parent.predicate("String_Node_Str" + parentType + '.' + name);
    }
    composeBackboneElement(t, "String_Node_Str", name, element, index);
    for (int i = 0; i < element.getVaccineCode().size(); i++) composeCodeableConcept(t, "String_Node_Str", "String_Node_Str", element.getVaccineCode().get(i), i);
    if (element.hasTargetDisease())
        composeCodeableConcept(t, "String_Node_Str", "String_Node_Str", element.getTargetDisease(), -1);
    for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) composeCodeableConcept(t, "String_Node_Str", "String_Node_Str", element.getContraindicatedVaccineCode().get(i), i);
    if (element.hasForecastStatus())
        composeCodeableConcept(t, "String_Node_Str", "String_Node_Str", element.getForecastStatus(), -1);
    for (int i = 0; i < element.getForecastReason().size(); i++) composeCodeableConcept(t, "String_Node_Str", "String_Node_Str", element.getForecastReason().get(i), i);
    for (int i = 0; i < element.getDateCriterion().size(); i++) composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "String_Node_Str", "String_Node_Str", element.getDateCriterion().get(i), i);
    if (element.hasDescriptionElement())
        composeString(t, "String_Node_Str", "String_Node_Str", element.getDescriptionElement(), -1);
    if (element.hasSeriesElement())
        composeString(t, "String_Node_Str", "String_Node_Str", element.getSeriesElement(), -1);
    if (element.hasDoseNumberElement())
        composePositiveInt(t, "String_Node_Str", "String_Node_Str", element.getDoseNumberElement(), -1);
    if (element.hasSeriesDosesElement())
        composePositiveInt(t, "String_Node_Str", "String_Node_Str", element.getSeriesDosesElement(), -1);
    for (int i = 0; i < element.getSupportingImmunization().size(); i++) composeReference(t, "String_Node_Str", "String_Node_Str", element.getSupportingImmunization().get(i), i);
    for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) composeReference(t, "String_Node_Str", "String_Node_Str", element.getSupportingPatientInformation().get(i), i);
}

Output:
         composeString(t, "String_Node_Str", "String_Node_Str", element.getSeriesElement(), -1);
-    if (element.hasDoseNumberElement())
-        composePositiveInt(t, "String_Node_Str", "String_Node_Str", element.getDoseNumberElement(), -1);
-    if (element.hasSeriesDosesElement())
-        composePositiveInt(t, "String_Node_Str", "String_Node_Str", element.getSeriesDosesElement(), -1);
+    if (element.hasDoseNumber())
+        composeType(t, "String_Node_Str", "String_Node_Str", element.getDoseNumber(), -1);
+    if (element.hasSeriesDoses())
+        composeType(t, "String_Node_Str", "String_Node_Str", element.getSeriesDoses(), -1);
     for (int i = 0; i < element.getSupportingImmunization().size(); i++) composeReference(t, "String_Node_Str", "String_Node_Str", element.getSupportingImmunization().get(i), i);


Input:
private OFFlowMod expandActions(OFFlowMod flowMod) {
    Short portId = flowMod.getMatch().getInputPort();
    List<OFAction> actions = flowMod.getActions();
    if (actions == null || actions.isEmpty()) {
        log.debug("String_Node_Str");
        return null;
    }
    List<OFAction> newActions = new ArrayList<OFAction>();
    for (OFAction action : actions) {
        log.debug("String_Node_Str" + action.getType().name());
        if (action.getType() == OFActionType.OUTPUT) {
            OFActionOutput output = (OFActionOutput) action;
            if (output.getPort() == OFPort.OFPP_ALL.getValue()) {
                log.debug("String_Node_Str");
                for (Map.Entry<String, PortConfig> port : this.portList.entrySet()) {
                    if (port.getValue().getPortId() != portId) {
                        OFActionOutput newAct;
                        try {
                            newAct = (OFActionOutput) action.clone();
                        } catch (CloneNotSupportedException e) {
                            log.error("String_Node_Str");
                            log.error(e.getMessage());
                            return null;
                        }
                        newAct.setPort(port.getValue().getPortId());
                        newActions.add(newAct);
                    }
                }
            } else if (output.getPort() == OFPort.OFPP_FLOOD.getValue()) {
                return null;
            } else {
                log.debug("String_Node_Str");
                newActions.add(action);
            }
        } else {
            log.debug("String_Node_Str");
            newActions.add(action);
        }
    }
    OFFlowMod newFlow;
    try {
        newFlow = flowMod.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
        return null;
    }
    newFlow.setActions(newActions);
    return newFlow;
}

Output:
         log.debug("String_Node_Str");
-        return null;
+        return flowMod;
     }


Input:
public MediaInfo convert(String value, IdType fromType) throws InfoProviderException {
    logger.info("String_Node_Str", fromType, value);
    try {
        MediaInfo info;
        if (fromType == TMDB || fromType == IMDB || fromType == MOVIETITLE) {
            MovieInfo movieInfo;
            if (fromType == TMDB) {
                movieInfo = movieInfoRepository.findByTmdbId(value);
            } else if (fromType == IMDB) {
                movieInfo = movieInfoRepository.findByImdbId(value);
            } else {
                movieInfo = movieInfoRepository.findByTitle(value);
            }
            if (movieInfo != null) {
                info = new MediaInfo(movieInfo);
            } else {
                TmdbSearchResult result = tmdbHandler.getInfos(value, fromType);
                info = new MediaInfo(result);
                movieInfo = new MovieInfo(info.getImdbId().orElse(null), info.getTmdbId().orElse(null), info.getTitle().orElse(null), info.getYear().orElse(null), info.getPosterUrl().orElse(null));
                movieInfoRepository.save(movieInfo);
            }
        } else if (fromType == TVMAZE || fromType == TVDB || fromType == TVRAGE || fromType == TVTITLE) {
            TvInfo tvInfo;
            if (fromType == TVMAZE) {
                tvInfo = tvInfoRepository.findByTvmazeId(value);
            } else if (fromType == TVDB) {
                tvInfo = tvInfoRepository.findByTvdbId(value);
            } else if (fromType == TVRAGE) {
                tvInfo = tvInfoRepository.findByTvrageId(value);
            } else {
                tvInfo = tvInfoRepository.findByTitle(value);
            }
            if (tvInfo != null) {
                info = new MediaInfo(tvInfo);
            } else {
                TvMazeSearchResult result = tvMazeHandler.getInfos(value, fromType);
                info = new MediaInfo(result);
                tvInfo = new TvInfo(info.getTvDbId().orElse(null), info.getTvRageId().orElse(null), info.getTvMazeId().orElse(null), info.getTitle().orElse(null), info.getYear().orElse(null), info.getPosterUrl().orElse(null));
                tvInfoRepository.save(tvInfo);
            }
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
        logger.info("String_Node_Str" + info);
        return info;
    } catch (Exception e) {
        logger.error("String_Node_Str" + fromType + "String_Node_Str" + value, e);
        Throwables.throwIfInstanceOf(e, InfoProviderException.class);
        throw new InfoProviderException("String_Node_Str", e);
    }
}

Output:
 public MediaInfo convert(String value, IdType fromType) throws InfoProviderException {
-    logger.info("String_Node_Str", fromType, value);
+    logger.debug("String_Node_Str", fromType, value);
     try {


Input:
public void onPlayerTick(PlayerTickEvent event) {
    if (event.phase == Phase.START && !event.player.getEntityWorld().isRemote) {
        if (ticks % 20 == 0) {
            PlayerInformation playerInfo = (PlayerInformation) event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION, null);
            if (playerInfo != null) {
                if (event.player.inventory.getCurrentItem() != mainhand && playerInfo.getPlayerLevel() >= NBTHelper.loadStackNBT(event.player.inventory.getCurrentItem()).getInteger("String_Node_Str")) {
                    updateStats(event.player, playerInfo);
                    mainhand = event.player.inventory.getCurrentItem();
                }
                for (ItemStack stack : event.player.inventory.armorInventory) {
                    if (stack.getItem() instanceof ItemArmor && playerInfo.getPlayerLevel() >= NBTHelper.loadStackNBT(stack).getInteger("String_Node_Str")) {
                        if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.HEAD && stack != helmet) {
                            updateStats(event.player, playerInfo);
                            helmet = stack;
                        } else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.CHEST && stack != chestplate) {
                            updateStats(event.player, playerInfo);
                            chestplate = stack;
                        } else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.LEGS && stack != leggings) {
                            updateStats(event.player, playerInfo);
                            leggings = stack;
                        } else if (((ItemArmor) stack.getItem()).getEquipmentSlot() == EntityEquipmentSlot.FEET && stack != boots) {
                            updateStats(event.player, playerInfo);
                            boots = stack;
                        }
                    }
                }
            }
            ticks = 0;
        }
        if (regenTicks % 100 == 0) {
            Stats statsCap = (Stats) event.player.getCapability(CapabilityPlayerStats.STATS, null);
            if (statsCap != null) {
                if (statsCap.getMana() < statsCap.getMaxMana()) {
                    statsCap.increaseMana(statsCap.getManaPerSecond());
                }
                if (event.player.getHealth() < event.player.getMaxHealth()) {
                    event.player.heal(statsCap.getHealthPerSecond());
                }
                LostEclipse.network.sendTo(new PacketUpdateStats(statsCap), (EntityPlayerMP) event.player);
            }
            regenTicks = 0;
        }
        ticks++;
        regenTicks++;
    }
}

Output:
     if (event.phase == Phase.START && !event.player.getEntityWorld().isRemote) {
-        if (ticks % 20 == 0) {
+        if (ticks % 10 == 0) {
             PlayerInformation playerInfo = (PlayerInformation) event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION, null);


Input:
public void addIDPickingListener(IPickingListener pickingListener, String pickingType, int pickedObjectID) {
    HashMap<Integer, Set<IPickingListener>> map = idPickingListeners.get(pickingType);
    if (map == null) {
        map = new HashMap<Integer, Set<IPickingListener>>();
        idPickingListeners.put(pickingType, map);
    }
    Set<IPickingListener> pickingListeners = map.get(pickedObjectID);
    if (pickingListeners == null) {
        pickingListeners = new HashSet<IPickingListener>();
    }
    for (IPickingListener listener : pickingListeners) {
        if (listener.getClass() == pickingListener.getClass()) {
            return;
        }
    }
    pickingListeners.add(pickingListener);
    map.put(pickedObjectID, pickingListeners);
}

Output:
     for (IPickingListener listener : pickingListeners) {
-        if (listener.getClass() == pickingListener.getClass()) {
+        if (listener == pickingListener) {
             return;


Input:
private Long shiftDown(Long position) {
    return new Long(position >> 8);
}

Output:
 private Long shiftDown(Long position) {
-    return new Long(position >> 8);
+    return new Long(position >>> 8);
 }


Input:
protected void createColumnNameFilter() {
    if (mapperManager.isAdvancedMap() && getDataMapTable() instanceof AbstractInOutTable) {
        final AbstractInOutTable table = (AbstractInOutTable) getDataMapTable();
        IPreferenceStore preferenceStore = CorePlugin.getDefault().getPreferenceStore();
        filterImageLabel = new Label(getCenterComposite(), SWT.NONE);
        filterImageLabel.setImage(ImageProviderMapper.getImage(ImageInfo.TMAP_FILTER_ICON));
        filterImageLabel.setVisible(table.isActivateColumnNameFilter());
        filterImageLabel.setToolTipText(Messages.getString("String_Node_Str"));
        columnNameTextFilter = new UnnotifiableColorStyledText(getCenterComposite(), SWT.BORDER, preferenceStore, LanguageManager.getCurrentLanguage().getName());
        if (mapperManager.componentIsReadOnly()) {
            columnNameTextFilter.setEditable(false);
            filterImageLabel.setEnabled(false);
        }
        GridData gridData1 = new GridData();
        gridData1.exclude = !table.isActivateColumnNameFilter();
        gridData1.horizontalAlignment = GridData.HORIZONTAL_ALIGN_CENTER;
        filterImageLabel.setLayoutData(gridData1);
        GridData nameFilterTextGridData = new GridData(GridData.FILL_HORIZONTAL);
        nameFilterTextGridData.minimumHeight = 10;
        nameFilterTextGridData.heightHint = 15;
        nameFilterTextGridData.minimumWidth = 25;
        nameFilterTextGridData.widthHint = 50;
        columnNameTextFilter.setLayoutData(nameFilterTextGridData);
        columnNameTextFilter.setText("String_Node_Str");
        columnNameTextFilter.setVisible(table.isActivateColumnNameFilter());
        nameFilterTextGridData.exclude = !table.isActivateColumnNameFilter();
        columnNameTextFilter.setBackground(ColorProviderMapper.getColor(ColorInfo.COLOR_BACKGROUND_VALID_EXPRESSION_CELL));
        columnNameTextFilter.setForeground(ColorProviderMapper.getColor(ColorInfo.COLOR_FOREGROUND_VALID_EXPRESSION_CELL));
        columnNameTextFilter.addControlListener(new ControlListener() {
            public void controlMoved(ControlEvent e) {
                redrawColumnNameFilter();
            }
            public void controlResized(ControlEvent e) {
                redrawColumnNameFilter();
            }
        });
        ColumnNameEditorToMapperStyledTextKeyListener keyAndModifyListener = new ColumnNameEditorToMapperStyledTextKeyListener(columnNameTextFilter, mapperManager.getUiManager().getTabFolderEditors().getStyledTextHandler());
        columnNameTextFilter.addExtendedModifyListener(keyAndModifyListener);
        columnNameTextFilter.addKeyListener(keyAndModifyListener);
    }
}

Output:
         });
-        ColumnNameEditorToMapperStyledTextKeyListener keyAndModifyListener = new ColumnNameEditorToMapperStyledTextKeyListener(columnNameTextFilter, mapperManager.getUiManager().getTabFolderEditors().getStyledTextHandler());
-        columnNameTextFilter.addExtendedModifyListener(keyAndModifyListener);
-        columnNameTextFilter.addKeyListener(keyAndModifyListener);
+        columnNameTextFilter.addModifyListener(new ModifyListener() {
+            public void modifyText(ModifyEvent e) {
+                parseColumnNameFilterRefresh();
+            }
+        });
     }


Input:
public void run(IProgressMonitor monitor) throws CoreException {
    Set<IRepositoryViewObject> selectedVersionItems = dialog.getSelectedVersionItems();
    String id = null;
    boolean isfirst = true;
    boolean needSys = true;
    try {
        for (IRepositoryViewObject object : selectedVersionItems) {
            Item selectedItem = object.getProperty().getItem();
            Item copy;
            copy = factory.copy(selectedItem, path, newJobName);
            if (isfirst) {
                id = copy.getProperty().getId();
                isfirst = false;
            }
            copy.getProperty().setId(id);
            if (needSys && item instanceof RoutineItem) {
                String lastestVersion = getLastestVersion(selectedVersionItems);
                if (lastestVersion.equals(copy.getProperty().getVersion())) {
                    synDuplicatedRoutine((RoutineItem) copy);
                    needSys = false;
                }
            }
            if (copy instanceof ProcessItem) {
                RelationshipItemBuilder.getInstance().addOrUpdateItem(copy);
            }
            if (copy instanceof ConnectionItem) {
                Connection connection = ((ConnectionItem) copy).getConnection();
                if (connection != null) {
                    connection.getSupplierDependency().clear();
                    connection.setLabel(newJobName);
                    connection.setName(newJobName);
                }
            }
            factory.save(copy);
            notifySQLExplorer(copy);
        }
    } catch (PersistenceException e) {
        throw new CoreException(new Status(IStatus.ERROR, "String_Node_Str", "String_Node_Str", e));
    } catch (BusinessException e) {
        throw new CoreException(new Status(IStatus.ERROR, "String_Node_Str", "String_Node_Str", e));
    }
}

Output:
                 if (lastestVersion.equals(copy.getProperty().getVersion())) {
-                    synDuplicatedRoutine((RoutineItem) copy);
+                    synDuplicatedRoutine((RoutineItem) copy, selectedItem.getProperty().getLabel());
                     needSys = false;