Input:
public Token add(pt.data.Token a) throws IllegalActionException {
    if (a instanceof StringToken) {
        String result = toString() + a.toString();
        return new StringToken(result);
    } else if (a instanceof ScalarToken) {
        _value = _value + ((ScalarToken) a).doubleValue();
        return new DoubleToken(_value);
    } else {
        String str = "String_Node_Str" + this.getClass().getName() + "String_Node_Str";
        str = str + a.getClass().getName();
        throw new IllegalActionException("String_Node_Str" + str);
    }
}

Output:
     } else if (a instanceof ScalarToken) {
-        _value = _value + ((ScalarToken) a).doubleValue();
-        return new DoubleToken(_value);
+        double tmp = _value + ((ScalarToken) a).doubleValue();
+        return new DoubleToken(tmp);
     } else {


Input:
public boolean isHandled(Class<?> klass) {
    if (PhaseListener.class.isAssignableFrom(klass)) {
        try {
            if (!_listeners.containsKey(klass.getName())) {
                _listeners.put(klass.getName(), (PhaseListener) klass.newInstance());
            }
        } catch (Exception e) {
            _log.error("String_Node_Str" + klass, e);
        }
        return true;
    }
    return false;
}

Output:
         try {
-            if (!_listeners.containsKey(klass.getName())) {
-                _listeners.put(klass.getName(), (PhaseListener) klass.newInstance());
+            synchronized (_listeners) {
+                if (!_listeners.containsKey(klass.getName())) {
+                    _listeners.put(klass.getName(), (PhaseListener) klass.newInstance());
+                }
             }


Input:
final boolean goInDirection(EDirection direction, boolean force) {
    ShortPoint2D targetPosition = direction.getNextHexPoint(position);
    if (force) {
        this.direction = direction;
        setState(EMovableState.PATHING);
        this.followPath(new Path(targetPosition));
        return true;
    } else if ((grid.isValidPosition(this, targetPosition) && grid.hasNoMovableAt(targetPosition.x, targetPosition.y))) {
        initGoingSingleStep(targetPosition);
        setState(EMovableState.GOING_SINGLE_STEP);
        return true;
    } else {
        return false;
    }
}

Output:
     ShortPoint2D targetPosition = direction.getNextHexPoint(position);
-    if (force) {
-        this.direction = direction;
-        setState(EMovableState.PATHING);
-        this.followPath(new Path(targetPosition));
-        return true;
-    } else if ((grid.isValidPosition(this, targetPosition) && grid.hasNoMovableAt(targetPosition.x, targetPosition.y))) {
-        initGoingSingleStep(targetPosition);
-        setState(EMovableState.GOING_SINGLE_STEP);
-        return true;
-    } else {
-        return false;
+    switch(mode) {
+        case GO_IF_ALLOWED_WAIT_TILL_FREE:
+            {
+                this.direction = direction;
+                setState(EMovableState.PATHING);
+                this.followPath(new Path(targetPosition));
+                return true;
+            }
+        case GO_IF_ALLOWED_AND_FREE:
+            if ((grid.isValidPosition(this, targetPosition) && grid.hasNoMovableAt(targetPosition.x, targetPosition.y))) {
+                initGoingSingleStep(targetPosition);
+                setState(EMovableState.GOING_SINGLE_STEP);
+                return true;
+            } else {
+                break;
+            }
+        case GO_IF_FREE:
+            if (grid.isFreePosition(targetPosition)) {
+                initGoingSingleStep(targetPosition);
+                setState(EMovableState.GOING_SINGLE_STEP);
+                return true;
+            } else {
+                break;
+            }
     }


Input:
public BoundedSet<SymbolicAddress> getStack(int index) {
    if (this == TOP)
        return bsFactory.top();
    Location stackLoc = new Location(index);
    BoundedSet<SymbolicAddress> val = map.get(stackLoc);
    if (val == null)
        throw new AssertionError("String_Node_Str" + index);
    return val;
}

Output:
 public BoundedSet<SymbolicAddress> getStack(int index) {
-    if (this == TOP)
+    if (this.isTop())
         return bsFactory.top();


Input:
private List<LibrarySelection> findLibrarySelections() throws IOException, JAXBException {
    JaxbObject<LibrarySelectionList> jaxb = new JaxbObject<LibrarySelectionList>();
    LibrarySelectionList list = (LibrarySelectionList) findObject("String_Node_Str", "String_Node_Str", jaxb, new LibrarySelectionList());
    return list.getList();
}

Output:
     LibrarySelectionList list = (LibrarySelectionList) findObject("String_Node_Str", "String_Node_Str", jaxb, new LibrarySelectionList());
-    return list.getList();
+    if (list != null)
+        return list.getList();
+    return null;
 }


Input:
IResultClass getCachedResultClass(DataSourceAndDataSet dsAndDs) throws DataException {
    Object cacheObject = null;
    Object key = getKey(dsAndDs);
    if (key != null) {
        cacheObject = cacheMap.get(key);
    }
    if (cacheObject instanceof MemoryDataSetCacheObject) {
        return ((MemoryDataSetCacheObject) cacheObject).getResultClass();
    } else if (cacheObject instanceof DiskDataSetCacheObject) {
        IResultClass rsClass;
        FileInputStream fis1 = null;
        BufferedInputStream bis1 = null;
        try {
            fis1 = new FileInputStream(((DiskDataSetCacheObject) cacheObject).getMetaFile());
            bis1 = new BufferedInputStream(fis1);
            IOUtil.readInt(bis1);
            rsClass = new ResultClass(bis1);
            bis1.close();
            fis1.close();
            return rsClass;
        } catch (FileNotFoundException e) {
            throw new DataException(ResourceConstants.DATASETCACHE_LOAD_ERROR, e);
        } catch (IOException e) {
            throw new DataException(ResourceConstants.DATASETCACHE_LOAD_ERROR, e);
        }
    }
    return null;
}

Output:
 IResultClass getCachedResultClass(DataSourceAndDataSet dsAndDs) throws DataException {
-    Object cacheObject = null;
+    IDataSetCacheObject cacheObject = null;
     Object key = getKey(dsAndDs);


Input:
public Bitmap getBitmap() {
    Bitmap bm = mBitmapCache.get();
    if (bm == null) {
        bm = createThumbnailBitmap(THUMBNAIL_BOUNDS_LIMIT, getUri());
        mBitmapCache = new SoftReference<Bitmap>(bm);
    }
    return bm;
}

Output:
 public Bitmap getBitmap() {
-    Bitmap bm = mBitmapCache.get();
-    if (bm == null) {
-        bm = createThumbnailBitmap(THUMBNAIL_BOUNDS_LIMIT, getUri());
-        mBitmapCache = new SoftReference<Bitmap>(bm);
-    }
-    return bm;
+    return internalGetBitmap(getUri());
 }


Input:
public static Query getQueryByName(ConnectionItem item, String name) {
    if (item == null || name == null) {
        return null;
    }
    final Connection connection = item.getConnection();
    if (connection != null) {
        final QueriesConnection queryConn = connection.getQueries();
        if (queryConn != null) {
            final EList queries = queryConn.getQuery();
            if (queries != null) {
                for (Query query : (List<Query>) queries) {
                    Object object = query.getProperties().get("String_Node_Str");
                    if (object == null || (object != null && !object.equals(Boolean.TRUE.toString()))) {
                        if (query.getLabel().equals(name)) {
                            return query;
                        }
                    }
                }
            }
        }
    }
    return null;
}

Output:
                 for (Query query : (List<Query>) queries) {
-                    Object object = query.getProperties().get("String_Node_Str");
-                    if (object == null || (object != null && !object.equals(Boolean.TRUE.toString()))) {
-                        if (query.getLabel().equals(name)) {
-                            return query;
-                        }
+                    if (query.getLabel().equals(name)) {
+                        return query;
                     }


Input:
public boolean apply(Game game, Ability source) {
    ExileZone exile = game.getExile().getExileZone(exileId);
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null && exile != null) {
        if (zone == Zone.GRAVEYARD) {
            controller.moveCards(exile, zone, Zone.EXILED, source, game);
        } else {
            exile = exile.copy();
            for (UUID cardId : exile) {
                Card card = game.getCard(cardId);
                Player owner = game.getPlayer(card.getOwnerId());
                if (owner != null) {
                    switch(zone) {
                        case BATTLEFIELD:
                            card.moveToZone(zone, source.getSourceId(), game, tapped);
                            if (!game.isSimulation()) {
                                game.informPlayers(controller.getLogName() + "String_Node_Str" + card.getName() + "String_Node_Str" + zone.toString().toLowerCase());
                            }
                            break;
                        case HAND:
                            controller.moveCards(card, Zone.EXILED, Zone.HAND, source, game);
                            break;
                        case LIBRARY:
                            controller.moveCardToLibraryWithInfo(card, source.getSourceId(), game, Zone.EXILED, true, true);
                            break;
                        case GRAVEYARD:
                            controller.moveCards(card, Zone.EXILED, Zone.GRAVEYARD, source, game);
                            break;
                        default:
                            card.moveToZone(zone, source.getSourceId(), game, tapped);
                            if (!game.isSimulation()) {
                                game.informPlayers(controller.getLogName() + "String_Node_Str" + card.getName() + "String_Node_Str" + zone.toString().toLowerCase());
                            }
                    }
                }
            }
            game.getExile().getExileZone(exileId).clear();
        }
        return true;
    }
    return false;
}

Output:
                             if (!game.isSimulation()) {
-                                game.informPlayers(controller.getLogName() + "String_Node_Str" + card.getName() + "String_Node_Str" + zone.toString().toLowerCase());
+                                game.informPlayers(controller.getLogName() + "String_Node_Str" + card.getLogName() + "String_Node_Str" + zone.toString().toLowerCase());
                             }


Input:
private void startSendStreams() {
    if (!sendStreamsAreCreated)
        createSendStreams();
    RTPManager rtpManager = getRTPManager();
    Iterable<SendStream> sendStreams = rtpManager.getSendStreams();
    if (sendStreams != null)
        for (SendStream sendStream : sendStreams) try {
            sendStream.getDataSource().connect();
            sendStream.start();
            sendStream.getDataSource().start();
            if (logger.isTraceEnabled())
                logger.trace("String_Node_Str" + "String_Node_Str" + sendStream.hashCode());
        } catch (IOException ioe) {
            logger.warn("String_Node_Str" + sendStream, ioe);
        }
}

Output:
     Iterable<SendStream> sendStreams = rtpManager.getSendStreams();
-    if (sendStreams != null)
-        for (SendStream sendStream : sendStreams) try {
-            sendStream.getDataSource().connect();
-            sendStream.start();
-            sendStream.getDataSource().start();
-            if (logger.isTraceEnabled())
-                logger.trace("String_Node_Str" + "String_Node_Str" + sendStream.hashCode());
-        } catch (IOException ioe) {
-            logger.warn("String_Node_Str" + sendStream, ioe);
+    if (sendStreams != null) {
+        for (SendStream sendStream : sendStreams) {
+            try {
+                sendStream.getDataSource().connect();
+                sendStream.start();
+                sendStream.getDataSource().start();
+                if (logger.isTraceEnabled()) {
+                    logger.trace("String_Node_Str" + sendStream.hashCode());
+                }
+            } catch (IOException ioe) {
+                logger.warn("String_Node_Str" + sendStream, ioe);
+            }
         }


Input:
public void update() {
    super.update();
    List<EntityPlayer> viablePlayers = dragon.attacks.getViablePlayers();
    if (++summonTimer > 35 - Math.min(viablePlayers.size() * 4 + (ModCommonProxy.opMobs ? 5 : 0), 20)) {
        summonTimer = 0;
        boolean didSummon = false;
        for (int amt = MathUtil.clamp(MathUtil.ceil(viablePlayers.size() * (0.2D + rand.nextDouble() * 0.25D)), 1, viablePlayers.size()), aggro = 0; amt > 0; amt--) {
            EntityPlayer player = viablePlayers.remove(rand.nextInt(viablePlayers.size()));
            for (EntityMobAngryEnderman enderman : (List<EntityMobAngryEnderman>) dragon.worldObj.getEntitiesWithinAABB(EntityMobAngryEnderman.class, player.boundingBox.expand(7D, 3D, 7D))) {
                if (enderman.getEntityToAttack() == player)
                    ++aggro;
            }
            if (aggro < 1 + getDifficulty()) {
                boolean flying = true;
                for (int a = 0, xx = MathUtil.floor(player.posX), zz = MathUtil.floor(player.posZ), testY = MathUtil.floor(player.posY) - 1; a < 4; a++) {
                    if (!dragon.worldObj.isAirBlock(xx, testY - a, zz)) {
                        flying = false;
                        break;
                    }
                }
                if (flying) {
                    if (lastStriked.adjustOrPutValue(player.getPersistentID(), (byte) -1, (byte) 0) <= 0) {
                        player.attackEntityFrom(DamageSource.magic, 1F);
                        player.hurtResistantTime = 0;
                        player.attackEntityFrom(DamageSource.causeMobDamage(dragon), 7F);
                        player.setFire(5);
                        dragon.worldObj.addWeatherEffect(new EntityWeatherLightningBoltSafe(dragon.worldObj, player.posX, player.posY, player.posZ));
                        lastStriked.put(player.getPersistentID(), (byte) (2 + rand.nextInt(3)));
                    }
                    continue;
                }
                for (int a = 0; a < 3 + rand.nextInt(2 + getDifficulty()); a++) {
                    double x = player.posX + (rand.nextDouble() - 0.5D) * 11D, z = player.posZ + (rand.nextDouble() - 0.5D) * 11D;
                    int y = 1 + DragonUtil.getTopBlockY(dragon.worldObj, Blocks.end_stone, MathUtil.floor(x), MathUtil.floor(z), MathUtil.floor(player.posY + 8));
                    EntityMobAngryEnderman enderman = new EntityMobAngryEnderman(dragon.worldObj);
                    enderman.setPosition(x, y, z);
                    enderman.setTarget(player);
                    if ((getDifficulty() > 1 || ModCommonProxy.opMobs) && rand.nextInt(100) < 5 + getDifficulty() * 10 + (ModCommonProxy.opMobs ? 25 : 0)) {
                        enderman.addPotionEffect(new PotionEffect(Potion.damageBoost.id, 2400, 0, true));
                    }
                    dragon.worldObj.addWeatherEffect(new EntityWeatherLightningBoltSafe(dragon.worldObj, x, y, z));
                    dragon.worldObj.spawnEntityInWorld(enderman);
                }
                didSummon = true;
            }
        }
        if (didSummon && ++summoned > 5 + getDifficulty())
            ended = true;
    }
}

Output:
         boolean didSummon = false;
-        for (int amt = MathUtil.clamp(MathUtil.ceil(viablePlayers.size() * (0.2D + rand.nextDouble() * 0.25D)), 1, viablePlayers.size()), aggro = 0; amt > 0; amt--) {
+        for (int amt = MathUtil.clamp(MathUtil.ceil(viablePlayers.size() * (0.2D + rand.nextDouble() * 0.25D)), 1, viablePlayers.size()), aggro = 0, total = 0; amt > 0; amt--) {
             EntityPlayer player = viablePlayers.remove(rand.nextInt(viablePlayers.size()));


Input:
public byte[] getPicture() {
    return picture;
}

Output:
 public byte[] getPicture() {
-    return picture;
+    return Arrays.copyOf(picture, picture.length);
 }


Input:
public synchronized void startMatch() {
    if (table.getState() == TableState.STARTING) {
        try {
            User user = UserManager.getInstance().getUser(userId);
            logger.info(new StringBuilder("String_Node_Str").append(user.getName()).append("String_Node_Str").append(match.getId()));
            match.startMatch();
            startGame(null);
        } catch (GameException ex) {
            logger.fatal("String_Node_Str", ex);
            match.endGame();
        }
    }
}

Output:
         try {
-            User user = UserManager.getInstance().getUser(userId);
-            logger.info(new StringBuilder("String_Node_Str").append(user.getName()).append("String_Node_Str").append(match.getId()));
+            String tableInfo;
+            if (table.isTournamentSubTable()) {
+                tableInfo = "String_Node_Str" + table.getTournament().getId() + "String_Node_Str";
+            } else {
+                User user = UserManager.getInstance().getUser(userId);
+                tableInfo = "String_Node_Str" + user.getName();
+            }
+            logger.info(new StringBuilder(tableInfo).append("String_Node_Str").append(match.getId()));
             match.startMatch();


Input:
private static LoggerFactory createFactory(int library) throws ClassNotFoundException {
    String loggerClassName = LIBINIT[library * 2];
    String factoryType = LIBINIT[library * 2 + 1];
    try {
        ClassUtil.forName(loggerClassName);
        return (LoggerFactory) Class.forName("String_Node_Str" + factoryType + "String_Node_Str").newInstance();
    } catch (IllegalAccessException e) {
        throw new IllegalAccessError(e.getMessage());
    } catch (InstantiationException e) {
        throw new InstantiationError(e.getMessage());
    }
}

Output:
     try {
-        ClassUtil.forName(loggerClassName);
+        Class.forName(loggerClassName);
         return (LoggerFactory) Class.forName("String_Node_Str" + factoryType + "String_Node_Str").newInstance();


Input:
public String toString() {
    if (this == registry.getNativeType(JSTypeNative.FUNCTION_INSTANCE_TYPE)) {
        return "String_Node_Str";
    }
    StringBuilder b = new StringBuilder(32);
    b.append("String_Node_Str");
    int paramNum = call.parameters.getChildCount();
    boolean hasKnownTypeOfThis = !typeOfThis.isUnknownType();
    if (hasKnownTypeOfThis) {
        if (isConstructor()) {
            b.append("String_Node_Str");
        } else {
            b.append("String_Node_Str");
        }
        b.append(typeOfThis.toString());
    }
    if (paramNum > 0) {
        if (hasKnownTypeOfThis) {
            b.append("String_Node_Str");
        }
        Node p = call.parameters.getFirstChild();
        if (p.isVarArgs()) {
            appendVarArgsString(b, p.getJSType());
        } else {
            b.append(p.getJSType().toString());
        }
        p = p.getNext();
        while (p != null) {
            b.append("String_Node_Str");
            if (p.isVarArgs()) {
                appendVarArgsString(b, p.getJSType());
            } else {
                b.append(p.getJSType().toString());
            }
            p = p.getNext();
        }
    }
    b.append("String_Node_Str");
    b.append(call.returnType);
    return b.toString();
}

Output:
 public String toString() {
-    if (this == registry.getNativeType(JSTypeNative.FUNCTION_INSTANCE_TYPE)) {
+    if (!isPrettyPrint() || this == registry.getNativeType(JSTypeNative.FUNCTION_INSTANCE_TYPE)) {
         return "String_Node_Str";


Input:
public String getLocalizedMessage() {
    if (infoCode == CONVERT_FOR_COLUMN_BINDING) {
        return ModelMessages.getMessage(CONVERT_INFO_MSG, new String[] { COLUMN_BINDING_FROM_VERSION, COLUMN_BINDING_FEATURE });
    }
    return ModelMessages.getMessage(INVALID_DESIGN_FILE_MSG);
}

Output:
     if (infoCode == CONVERT_FOR_COLUMN_BINDING) {
-        return ModelMessages.getMessage(CONVERT_INFO_MSG, new String[] { COLUMN_BINDING_FROM_VERSION, COLUMN_BINDING_FEATURE });
+        return ModelMessages.getMessage(CONVERT_INFO_MSG);
     }


Input:
public byte[][] splitToFrames(java.nio.ByteBuffer packet, int blockIndex, int[] index, int count, Command cmd, int resultChoice) {
    ByteArrayOutputStream tmp = new ByteArrayOutputStream();
    if (this.getInterfaceType() == InterfaceType.GENERAL && !(Ciphering.getSecurity() != Security.NONE && frameSequence != -1)) {
        try {
            if (getServer()) {
                tmp.write(GXCommon.LLCReplyBytes);
            } else {
                tmp.write(GXCommon.LLCSendBytes);
            }
        } catch (Exception ex) {
            throw new RuntimeException(ex.getMessage());
        }
    }
    if (cmd != Command.None && this.getUseLogicalNameReferencing()) {
        boolean moreBlocks = packet.limit() > getMaxReceivePDUSize() && packet.limit() > index[0] + count;
        tmp.write(cmd.getValue());
        tmp.write((byte) (moreBlocks ? 2 : 1));
        tmp.write(getInvokeIDPriority());
        if (getServer()) {
            tmp.write(resultChoice);
        }
        if (moreBlocks) {
            tmp.write((byte) blockIndex >> 8);
            tmp.write((byte) blockIndex & 0xFF);
            tmp.write((byte) 0);
            GXCommon.setObjectCount(count, tmp);
        }
    } else if (cmd != Command.None && !this.getUseLogicalNameReferencing()) {
        tmp.write((byte) cmd.getValue());
    }
    if (Ciphering.getSecurity() != Security.NONE && frameSequence != -1) {
        try {
            int cnt = count;
            if (count + index[0] > packet.limit()) {
                cnt = packet.limit() - index[0];
            }
            tmp.write(packet.array(), index[0], cnt);
        } catch (Exception ex) {
            throw new RuntimeException(ex.getMessage());
        }
        packet.clear();
        Ciphering.setFrameCounter(Ciphering.getFrameCounter() + 1);
        Command gloCmd;
        if (cmd == Command.ReadRequest || cmd == Command.GetRequest) {
            gloCmd = Command.GloGetRequest;
        } else if (cmd == Command.WriteRequest || cmd == Command.SetRequest) {
            gloCmd = Command.GloSetRequest;
        } else if (cmd == Command.MethodRequest) {
            gloCmd = Command.GloMethodRequest;
        } else if (cmd == Command.ReadResponse || cmd == Command.GetResponse) {
            gloCmd = Command.GloGetResponse;
        } else if (cmd == Command.WriteResponse || cmd == Command.SetResponse) {
            gloCmd = Command.GloSetResponse;
        } else if (cmd == Command.MethodResponse) {
            gloCmd = Command.GloMethodResponse;
        } else {
            throw new GXDLMSException("String_Node_Str");
        }
        byte[] tmp2 = tmp.toByteArray();
        packet = java.nio.ByteBuffer.wrap(GXDLMSChippering.EncryptAesGcm(gloCmd, Ciphering.getSecurity(), Ciphering.getFrameCounter(), Ciphering.getSystemTitle(), Ciphering.getBlockCipherKey(), Ciphering.getAuthenticationKey(), tmp2));
        packet.position(packet.limit());
        count = packet.position();
        tmp.reset();
        try {
            if (this.getInterfaceType() == InterfaceType.GENERAL) {
                if (getServer()) {
                    tmp.write(GXCommon.LLCReplyBytes);
                } else {
                    tmp.write(GXCommon.LLCSendBytes);
                }
            }
        } catch (Exception ex) {
            throw new RuntimeException(ex.getMessage());
        }
    }
    int dataSize;
    if (this.getInterfaceType() == InterfaceType.NET) {
        dataSize = getMaxReceivePDUSize();
    } else {
        if (cmd == Command.GetRequest || cmd == Command.MethodRequest || cmd == Command.ReadRequest || cmd == Command.SetRequest || cmd == Command.WriteRequest) {
            dataSize = GXCommon.intValue(getLimits().getMaxInfoTX());
        } else {
            dataSize = GXCommon.intValue(getLimits().getMaxInfoRX());
        }
    }
    if (count + index[0] > packet.limit()) {
        count = packet.limit() - index[0];
    }
    packet.position(index[0]);
    byte[] tmp2 = new byte[count];
    packet.get(tmp2);
    try {
        tmp.write(tmp2);
    } catch (Exception ex) {
        throw new RuntimeException(ex.getMessage());
    }
    index[0] += count;
    count = tmp.size();
    if (count < dataSize) {
        dataSize = count;
    }
    int cnt = (int) (count / dataSize);
    if (count % dataSize != 0) {
        ++cnt;
    }
    int start = 0;
    byte[][] buff = new byte[cnt][];
    for (int pos = 0; pos < cnt; ++pos) {
        byte id;
        if (pos == 0) {
            id = generateIFrame();
        } else {
            id = generateNextFrame();
        }
        if (start + dataSize > count) {
            dataSize = count - start;
        }
        buff[pos] = addFrame(id, cnt != 1 && pos < cnt - 1, tmp.toByteArray(), start, dataSize);
        start += dataSize;
    }
    return buff;
}

Output:
         tmp.write(cmd.getValue());
-        tmp.write((byte) (moreBlocks ? 2 : 1));
+        if (asList) {
+            tmp.write((byte) 3);
+        } else {
+            tmp.write((byte) (moreBlocks ? 2 : 1));
+        }
         tmp.write(getInvokeIDPriority());


Input:
private static void simpleThreadingTest() {
    AtomicInteger ai = new AtomicInteger();
    int num = 4;
    final Random random = new Random();
    final CountDownLatch latch = new CountDownLatch(4);
    for (int i = 0; i < num; i++) {
        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(100 + random.nextInt(50));
                } catch (InterruptedException e) {
                    throw new AssertionError(e);
                }
                ai.getAndIncrement();
                latch.countDown();
            }
        }).start();
    }
    try {
        latch.await();
    } catch (InterruptedException e) {
        throw new AssertionError(e);
    }
    System.out.println("String_Node_Str" + num + "String_Node_Str" + ai);
}

Output:
     AtomicInteger ai = new AtomicInteger();
-    int num = 4;
+    int num = 40;
     final Random random = new Random();


Input:
public boolean doInteraction(Object arg) {
    if (getBooleanProperty(PROPERTY_DISABLED, false)) {
        logger.info("String_Node_Str");
        return false;
    }
    int waitForReturn = getIntegerProperty(PROPERTY_WAIT_FOR_RETURN, 0);
    String executeIn = Replacer.insertVariables(getStringProperty(PROPERTY_EXECUTE_FOLDER));
    String command = Replacer.insertVariables(getStringProperty(PROPERTY_COMMAND));
    String parameter = Replacer.insertVariables(getStringProperty(PROPERTY_PARAMETER));
    logger.finer("String_Node_Str" + JDUtilities.runCommand(command, parameter, executeIn, waitForReturn));
    return true;
}

Output:
     String parameter = Replacer.insertVariables(getStringProperty(PROPERTY_PARAMETER));
-    logger.finer("String_Node_Str" + JDUtilities.runCommand(command, parameter, executeIn, waitForReturn));
+    logger.finer("String_Node_Str" + JDUtilities.runCommand(command, JDUtilities.splitByNewline(parameter), executeIn, waitForReturn));
     return true;


Input:
NativeEvaluator createEvaluator(RolapEvaluator evaluator, FunDef fun, Exp[] args) {
    if (!isEnabled()) {
        return null;
    }
    if (!FilterConstraint.isValidContext(evaluator, restrictMemberTypes())) {
        return null;
    }
    String funName = fun.getName();
    if (!"String_Node_Str".equalsIgnoreCase(funName)) {
        return null;
    }
    if (args.length != 2) {
        return null;
    }
    List<CrossJoinArg[]> allArgs = crossJoinArgFactory().checkCrossJoinArg(evaluator, args[0]);
    if (allArgs == null || allArgs.isEmpty() || allArgs.get(0) == null) {
        return null;
    }
    CrossJoinArg[] cjArgs = allArgs.get(0);
    if (isPreferInterpreter(cjArgs, false)) {
        return null;
    }
    SchemaReader schemaReader = evaluator.getSchemaReader();
    DataSource ds = schemaReader.getDataSource();
    SqlQuery sqlQuery = SqlQuery.newQuery(ds, "String_Node_Str");
    RolapNativeSql sql = new RolapNativeSql(sqlQuery, null, evaluator, cjArgs[0].getLevel());
    final Exp filterExpr = args[1];
    String filterExprStr = sql.generateFilterCondition(filterExpr);
    if (filterExprStr == null) {
        return null;
    }
    if (SqlConstraintUtils.containsCalculatedMember(evaluator.getNonAllMembers(), true)) {
        return null;
    }
    LOGGER.debug("String_Node_Str");
    final int savepoint = evaluator.savepoint();
    try {
        overrideContext(evaluator, cjArgs, sql.getStoredMeasure());
        if (!evaluator.isNonEmpty() && sql.getStoredMeasure() == null) {
            for (Member m : evaluator.getMembers()) {
                evaluator.setContext(m.getLevel().getHierarchy().getDefaultMember());
            }
        }
        CrossJoinArg[] combinedArgs = cjArgs;
        if (allArgs.size() == 2) {
            CrossJoinArg[] predicateArgs = allArgs.get(1);
            if (predicateArgs != null) {
                combinedArgs = Util.appendArrays(cjArgs, predicateArgs);
            }
        }
        TupleConstraint constraint = new FilterConstraint(combinedArgs, evaluator, filterExpr);
        return new SetEvaluator(cjArgs, schemaReader, constraint);
    } finally {
        evaluator.restore(savepoint);
    }
}

Output:
     }
-    if (SqlConstraintUtils.containsCalculatedMember(evaluator.getNonAllMembers(), true)) {
+    if (SqlConstraintUtils.containsCalculatedMember(Arrays.asList(evaluator.getNonAllMembers()), true)) {
         return null;


Input:
protected void handleDestinationBrowseButtonPressed() {
    FileDialog dialog = new FileDialog(getContainer().getShell(), SWT.SAVE);
    dialog.setFilterExtensions(new String[] { "String_Node_Str", "String_Node_Str" });
    dialog.setText("String_Node_Str");
    dialog.setFileName(this.getDefaultFileName().get(0));
    String currentSourceString = getDestinationValue();
    int lastSeparatorIndex = currentSourceString.lastIndexOf(File.separator);
    if (lastSeparatorIndex != -1) {
        dialog.setFilterPath(currentSourceString.substring(0, lastSeparatorIndex));
    }
    String selectedFileName = dialog.open();
    if (selectedFileName != null && !selectedFileName.endsWith(this.getOutputSuffix()))
        selectedFileName += this.getOutputSuffix();
    if (selectedFileName != null && !selectedFileName.endsWith(this.getSelectedJobVersion() + this.getOutputSuffix())) {
        String b = selectedFileName.substring(0, (selectedFileName.length() - 4));
        File file = new File(b);
        String str = file.getName();
        String s = this.getDefaultFileName().get(0);
        if (str.equals(s)) {
            selectedFileName = b + "String_Node_Str" + this.getDefaultFileName().get(1) + this.getOutputSuffix();
        } else {
            selectedFileName = b + this.getOutputSuffix();
        }
    }
    if (selectedFileName != null) {
        setErrorMessage(null);
        setDestinationValue(selectedFileName);
    }
}

Output:
     String selectedFileName = dialog.open();
-    if (selectedFileName != null && !selectedFileName.endsWith(this.getOutputSuffix()))
+    if (selectedFileName != null && !selectedFileName.endsWith(this.getOutputSuffix())) {
         selectedFileName += this.getOutputSuffix();


Input:
private void checkDetected_LensDistortion(Class imageType, double tol) {
    renderDistortedRectangle(imageType);
    Affine2D_F32 a = new Affine2D_F32();
    UtilAffine.convert(transform, a);
    PixelTransform_F32 tranFrom = new PixelTransformAffine_F32(a);
    PixelTransform_F32 tranTo = new PixelTransformAffine_F32(a.invert(null));
    int numberOfSides = 4;
    BinaryPolygonConvexDetector alg = createDetector(imageType, numberOfSides);
    alg.setLensDistortion(dist.width, dist.height, tranTo, tranFrom);
    alg.process(dist);
    FastQueue<Polygon2D_F64> found = alg.getFound();
    assertEquals(rectangles.size(), found.size);
    for (int i = 0; i < found.size; i++) {
        assertEquals(1, findMatchesOriginal(found.get(i), tol));
    }
}

Output:
     int numberOfSides = 4;
-    BinaryPolygonConvexDetector alg = createDetector(imageType, numberOfSides);
+    BinaryPolygonConvexDetector alg = createDetector(imageType, numberOfSides, useLines);
     alg.setLensDistortion(dist.width, dist.height, tranTo, tranFrom);


Input:
public void updateConfigGroupName(AmNodeGroupDef nodeGroup) {
    String configGroupName = nodeGroup.getName();
    if (!AmUtils.isAmbariServerBelow_2_0_0(this.ambariServerVersion)) {
        configGroupName = nodeGroup.getClusterName() + "String_Node_Str" + nodeGroup.getName();
    }
    this.configGroupName = configGroupName;
}

Output:
     String configGroupName = nodeGroup.getName();
-    if (!AmUtils.isAmbariServerBelow_2_0_0(this.ambariServerVersion)) {
+    if (!AmUtils.isAmbariServerBelow_2_0_0(this.ambariServerVersion) && this.configTypeToService != null) {
         configGroupName = nodeGroup.getClusterName() + "String_Node_Str" + nodeGroup.getName();


Input:
public void initialize(URI uri, Configuration conf) throws IOException {
    int logLevel = Logging.LEVEL_WARN;
    if (conf.getBoolean("String_Node_Str", false)) {
        logLevel = Logging.LEVEL_DEBUG;
    }
    String volumeName = conf.get("String_Node_Str");
    if (volumeName == null)
        throw new IOException("String_Node_Str" + "String_Node_Str");
    Logging.start(logLevel, Category.all);
    Logging.logMessage(Logging.LEVEL_DEBUG, this, "String_Node_Str" + uri);
    InetSocketAddress dir = new InetSocketAddress(uri.getHost(), uri.getPort());
    xtreemfsClient = new Client(new InetSocketAddress[] { dir }, 30 * 1000, 15 * 60 * 1000, null);
    try {
        xtreemfsClient.start();
    } catch (Exception ex) {
        throw new IOException("String_Node_Str", ex);
    }
    UserCredentials uc = null;
    if ((conf.get("String_Node_Str") != null) && (conf.get("String_Node_Str") != null)) {
        StringSet grps = new StringSet();
        grps.add(conf.get("String_Node_Str"));
        uc = new UserCredentials(conf.get("String_Node_Str"), grps, "String_Node_Str");
    }
    if (uc == null) {
        if (System.getenv("String_Node_Str") != null) {
            StringSet grps = new StringSet();
            grps.add("String_Node_Str");
            uc = new UserCredentials(System.getenv("String_Node_Str"), grps, "String_Node_Str");
        }
    }
    volume = xtreemfsClient.getVolume(volumeName, uc);
    fsURI = uri;
    Logging.logMessage(Logging.LEVEL_DEBUG, this, "String_Node_Str" + uri.getUserInfo());
}

Output:
             grps.add("String_Node_Str");
-            uc = new UserCredentials(System.getenv("String_Node_Str"), grps, "String_Node_Str");
+            uc = new UserCredentials(System.getProperty("String_Node_Str"), grps, "String_Node_Str");
         }


Input:
public IType getConcreteType(ITypeContext context) {
    if (this.lowerBound != null) {
        return this.lowerBound.getConcreteType(context);
    }
    WildcardType type = new WildcardType(this.position);
    type.upperBounds = new IType[this.upperBoundCount];
    type.upperBoundCount = this.upperBoundCount;
    for (int i = 0; i < this.upperBoundCount; i++) {
        type.upperBounds[i] = this.upperBounds[i].getConcreteType(context);
    }
    return type;
}

Output:
     }
-    WildcardType type = new WildcardType(this.position);
-    type.upperBounds = new IType[this.upperBoundCount];
-    type.upperBoundCount = this.upperBoundCount;
-    for (int i = 0; i < this.upperBoundCount; i++) {
-        type.upperBounds[i] = this.upperBounds[i].getConcreteType(context);
+    if (this.upperBound != null) {
+        WildcardType copy = new WildcardType(this.position);
+        copy.upperBound = this.upperBound.getConcreteType(context);
+        return copy;
     }


Input:
public SufficientStatistics createInitSufficientStatistics() {
    CompoundVector vectorSS = this.createEmtpyCompoundVector();
    double[] Xarray = { 0.0 };
    double[] Yarray = this.parents.stream().mapToDouble(w -> 0.0).toArray();
    RealVector XYRealVector = new ArrayRealVector(Xarray, Yarray);
    vectorSS.setXYbaseVector(XYRealVector);
    RealMatrix covRealmatrix = new Array2DRowRealMatrix(Yarray.length + 1, Yarray.length + 1);
    covRealmatrix = covRealmatrix.scalarAdd(1.0);
    vectorSS.setcovbaseVector(covRealmatrix);
    return vectorSS;
}

Output:
     RealMatrix covRealmatrix = new Array2DRowRealMatrix(Yarray.length + 1, Yarray.length + 1);
-    covRealmatrix = covRealmatrix.scalarAdd(1.0);
+    Random rand = new Random(0);
+    for (int i = 0; i < Yarray.length + 1; i++) {
+        for (int j = 0; j < Yarray.length + 1; j++) {
+            covRealmatrix.addToEntry(i, j, rand.nextDouble() + 0.01);
+        }
+    }
     vectorSS.setcovbaseVector(covRealmatrix);


Input:
public void renderMemoPad(final GL gl) {
    gl.glLoadName(MEMO_PAD_PICKING_ID);
    gl.glColor3f(0.5f, 0.5f, 0.5f);
    gl.glBegin(GL.GL_POLYGON);
    gl.glVertex3f(-0.7f, -1.5f, 0.0f);
    gl.glVertex3f(-0.7f, -2.3f, 0.0f);
    gl.glVertex3f(4.0f, -2.3f, 0.0f);
    gl.glVertex3f(4.0f, -1.5f, 0.0f);
    gl.glEnd();
    gl.glLineWidth(2);
    gl.glColor3f(0.2f, 0.2f, 0.2f);
    gl.glBegin(GL.GL_LINE_LOOP);
    gl.glVertex3f(-0.7f, -1.5f, 0.0f);
    gl.glVertex3f(-0.7f, -2.3f, 0.0f);
    gl.glVertex3f(4.0f, -2.3f, 0.0f);
    gl.glVertex3f(4.0f, -1.5f, 0.0f);
    gl.glEnd();
    if (textRenderer == null)
        return;
    textRenderer.begin3DRendering();
    textRenderer.setColor(0.7f, 0.7f, 0.7f, 1.0f);
    textRenderer.draw3D("String_Node_Str", 1.3f, -2.2f, 0.01f, 0.005f);
    textRenderer.end3DRendering();
    Iterator<Integer> iterMemoPathwayIndex = memoPad.getElementList().iterator();
    while (iterMemoPathwayIndex.hasNext()) {
        int iPathwayId = iterMemoPathwayIndex.next();
        gl.glPushMatrix();
        Transform transform = memoPad.getTransformByElementId(iPathwayId);
        Vec3f translation = transform.getTranslation();
        gl.glTranslatef(translation.x(), translation.y(), translation.z());
        Vec3f scale = transform.getScale();
        gl.glScalef(scale.x(), scale.y(), scale.z());
        refGLPathwayTextureManager.renderPathway(gl, iPathwayId, 1f, false);
        float tmp = refGLPathwayTextureManager.getTextureByPathwayId(iPathwayId).getImageHeight() * GLPathwayManager.SCALING_FACTOR_Y;
        gl.glTranslatef(0, tmp, 0.01f);
        refGLPathwayManager.renderPathway(gl, iPathwayId, false);
        gl.glTranslatef(0, -tmp, 0.01f);
        gl.glPopMatrix();
    }
    renderTrashCan(gl);
}

Output:
     gl.glLoadName(MEMO_PAD_PICKING_ID);
-    gl.glColor3f(0.5f, 0.5f, 0.5f);
+    gl.glColor3f(0.7f, 0.7f, 0.7f);
     gl.glBegin(GL.GL_POLYGON);


Input:
public void actionOpenProject(String path) {
    if (!path.endsWith("String_Node_Str")) {
        path += "String_Node_Str";
    }
    WorkerLoad worker = null;
    try {
        worker = new WorkerLoad(path, this);
    } catch (final IOException e) {
        main.showInfoDialog(main.getShell(), Resources.getMessage("String_Node_Str"), e.getMessage());
        return;
    }
    main.showProgressDialog(Resources.getMessage("String_Node_Str"), worker);
    if (worker.getError() != null) {
        getResources().getLogger().info(worker.getError());
        main.showInfoDialog(main.getShell(), Resources.getMessage("String_Node_Str"), worker.getError().getMessage());
        return;
    }
    reset();
    model = worker.getResult();
    model.setPath(path);
    final ModelNodeFilter tempNodeFilter = model.getNodeFilter();
    final String tempSelectedAttribute = model.getSelectedAttribute();
    final ARXNode tempSelectedNode = model.getSelectedNode();
    final Set<ARXNode> tempClipboard = new HashSet<ARXNode>();
    if (model.getClipboard() == null) {
        model.setClipboard(new HashSet<ARXNode>());
    } else {
        tempClipboard.addAll(model.getClipboard());
    }
    update(new ModelEvent(this, ModelPart.MODEL, model));
    if (model.getInputConfig().getInput() != null) {
        update(new ModelEvent(this, ModelPart.INPUT, model.getInputConfig().getInput().getHandle()));
    }
    if (model.getResult() != null) {
        update(new ModelEvent(this, ModelPart.RESULT, model.getResult()));
    }
    if (tempSelectedNode != null) {
        model.setSelectedNode(tempSelectedNode);
        update(new ModelEvent(this, ModelPart.SELECTED_NODE, model.getSelectedNode()));
        final DataHandle handle = model.getResult().getOutput(tempSelectedNode, false);
        model.setOutput(handle, tempSelectedNode);
        update(new ModelEvent(this, ModelPart.OUTPUT, handle));
    }
    if (tempNodeFilter != null) {
        model.setNodeFilter(tempNodeFilter);
        update(new ModelEvent(this, ModelPart.FILTER, tempNodeFilter));
    }
    if (model.getInputConfig() != null && model.getInputConfig().getInput() != null) {
        DataHandle handle = model.getInputConfig().getInput().getHandle();
        if (handle != null) {
            for (int i = 0; i < handle.getNumColumns(); i++) {
                String attr = handle.getAttributeName(i);
                Hierarchy hierarchy = model.getInputConfig().getHierarchy(attr);
                if (hierarchy != null) {
                    model.setSelectedAttribute(attr);
                    update(new ModelEvent(this, ModelPart.HIERARCHY, hierarchy));
                }
            }
            if (handle.getNumColumns() > 0) {
                String attribute = handle.getAttributeName(0);
                model.setSelectedAttribute(attribute);
                update(new ModelEvent(this, ModelPart.SELECTED_ATTRIBUTE, attribute));
            }
        }
    }
    if (tempSelectedAttribute != null) {
        model.setSelectedAttribute(tempSelectedAttribute);
        update(new ModelEvent(this, ModelPart.SELECTED_ATTRIBUTE, tempSelectedAttribute));
    }
    if (tempClipboard != null) {
        model.getClipboard().clear();
        model.getClipboard().addAll(tempClipboard);
        update(new ModelEvent(this, ModelPart.CLIPBOARD, model.getClipboard()));
    }
    if (model.getInputConfig().getInput() != null) {
        final DataHandle handle = model.getInputConfig().getInput().getHandle();
        for (int i = 0; i < handle.getNumColumns(); i++) {
            update(new ModelEvent(this, ModelPart.ATTRIBUTE_TYPE, handle.getAttributeName(i)));
        }
    }
    update(new ModelEvent(this, ModelPart.RESEARCH_SUBSET, model.getInputConfig().getResearchSubset()));
    if (model.getOutput() != null) {
        update(new ModelEvent(this, ModelPart.VIEW_CONFIG, model.getOutput()));
    }
    model.setUnmodified();
}

Output:
     final ARXNode tempSelectedNode = model.getSelectedNode();
-    final Set<ARXNode> tempClipboard = new HashSet<ARXNode>();
-    if (model.getClipboard() == null) {
-        model.setClipboard(new HashSet<ARXNode>());
-    } else {
-        tempClipboard.addAll(model.getClipboard());
-    }
+    final List<ARXNode> tempClipboard = new ArrayList<ARXNode>();
+    tempClipboard.addAll(model.getClipboardEntries());
     update(new ModelEvent(this, ModelPart.MODEL, model));


Input:
public String request(LatLng start, LatLng end, String mode) {
    final String url = "String_Node_Str" + "String_Node_Str" + start.latitude + "String_Node_Str" + start.longitude + "String_Node_Str" + end.latitude + "String_Node_Str" + end.longitude + "String_Node_Str";
    if (isLogging)
        Log.i("String_Node_Str", "String_Node_Str" + url);
    new RequestTask().execute(new String[] { url });
    return url;
}

Output:
 public String request(LatLng start, LatLng end, String mode) {
-    final String url = "String_Node_Str" + "String_Node_Str" + start.latitude + "String_Node_Str" + start.longitude + "String_Node_Str" + end.latitude + "String_Node_Str" + end.longitude + "String_Node_Str";
+    final String url = "String_Node_Str" + "String_Node_Str" + start.latitude + "String_Node_Str" + start.longitude + "String_Node_Str" + end.latitude + "String_Node_Str" + end.longitude + "String_Node_Str" + mode;
     if (isLogging)


Input:
protected void channelRead0(ChannelHandlerContext ctx, FMLProxyPacket msg) throws Exception {
    Side side = ctx.channel().attr(NetworkRegistry.CHANNEL_SOURCE).get();
    NetworkManager manager = msg.getOrigin();
    if (msg.channel().equals("String_Node_Str") || msg.channel().equals("String_Node_Str")) {
        byte[] data = new byte[msg.payload().readableBytes()];
        msg.payload().readBytes(data);
        String channels = new String(data, Charsets.UTF_8);
        String[] split = channels.split("String_Node_Str");
        Set<String> channelSet = ImmutableSet.copyOf(split);
        FMLCommonHandler.instance().fireNetRegistrationEvent(manager, channelSet, msg.channel(), side);
    } else {
        ctx.fireChannelRead(msg);
    }
}

Output:
 protected void channelRead0(ChannelHandlerContext ctx, FMLProxyPacket msg) throws Exception {
-    Side side = ctx.channel().attr(NetworkRegistry.CHANNEL_SOURCE).get();
+    Side side = msg.getTarget();
     NetworkManager manager = msg.getOrigin();


Input:
public static void main(String[] args) throws FileNotFoundException, IOException {
    CommandOption.setSummary(SvmLight2Vectors.class, "String_Node_Str");
    CommandOption.process(SvmLight2Vectors.class, args);
    if (args.length == 0) {
        CommandOption.getList(SvmLight2Vectors.class).printUsage(false);
        System.exit(-1);
    }
    if (inputFiles == null) {
        throw new IllegalArgumentException("String_Node_Str" + "String_Node_Str");
    }
    Pipe instancePipe;
    InstanceList previousInstanceList = null;
    if (usePipeFromVectorsFile.wasInvoked()) {
        previousInstanceList = InstanceList.load(usePipeFromVectorsFile.value);
        instancePipe = previousInstanceList.getPipe();
    } else {
        ArrayList<Pipe> pipeList = new ArrayList<Pipe>();
        pipeList.add(new SvmLight2FeatureVectorAndLabel());
        if (printOutput.value) {
            pipeList.add(new PrintInputAndTarget());
        }
        instancePipe = new SerialPipes(pipeList);
    }
    if (inputFiles.value.length != outputFiles.value.length) {
        throw new RuntimeException("String_Node_Str");
    }
    for (int fileIndex = 0; fileIndex < inputFiles.value.length; fileIndex++) {
        InstanceList instances = new InstanceList(instancePipe);
        Reader fileReader;
        if (inputFiles.value[fileIndex].equals("String_Node_Str")) {
            fileReader = new InputStreamReader(System.in);
        } else {
            fileReader = new InputStreamReader(new FileInputStream(inputFiles.value[fileIndex]), encoding.value);
        }
        instances.addThruPipe(new SelectiveFileLineIterator(fileReader, "String_Node_Str"));
        ObjectOutputStream oos;
        if (outputFiles.value[fileIndex].toString().equals("String_Node_Str")) {
            oos = new ObjectOutputStream(System.out);
        } else {
            oos = new ObjectOutputStream(new FileOutputStream(outputFiles.value[fileIndex]));
        }
        oos.writeObject(instances);
        oos.close();
    }
    if (usePipeFromVectorsFile.wasInvoked()) {
        System.out.println("String_Node_Str" + usePipeFromVectorsFile.value);
        System.out.println("String_Node_Str" + previousInstanceList.getPipe().getInstanceId());
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(usePipeFromVectorsFile.value));
        oos.writeObject(previousInstanceList);
        oos.close();
    }
}

Output:
     for (int fileIndex = 0; fileIndex < inputFiles.value.length; fileIndex++) {
-        InstanceList instances = new InstanceList(instancePipe);
+        instances[fileIndex] = new InstanceList(instancePipe);
         Reader fileReader;


Input:
public GfoMsg Bld(byte[] src) {
    Gfs_nde nde = parser.Parse(src);
    return Bld_msg(src, nde);
}

Output:
 public GfoMsg Bld(byte[] src) {
-    Gfs_nde nde = parser.Parse(src);
-    return Bld_msg(src, nde);
+    synchronized (thread_lock) {
+        Gfs_nde nde = parser.Parse(src);
+        return Bld_msg(src, nde);
+    }
 }


Input:
public Map<Integer, Double> computeFeatureImportance() {
    Map<Integer, Double> importances = new HashMap<Integer, Double>();
    preOrder(importances, node);
    return importances;
}

Output:
     Map<Integer, Double> importances = new HashMap<Integer, Double>();
-    preOrder(importances, node);
+    double rootWgtCnt = node.getWgtCnt();
+    preOrder(importances, node, rootWgtCnt);
     return importances;


Input:
public void componentMoved(ComponentEvent e) {
    Object source = e.getSource();
    if (source == getDividerComponent()) {
        if (lastDividerLocation == -1 || lastDividerLocation == getDividerLocation()) {
            return;
        }
        lastDividerLocation = getDividerLocation();
        splitRatio = lastDividerLocation / (float) (getOrientation() == HORIZONTAL_SPLIT ? getWidth() : getHeight());
    }
}

Output:
 public void componentMoved(ComponentEvent e) {
-    Object source = e.getSource();
-    if (source == getDividerComponent()) {
-        if (lastDividerLocation == -1 || lastDividerLocation == getDividerLocation()) {
+    if (e.getSource() == getDividerComponent()) {
+        if (lastDividerLocation == -1) {
+            lastDividerLocation = getDividerLocation();
+            return;
+        } else if (lastDividerLocation == getDividerLocation())
             return;


Input:
public void directionalLight(float r, float g, float b, float nx, float ny, float nz) {
    if (!lights) {
        enableLighting();
    }
    if (lightCount == MAX_LIGHTS) {
        throw new RuntimeException("String_Node_Str" + MAX_LIGHTS + "String_Node_Str");
    }
    colorCalc(r, g, b);
    lightDiffuse[lightCount][0] = calcR;
    lightDiffuse[lightCount][1] = calcG;
    lightDiffuse[lightCount][2] = calcB;
    lightDiffuse[lightCount][3] = 1.0f;
    lightType[lightCount] = DIRECTIONAL;
    lightFalloffConstant[lightCount] = currentLightFalloffConstant;
    lightFalloffLinear[lightCount] = currentLightFalloffLinear;
    lightFalloffQuadratic[lightCount] = currentLightFalloffQuadratic;
    lightSpecular[lightCount][0] = currentLightSpecular[0];
    lightSpecular[lightCount][1] = currentLightSpecular[1];
    lightSpecular[lightCount][2] = currentLightSpecular[2];
    lightSpecular[lightCount][3] = currentLightSpecular[3];
    float invn = 1.0f / PApplet.dist(0, 0, 0, nx, ny, nz);
    lightNormal[lightCount][0] = invn * nx;
    lightNormal[lightCount][1] = invn * ny;
    lightNormal[lightCount][2] = invn * nz;
    lightNormal[lightCount][3] = 0.0f;
    lightEnable(lightCount);
    lightNoAmbient(lightCount);
    lightDirection(lightCount);
    lightDiffuse(lightCount);
    lightSpecular(lightCount);
    lightFalloff(lightCount);
    lightNoSpot(lightCount);
    lightCount++;
}

Output:
     lightSpecular[lightCount][3] = currentLightSpecular[3];
-    float invn = 1.0f / PApplet.dist(0, 0, 0, nx, ny, nz);
-    lightNormal[lightCount][0] = invn * nx;
-    lightNormal[lightCount][1] = invn * ny;
-    lightNormal[lightCount][2] = invn * nz;
+    lightNormal[lightCount][0] = -nx;
+    lightNormal[lightCount][1] = -ny;
+    lightNormal[lightCount][2] = -nz;
     lightNormal[lightCount][3] = 0.0f;


Input:
public void bindView(View v, Context context, Cursor cur) {
    ImageView checkv = (ImageView) v.findViewById(R.id.checkbtn);
    ImageView thumbnailv = (ImageView) v.findViewById(R.id.thumbnail);
    TextView titlev = (TextView) v.findViewById(R.id.title);
    TextView authorv = (TextView) v.findViewById(R.id.author);
    TextView playtmv = (TextView) v.findViewById(R.id.playtime);
    TextView uploadtmv = (TextView) v.findViewById(R.id.uploadedtime);
    int pos = cur.getPosition();
    checkv.setTag(VTAGKEY_POS, pos);
    checkv.setOnClickListener(mItemCheckOnClick);
    if (mCheckedMap.containsKey(pos))
        checkv.setImageResource(R.drawable.btncheck_on);
    else
        checkv.setImageResource(R.drawable.btncheck_off);
    titlev.setText(cur.getString(COLI_TITLE));
    String author = cur.getString(COLI_AUTHOR);
    if (Utils.isValidValue(author))
        authorv.setText(author);
    else
        authorv.setVisibility(View.GONE);
    uploadtmv.setVisibility(View.GONE);
    playtmv.setText(Utils.secsToMinSecText(cur.getInt(COLI_PLAYTIME)));
    byte[] thumbnailData = (byte[]) DB.get().getVideoInfo(cur.getString(COLI_VIDEOID), ColVideo.THUMBNAIL);
    UiUtils.setThumbnailImageView(thumbnailv, thumbnailData);
}

Output:
     String author = cur.getString(COLI_AUTHOR);
-    if (Utils.isValidValue(author))
+    if (Utils.isValidValue(author)) {
+        authorv.setVisibility(View.VISIBLE);
         authorv.setText(author);


Input:
void adjustLayoutSourceChildren(LinearLayout layoutSource, int count) {
    if (layoutSource.getChildCount() < count) {
        int offset = count - layoutSource.getChildCount();
        for (int i = 0; i < offset; i++) {
            View view;
            if (newsViewPool.isEmpty()) {
                view = mLayoutInflater.inflate(R.layout.item_topic_news, layoutSource, false);
            } else {
                view = newsViewPool.remove(0);
            }
            layoutSource.addView(view);
        }
    } else if (layoutSource.getChildCount() > count) {
        int offset = layoutSource.getChildCount() - count;
        for (int i = 0; i < offset; i++) {
            View view = layoutSource.getChildAt(0);
            layoutSource.removeView(view);
            newsViewPool.add(view);
        }
    }
}

Output:
             if (newsViewPool.isEmpty()) {
-                view = mLayoutInflater.inflate(R.layout.item_topic_news, layoutSource, false);
+                view = mLayoutInflater.inflate(R.layout.item_topic_news, null, false);
             } else {


Input:
private void smsFailed(SMS sms) {
    logger.info("String_Node_Str" + sms);
    log.addRecord(new Log.Record(MessageFormat.format(l10n.getString("String_Node_Str"), sms.getRecipient()), null, Icons.STATUS_WARNING));
    String cause = (sms.getErrMsg() != null ? sms.getErrMsg().trim() : "String_Node_Str");
    JHtmlLabel label = new JHtmlLabel(MessageFormat.format(l10n.getString("String_Node_Str"), sms.getRecipient(), cause));
    label.addValuedListener(new ValuedListener<JHtmlLabel.Events, String>() {
        public void eventOccured(ValuedEvent<JHtmlLabel.Events, String> e) {
            switch(e.getEvent()) {
                case LINK_CLICKED:
                    Actions.getBrowseAction(e.getValue()).actionPerformed(null);
            }
        }
    });
    label.setVerticalAlignment(SwingConstants.TOP);
    JPanel panel = new JPanel(new BorderLayout());
    panel.add(label, BorderLayout.CENTER);
    JOptionPane pane = new JOptionPane(panel, JOptionPane.WARNING_MESSAGE);
    JDialog dialog = pane.createDialog(MainFrame.this, null);
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    int width = panel.getWidth();
    int height = panel.getHeight();
    if (dialog.getWidth() > screenSize.getWidth()) {
        width = (int) screenSize.getWidth() * 2 / 3;
        height = height * (panel.getWidth() / width);
        panel.setPreferredSize(new Dimension(width, height));
        dialog = pane.createDialog(MainFrame.this, null);
    }
    logger.fine("String_Node_Str");
    RuntimeUtils.setDocumentModalDialog(dialog);
    dialog.setResizable(true);
    dialog.pack();
    dialog.setVisible(true);
    finish(sms);
}

Output:
 private void smsFailed(SMS sms) {
-    logger.info("String_Node_Str" + sms);
+    logger.log(Level.INFO, "String_Node_Str", sms);
     log.addRecord(new Log.Record(MessageFormat.format(l10n.getString("String_Node_Str"), sms.getRecipient()), null, Icons.STATUS_WARNING));


Input:
public VBD createVbd(final Connection conn, final DiskTO volume, final String vmName, final VM vm, final BootloaderType bootLoaderType, VDI vdi) throws XmlRpcException, XenAPIException {
    final Volume.Type type = volume.getType();
    if (vdi == null) {
        vdi = mount(conn, vmName, volume);
    }
    if (vdi != null) {
        if ("String_Node_Str".equals(vdi.getNameLabel(conn))) {
            vdi.setNameLabel(conn, vmName + "String_Node_Str");
        }
        final Map<String, String> smConfig = vdi.getSmConfig(conn);
        for (final String key : smConfig.keySet()) {
            if (key.startsWith("String_Node_Str")) {
                vdi.removeFromSmConfig(conn, key);
                break;
            }
        }
    }
    final VBD.Record vbdr = new VBD.Record();
    vbdr.VM = vm;
    if (vdi != null) {
        vbdr.VDI = vdi;
    } else {
        vbdr.empty = true;
    }
    if (type == Volume.Type.ROOT && bootLoaderType == BootloaderType.PyGrub) {
        vbdr.bootable = true;
    } else if (type == Volume.Type.ISO && bootLoaderType == BootloaderType.CD) {
        vbdr.bootable = true;
    }
    if (volume.getType() == Volume.Type.ISO) {
        vbdr.mode = Types.VbdMode.RO;
        vbdr.type = Types.VbdType.CD;
        vbdr.userdevice = "String_Node_Str";
    } else {
        vbdr.mode = Types.VbdMode.RW;
        vbdr.type = Types.VbdType.DISK;
        vbdr.unpluggable = (volume.getType() == Volume.Type.ROOT) ? false : true;
        vbdr.userdevice = "String_Node_Str";
        final Long deviceId = volume.getDiskSeq();
        if (deviceId != null && !isDeviceUsed(conn, vm, deviceId)) {
            vbdr.userdevice = deviceId.toString();
        }
    }
    final VBD vbd = VBD.create(conn, vbdr);
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("String_Node_Str" + vbd.getUuid(conn) + "String_Node_Str" + volume);
    }
    return vbd;
}

Output:
         final Long deviceId = volume.getDiskSeq();
-        if (deviceId != null && !isDeviceUsed(conn, vm, deviceId)) {
+        if (deviceId != null && (!isDeviceUsed(conn, vm, deviceId) || deviceId > 3)) {
             vbdr.userdevice = deviceId.toString();


Input:
public void checkTypes(MarkerList markers, IContext context) {
    if (this.tupleType instanceof TupleType) {
        ITypeList typeList = (ITypeList) this.tupleType;
        for (int i = 0; i < this.valueCount; i++) {
            IValue v1 = this.values[i].withType(typeList.getType(i));
            if (v1 != null) {
                this.values[i] = v1;
            } else {
            }
            this.values[i].checkTypes(markers, context);
        }
        return;
    }
    IMethod m = IContext.resolveMethod(this.getType(), null, Name.apply, this.arguments = new ArgumentList(this.values, this.valueCount));
    if (m == null) {
        StringBuilder builder = new StringBuilder();
        if (this.valueCount > 0) {
            this.values[0].getType().toString("String_Node_Str", builder);
            for (int i = 1; i < this.valueCount; i++) {
                builder.append("String_Node_Str");
                this.values[i].getType().toString("String_Node_Str", builder);
            }
        }
        markers.add(this.position, "String_Node_Str", builder.toString(), this.tupleType.toString());
    } else {
        this.method = m;
        m.checkArguments(markers, this.position, context, null, this.arguments, null);
    }
}

Output:
         for (int i = 0; i < this.valueCount; i++) {
-            IValue v1 = this.values[i].withType(typeList.getType(i));
-            if (v1 != null) {
-                this.values[i] = v1;
+            IType type = typeList.getType(i);
+            IValue value = this.values[i];
+            IValue value1 = value.withType(type);
+            if (value1 == null) {
+                Marker m = markers.create(value.getPosition(), "String_Node_Str");
+                m.addInfo("String_Node_Str" + value.getType());
+                m.addInfo("String_Node_Str" + type);
             } else {


Input:
public static List<TextChunk> mergeWords(List<TextElement> textElements, List<Ruling> verticalRulings) {
    List<TextChunk> textChunks = new ArrayList<TextChunk>();
    if (textElements.isEmpty()) {
        return textChunks;
    }
    textChunks.add(new TextChunk(textElements.remove(0)));
    TextChunk firstTC = textChunks.get(0);
    float previousAveCharWidth = (float) firstTC.getWidth();
    float endOfLastTextX = (float) firstTC.getRight();
    float maxYForLine = (float) firstTC.getBottom();
    float maxHeightForLine = (float) firstTC.getHeight();
    float minYTopForLine = (float) firstTC.getTop();
    float lastWordSpacing = -1;
    float wordSpacing, deltaSpace, averageCharWidth, deltaCharWidth;
    float expectedStartOfNextWordX, dist;
    TextElement sp, prevChar;
    TextChunk currentChunk;
    boolean sameLine, acrossVerticalRuling;
    for (TextElement chr : textElements) {
        currentChunk = textChunks.get(textChunks.size() - 1);
        prevChar = currentChunk.textElements.get(currentChunk.textElements.size() - 1);
        if ((chr.getText().equals(prevChar.getText())) && (prevChar.overlapRatio(chr) > 0.5)) {
            continue;
        }
        if (chr.getText().equals("String_Node_Str") && Utils.feq(prevChar.getLeft(), chr.getLeft()) && Utils.feq(prevChar.getTop(), chr.getTop())) {
            continue;
        }
        if ((chr.getFont() != prevChar.getFont()) || !Utils.feq(chr.getFontSize(), prevChar.getFontSize())) {
            previousAveCharWidth = -1;
        }
        acrossVerticalRuling = false;
        for (Ruling r : verticalRulings) {
            if ((verticallyOverlapsRuling(prevChar, r) && verticallyOverlapsRuling(chr, r)) && (prevChar.x < r.getPosition() && chr.x > r.getPosition()) || (prevChar.x > r.getPosition() && chr.x < r.getPosition())) {
                acrossVerticalRuling = true;
                break;
            }
        }
        wordSpacing = chr.getWidthOfSpace();
        deltaSpace = 0;
        if (java.lang.Float.isNaN(wordSpacing) || wordSpacing == 0) {
            deltaSpace = java.lang.Float.MAX_VALUE;
        } else if (lastWordSpacing < 0) {
            deltaSpace = wordSpacing * 0.5f;
        } else {
            deltaSpace = ((wordSpacing + lastWordSpacing) / 2.0f) * 0.5f;
        }
        if (previousAveCharWidth < 0) {
            averageCharWidth = (float) (chr.getWidth() / chr.getText().length());
        } else {
            averageCharWidth = (float) ((previousAveCharWidth + (chr.getWidth() / chr.getText().length())) / 2.0f);
        }
        deltaCharWidth = averageCharWidth * AVERAGE_CHAR_TOLERANCE;
        expectedStartOfNextWordX = -java.lang.Float.MAX_VALUE;
        if (endOfLastTextX != -1) {
            expectedStartOfNextWordX = endOfLastTextX + Math.min(deltaCharWidth, deltaSpace);
        }
        sameLine = true;
        if (!Utils.overlap((float) chr.getBottom(), chr.height, maxYForLine, maxHeightForLine)) {
            endOfLastTextX = -1;
            expectedStartOfNextWordX = -java.lang.Float.MAX_VALUE;
            maxYForLine = -java.lang.Float.MAX_VALUE;
            maxHeightForLine = -1;
            minYTopForLine = java.lang.Float.MAX_VALUE;
            sameLine = false;
        }
        endOfLastTextX = (float) chr.getRight();
        if (!acrossVerticalRuling && sameLine && expectedStartOfNextWordX < chr.getLeft() && !prevChar.getText().endsWith("String_Node_Str")) {
            sp = new TextElement((float) prevChar.getTop(), (float) prevChar.getLeft(), (float) (expectedStartOfNextWordX - prevChar.getLeft()), (float) prevChar.getHeight(), prevChar.getFont(), prevChar.getFontSize(), "String_Node_Str", prevChar.getWidthOfSpace());
            currentChunk.add(sp);
        } else {
            sp = null;
        }
        maxYForLine = (float) Math.max(chr.getBottom(), maxYForLine);
        maxHeightForLine = (float) Math.max(maxHeightForLine, chr.getHeight());
        minYTopForLine = (float) Math.min(minYTopForLine, chr.getTop());
        dist = (float) (chr.getLeft() - (sp != null ? sp.getRight() : prevChar.getRight()));
        if (!acrossVerticalRuling && sameLine && (dist < 0 ? currentChunk.verticallyOverlaps(chr) : dist < wordSpacing)) {
            currentChunk.add(chr);
        } else {
            textChunks.add(new TextChunk(chr));
        }
        lastWordSpacing = wordSpacing;
        previousAveCharWidth = (float) (sp != null ? (averageCharWidth + sp.getWidth()) / 2.0f : averageCharWidth);
    }
    List<TextChunk> textChunksSeparatedByDirectionality = new ArrayList<TextChunk>();
    for (TextChunk chunk : textChunks) {
        boolean isLtrDominant = chunk.isLtrDominant() != -1;
        TextChunk dirChunk = chunk.groupByDirectionality(isLtrDominant);
        textChunksSeparatedByDirectionality.add(dirChunk);
    }
    return textChunksSeparatedByDirectionality;
}

Output:
     }
-    textChunks.add(new TextChunk(textElements.remove(0)));
+    List<TextElement> copyOfTextElements = new ArrayList<TextElement>(textElements);
+    textChunks.add(new TextChunk(copyOfTextElements.remove(0)));
     TextChunk firstTC = textChunks.get(0);


Input:
public List<SimplePrincipalCollection> getSimplePrincipalCollectionByUserId(Long... userIds) {
    Set<Long> idset = new TreeSet<Long>(Arrays.asList(userIds));
    Collection<Session> sessions = shiroSessionDao.getActiveSessions();
    List<SimplePrincipalCollection> list = new ArrayList<SimplePrincipalCollection>();
    for (Session session : sessions) {
        Object obj = session.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
        if (null != obj && obj instanceof SimplePrincipalCollection) {
            SimplePrincipalCollection spc = (SimplePrincipalCollection) obj;
            obj = spc.getPrimaryPrincipal();
            if (null != obj && obj instanceof UserEntity) {
                UserEntity user = (UserEntity) obj;
                if (null != user && idset.contains(user.getId())) {
                    list.add(spc);
                }
            }
        }
    }
    return list;
}

Output:
                 UserEntity user = (UserEntity) obj;
-                if (null != user && idset.contains(user.getId())) {
+                if (idset.contains(user.getId())) {
                     list.add(spc);


Input:
private void checkConnection(final StringBuffer retProposedSchema) {
    if (isSqliteFileFieldInvalidate()) {
        return;
    }
    checkButton.setEnabled(false);
    if (connectionItem.getConnection() instanceof DatabaseConnection) {
        DatabaseConnection c = (DatabaseConnection) connectionItem.getConnection();
        if (!isContextMode()) {
            if (EDatabaseTypeName.ORACLEFORSID.getProduct().equals(c.getProductId())) {
                schemaText.setText(schemaText.getText().toUpperCase());
            } else if (EDatabaseTypeName.NETEZZA.getProduct().equals(c.getProductId()) || MetadataFillFactory.isJdbcNetezza(c.getDatabaseType(), c.getDriverClass())) {
                if (sidOrDatabaseText != null) {
                    sidOrDatabaseText.setText(sidOrDatabaseText.getText().toUpperCase());
                }
                if (urlConnectionStringText != null) {
                    urlConnectionStringText.setText(getUppercaseNetezzaUrl(urlConnectionStringText.getText()));
                }
                if (generalJdbcUrlText != null) {
                    generalJdbcUrlText.setText(getUppercaseNetezzaUrl(generalJdbcUrlText.getText()));
                }
            }
        }
    }
    final ManagerConnection managerConnection = new ManagerConnection();
    if (isContextMode()) {
        selectedContextType = ConnectionContextHelper.getContextTypeForContextMode(connectionItem.getConnection());
        String urlStr = DBConnectionContextUtils.setManagerConnectionValues(managerConnection, connectionItem, selectedContextType, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), dbTypeCombo.getSelectionIndex());
        if (urlStr == null || isHiveDBConnSelected()) {
            if (dbTypeCombo.getText().equals(EDatabaseConnTemplate.GENERAL_JDBC.getDBDisplayName())) {
                DatabaseConnection dbConn = (DatabaseConnection) connectionItem.getConnection();
                ContextType contextType = ConnectionContextHelper.getContextTypeForContextMode(dbConn);
                urlStr = ConnectionContextHelper.getOriginalValue(contextType, dbConn.getURL());
            } else {
                urlStr = getStringConnection();
            }
        }
        urlConnectionStringText.setText(urlStr);
    } else {
        String versionStr = dbVersionCombo.getText();
        if (EDatabaseTypeName.HIVE.getDisplayName().equals(dbTypeCombo.getText())) {
            EDatabaseVersion4Drivers driver = EDatabaseVersion4Drivers.indexOfByVersionDisplay(hiveModeCombo.getText());
            versionStr = driver.getVersionValue();
        } else if (EDatabaseTypeName.IMPALA.getDisplayName().equals(dbTypeCombo.getText())) {
            urlConnectionStringText.setText(getStringConnection());
            if (EImpalaDistributions.CUSTOM != EImpalaDistributions.getDistributionByName(impalaDistributionCombo.getText(), true)) {
                versionStr = EImpalaDistribution4Versions.indexOfByVersionDisplay(impalaVersionCombo.getText()).getVersionValue();
            }
        } else {
            EDatabaseVersion4Drivers version = EDatabaseVersion4Drivers.indexOfByVersionDisplay(versionStr);
            if (version != null) {
                versionStr = version.getVersionValue();
            }
        }
        managerConnection.setValue(0, dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()), isGeneralJDBC() ? generalJdbcUrlText.getText() : urlConnectionStringText.getText(), serverText.getText(), isGeneralJDBC() ? generalJdbcUserText.getText() : usernameText.getText(), isGeneralJDBC() ? generalJdbcPasswordText.getText() : passwordText.getText(), sidOrDatabaseText.getText(), portText.getText(), fileField.getText(), datasourceText.getText(), isGeneralJDBC() ? jDBCschemaText.getText() : schemaText.getText(), additionParamText.getText(), generalJdbcClassNameText.getText(), generalJdbcDriverjarText.getText(), enableDbVersion() ? versionStr : null, metadataconnection.getOtherParameters());
        managerConnection.setDbRootPath(directoryField.getText());
    }
    managerConnection.setValueProperties(sqlSyntaxCombo.getItem(sqlSyntaxCombo.getSelectionIndex()), stringQuoteText.getText(), nullCharText.getText());
    EDatabaseTypeName dbType = EDatabaseTypeName.getTypeFromDbType(dbTypeCombo.getItem(dbTypeCombo.getSelectionIndex()));
    AProgressMonitorDialogWithCancel<Boolean> checkingDialog;
    if (dbType.isUseProvider()) {
        final IMetadataConnection metadataConn = ConvertionHelper.convert(connectionItem.getConnection(), true);
        checkingDialog = new AProgressMonitorDialogWithCancel<Boolean>(getShell()) {
            protected Boolean runWithCancel(IProgressMonitor monitor) throws Exception {
                return managerConnection.check(metadataConn, retProposedSchema);
            }
        };
    } else if (isHiveDBConnSelected()) {
        final IMetadataConnection metadataConn = ConvertionHelper.convert(connectionItem.getConnection(), true);
        if (isHiveEmbeddedMode()) {
            doHivePreSetup((DatabaseConnection) metadataConn.getCurrentConnection());
        }
        checkingDialog = new AProgressMonitorDialogWithCancel<Boolean>(getShell()) {
            protected Boolean runWithCancel(IProgressMonitor monitor) throws Exception {
                return managerConnection.checkHiveConnection(metadataConn);
            }
        };
    } else {
        checkingDialog = new AProgressMonitorDialogWithCancel<Boolean>(getShell()) {
            protected Boolean runWithCancel(IProgressMonitor monitor) throws Exception {
                return managerConnection.check(retProposedSchema);
            }
        };
    }
    String executeMessage = Messages.getString("String_Node_Str");
    Exception executeException = null;
    try {
        checkingDialog.run(executeMessage, null, true, AProgressMonitorDialogWithCancel.ENDLESS_WAIT_TIME);
    } catch (Exception e) {
        executeException = e;
    }
    checkButton.setEnabled(true);
    if (checkingDialog.isUserCanncelled()) {
        return;
    }
    if (checkingDialog.getExecuteException() != null) {
        executeException = checkingDialog.getExecuteException();
    }
    if (executeException != null) {
        if (executeException instanceof InterruptedException) {
            CommonExceptionHandler.process(executeException, Priority.WARN);
            return;
        }
        databaseSettingIsValide = false;
    } else {
        databaseSettingIsValide = checkingDialog.getExecuteResult();
    }
    if (databaseSettingIsValide) {
        if (!isReadOnly()) {
            updateStatus(IStatus.OK, null);
        }
        MessageDialog.openInformation(getShell(), Messages.getString("String_Node_Str"), "String_Node_Str" + connectionItem.getProperty().getDisplayName() + "String_Node_Str" + Messages.getString("String_Node_Str"));
        if (!isReadOnly()) {
            if (isContextMode()) {
                adaptFormToEditable();
            } else {
                setPropertiesFormEditable(true);
            }
        }
        String msg = checkDBVersion();
        if (msg != null) {
            updateStatus(IStatus.WARNING, msg);
        }
    } else {
        String mainMsg = null;
        Exception exception = managerConnection.getException();
        if (exception instanceof WarningSQLException) {
            mainMsg = exception.getMessage();
            MessageDialog.openWarning(getShell(), Messages.getString("String_Node_Str"), mainMsg);
        } else if (exception == null && executeException != null) {
            mainMsg = executeException.getMessage();
            MessageDialog.openWarning(getShell(), Messages.getString("String_Node_Str"), mainMsg);
        } else {
            mainMsg = Messages.getString("String_Node_Str") + "String_Node_Str" + Messages.getString("String_Node_Str");
            new ErrorDialogWidthDetailArea(getShell(), PID, mainMsg, managerConnection.getMessageException());
        }
        if (!isReadOnly()) {
            updateStatus(IStatus.WARNING, mainMsg);
        }
    }
}

Output:
     String executeMessage = Messages.getString("String_Node_Str");
-    Exception executeException = null;
+    Throwable executeException = null;
     try {


Input:
public void twoDistanceIteration() {
    Iterator<Vector3i> iter = new Diamond3iIterator(Vector3i.zero(), 2);
    Set<Vector3i> expected = Sets.newHashSet(Vector3i.zero(), new Vector3i(1, 0, 0), new Vector3i(-1, 0, 0), new Vector3i(0, 1, 0), new Vector3i(0, -1, 0), new Vector3i(0, 0, 1), new Vector3i(0, 0, -1));
    while (iter.hasNext()) {
        Vector3i next = iter.next();
        assertTrue("String_Node_Str" + next, expected.remove(next));
    }
    assertTrue("String_Node_Str" + expected, expected.isEmpty());
}

Output:
 public void twoDistanceIteration() {
-    Iterator<Vector3i> iter = new Diamond3iIterator(Vector3i.zero(), 2);
-    Set<Vector3i> expected = Sets.newHashSet(Vector3i.zero(), new Vector3i(1, 0, 0), new Vector3i(-1, 0, 0), new Vector3i(0, 1, 0), new Vector3i(0, -1, 0), new Vector3i(0, 0, 1), new Vector3i(0, 0, -1));
-    while (iter.hasNext()) {
-        Vector3i next = iter.next();
-        assertTrue("String_Node_Str" + next, expected.remove(next));
+    Set<Vector3i> iter = Sets.newHashSet(Diamond3iIterator.iterate(Vector3i.zero(), 2));
+    assertEquals(25, iter.size());
+    for (Vector3i pos : iter) {
+        assertTrue(pos.gridDistance(new Vector3i()) <= 2);
     }


Input:
public void display(final GL gl) {
    clipToFrustum(gl);
    gl.glTranslatef(fXDefaultTranslation + fXTranslation, fYTranslation, 0.0f);
    if (bIsDraggingActive)
        handleDragging(gl);
    checkUnselection();
    gl.glCallList(iGLDisplayListToCall);
    if (bIsAngularBrushingActive && iSelectedLineID != -1) {
        handleAngularBrushing(gl);
    }
    gl.glTranslatef(-fXDefaultTranslation - fXTranslation, -fYTranslation, 0.0f);
    gl.glDisable(GL.GL_STENCIL_TEST);
}

Output:
     gl.glTranslatef(fXDefaultTranslation + fXTranslation, fYTranslation, 0.0f);
-    if (bIsDraggingActive)
+    if (bIsDraggingActive) {
         handleDragging(gl);


Input:
public void run() throws Exception {
    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new HttpStaticFileServerInitializer());
        b.bind(port).sync().channel().closeFuture().sync();
        System.out.println("String_Node_Str" + port + '.');
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

Output:
         b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new HttpStaticFileServerInitializer());
-        b.bind(port).sync().channel().closeFuture().sync();
+        Channel ch = b.bind(port).sync().channel();
         System.out.println("String_Node_Str" + port + '.');


Input:
public boolean execute(Database database) throws MigrationFailedException {
    boolean skipChange = false;
    boolean markRan = true;
    try {
        if (runInTransaction) {
            database.setAutoCommit(false);
        }
        database.getJdbcTemplate().comment("String_Node_Str" + toString());
        if (StringUtils.trimToNull(getComments()) != null) {
            String comments = getComments();
            String[] lines = comments.split("String_Node_Str");
            for (int i = 0; i < lines.length; i++) {
                if (i > 0) {
                    lines[i] = database.getLineComment() + "String_Node_Str" + lines[i];
                }
            }
            database.getJdbcTemplate().comment(StringUtils.join(Arrays.asList(lines), "String_Node_Str"));
        }
        if (database.getJdbcTemplate().executesStatements() && rootPrecondition != null) {
            try {
                rootPrecondition.check(database, null);
            } catch (PreconditionFailedException e) {
                StringBuffer message = new StringBuffer();
                message.append(StreamUtil.getLineSeparator());
                for (FailedPrecondition invalid : e.getFailedPreconditions()) {
                    message.append("String_Node_Str").append(invalid.toString());
                    message.append(StreamUtil.getLineSeparator());
                }
                if (rootPrecondition.getOnFail().equals(Preconditions.FailOption.HALT)) {
                    e.printStackTrace();
                    throw new MigrationFailedException(this, message.toString());
                } else if (rootPrecondition.getOnFail().equals(Preconditions.FailOption.CONTINUE)) {
                    skipChange = true;
                    markRan = false;
                    log.log(Level.INFO, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else if (rootPrecondition.getOnFail().equals(Preconditions.FailOption.MARK_RAN)) {
                    skipChange = true;
                    log.log(Level.INFO, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else if (rootPrecondition.getOnFail().equals(Preconditions.FailOption.WARN)) {
                    log.log(Level.WARNING, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else {
                    throw new MigrationFailedException(this, "String_Node_Str" + rootPrecondition.getOnFail());
                }
            } catch (PreconditionErrorException e) {
                StringBuffer message = new StringBuffer();
                message.append(StreamUtil.getLineSeparator());
                for (ErrorPrecondition invalid : e.getErrorPreconditions()) {
                    message.append("String_Node_Str").append(invalid.toString());
                    message.append(StreamUtil.getLineSeparator());
                }
                if (rootPrecondition.getOnError().equals(Preconditions.ErrorOption.HALT)) {
                    throw new MigrationFailedException(this, message.toString());
                } else if (rootPrecondition.getOnError().equals(Preconditions.ErrorOption.CONTINUE)) {
                    skipChange = true;
                    markRan = false;
                    log.log(Level.INFO, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else if (rootPrecondition.getOnError().equals(Preconditions.ErrorOption.MARK_RAN)) {
                    skipChange = true;
                    markRan = true;
                    log.log(Level.INFO, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else if (rootPrecondition.getOnError().equals(Preconditions.ErrorOption.WARN)) {
                    log.log(Level.WARNING, "String_Node_Str" + toString() + "String_Node_Str" + message);
                } else {
                    throw new MigrationFailedException(this, "String_Node_Str" + rootPrecondition.getOnError());
                }
                database.rollback();
            }
        }
        if (!skipChange) {
            for (Change change : changes) {
                try {
                    change.setUp();
                } catch (SetupException se) {
                    throw new MigrationFailedException(this, se);
                }
            }
            log.finest("String_Node_Str" + toString());
            for (Change change : getChanges()) {
                change.executeStatements(database, sqlVisitors);
                log.finest(change.getConfirmationMessage());
            }
            if (!runInTransaction) {
                database.commit();
            }
            log.finest("String_Node_Str" + toString() + "String_Node_Str");
            database.commit();
        } else {
            log.finest("String_Node_Str" + toString());
        }
    } catch (Exception e) {
        try {
            database.rollback();
        } catch (Exception e1) {
            throw new MigrationFailedException(this, e);
        }
        if (getFailOnError() != null && !getFailOnError()) {
            log.log(Level.INFO, "String_Node_Str" + toString(false) + "String_Node_Str", e);
        } else {
            if (e instanceof MigrationFailedException) {
                throw ((MigrationFailedException) e);
            } else {
                throw new MigrationFailedException(this, e);
            }
        }
    } finally {
        if (runInTransaction) {
            try {
                database.setAutoCommit(true);
            } catch (JDBCException e) {
                throw new MigrationFailedException(this, "String_Node_Str");
            }
        }
    }
    return markRan;
}

Output:
     try {
-        if (runInTransaction) {
-            database.setAutoCommit(false);
-        }
+        database.setAutoCommit(!runInTransaction);
         database.getJdbcTemplate().comment("String_Node_Str" + toString());


Input:
public static void printUsage(String error) {
    if (error != null) {
        System.err.println(error);
    }
    System.err.println("String_Node_Str");
    System.err.println("String_Node_Str");
    System.err.println("String_Node_Str" + DEFAULT_K);
    System.err.println("String_Node_Str" + DEFAULT_HASHES);
    System.err.println("String_Node_Str" + DEFAULT_THRESHOLD);
    System.err.println("String_Node_Str" + DEFAULT_SKIP);
    System.exit(1);
}

Output:
     System.err.println("String_Node_Str");
-    System.err.println("String_Node_Str" + DEFAULT_K);
-    System.err.println("String_Node_Str" + DEFAULT_HASHES);
+    System.err.println("String_Node_Str" + DEFAULT_KMER_SIZE);
+    System.err.println("String_Node_Str" + DEFAULT_NUM_HASHES);
     System.err.println("String_Node_Str" + DEFAULT_THRESHOLD);


Input:
private void composeElement(IXMLWriter xml, Element element, String elementName) throws IOException {
    for (String s : element.getComments()) {
        xml.comment(s, true);
    }
    if (isText(element.getProperty())) {
        if (linkResolver != null)
            xml.link(linkResolver.resolveProperty(element.getProperty()));
        xml.enter(elementName);
        xml.text(element.getValue());
        xml.exit(elementName);
    } else if (element.isPrimitive() || (element.hasType() && isPrimitive(element.getType()))) {
        if (element.getType().equals("String_Node_Str")) {
            xml.escapedText(element.getValue());
        } else if (isText(element.getProperty())) {
            if (linkResolver != null)
                xml.link(linkResolver.resolveProperty(element.getProperty()));
            xml.text(element.getValue());
        } else {
            if (element.hasValue()) {
                if (linkResolver != null)
                    xml.link(linkResolver.resolveType(element.getType()));
                xml.attribute("String_Node_Str", element.getValue());
            }
            if (linkResolver != null)
                xml.link(linkResolver.resolveProperty(element.getProperty()));
            if (element.hasChildren()) {
                xml.enter(elementName);
                for (Element child : element.getChildren()) composeElement(xml, child, child.getName());
                xml.exit(elementName);
            } else
                xml.element(elementName);
        }
    } else {
        for (Element child : element.getChildren()) {
            if (isAttr(child.getProperty())) {
                if (linkResolver != null)
                    xml.link(linkResolver.resolveType(child.getType()));
                xml.attribute(child.getName(), child.getValue());
            }
        }
        if (linkResolver != null)
            xml.link(linkResolver.resolveProperty(element.getProperty()));
        xml.enter(elementName);
        if (element.getSpecial() != null) {
            if (linkResolver != null)
                xml.link(linkResolver.resolveProperty(element.getProperty()));
            xml.enter(element.getType());
        }
        for (Element child : element.getChildren()) {
            if (isText(child.getProperty())) {
                if (linkResolver != null)
                    xml.link(linkResolver.resolveProperty(element.getProperty()));
                xml.text(child.getValue());
            } else if (!isAttr(child.getProperty()))
                composeElement(xml, child, child.getName());
        }
        if (element.getSpecial() != null)
            xml.exit(element.getType());
        xml.exit(elementName);
    }
}

Output:
                 xml.enter(elementName);
-                for (Element child : element.getChildren()) composeElement(xml, child, child.getName());
+                for (Element child : element.getChildren()) composeElement(xml, child, child.getName(), false);
                 xml.exit(elementName);


Input:
private void calculatePageLimitAndMargin() {
    int contentSize, viewSize;
    if (mConfig.orientation == CarouselConfig.HORIZONTAL) {
        contentSize = mResources.getDimensionPixelSize(R.dimen.page_content_width);
        viewSize = mViewPagerWidth;
    } else {
        contentSize = mResources.getDimensionPixelSize(R.dimen.page_content_height);
        viewSize = mViewPagerHeight;
    }
    int minOffset = 0;
    switch(mConfig.scrollScalingMode) {
        case CarouselConfig.SCROLL_MODE_BIG_CURRENT:
            {
                minOffset = (int) (mConfig.getDiffScale() * contentSize / 2) + mMinPagesOffset;
                contentSize *= mConfig.smallScale;
                break;
            }
        case CarouselConfig.SCROLL_MODE_BIG_ALL:
            {
                minOffset = (int) (mConfig.getDiffScale() * contentSize) + mMinPagesOffset;
                contentSize *= mConfig.smallScale;
                break;
            }
        case CarouselConfig.SCROLL_MODE_NONE:
            {
                minOffset = mMinPagesOffset;
                break;
            }
    }
    if (contentSize + 2 * minOffset > viewSize) {
        Log.w(TAG, "String_Node_Str");
        return;
    }
    final float step = 0.1f;
    while (contentSize + 2 * contentSize * (mSidePagesVisiblePart - step) + 2 * minOffset > viewSize && Math.abs(mSidePagesVisiblePart - step) > 1e-6) {
        mSidePagesVisiblePart -= step;
    }
    int fullPages = 0;
    final int s = viewSize - (int) (2 * contentSize * mSidePagesVisiblePart);
    while (minOffset + (fullPages + 1) * (contentSize + minOffset) <= s) {
        fullPages++;
    }
    if (fullPages != 0 && fullPages % 2 == 0) {
        fullPages--;
    }
    int offset = (s - fullPages * contentSize) / (fullPages + 1);
    if (Math.abs(mSidePagesVisiblePart) > 1e-6) {
        mPageLimit = (fullPages + 2) - 1;
    } else {
        mPageLimit = fullPages - 1;
    }
    mPageLimit *= 3;
    mConfig.pageLimit = mPageLimit;
    if (mConfig.orientation == CarouselConfig.VERTICAL) {
        mPageMargin = -(int) ((viewSize - contentSize - offset) * mConfig.scaleY);
    } else {
        mPageMargin = -(viewSize - contentSize - offset);
    }
    mConfig.pageMargin = mPageMargin;
}

Output:
     }
-    mPageLimit *= 3;
+    mPageLimit = 2 * mPageLimit + mPageLimit / 2;
     mConfig.pageLimit = mPageLimit;


Input:
public GraphTraversal<Vertex, Vertex> V() {
    this.tx().readWrite();
    final GraphTraversal traversal = new DefaultGraphTraversal<Object, Vertex>();
    traversal.strategies().register(SqlGGraphStepStrategy.instance());
    traversal.strategies().register(SqlgHasStepStrategy.instance());
    traversal.addStep(new SqlgGraphStep(traversal, Vertex.class, this));
    traversal.sideEffects().setGraph(this);
    return traversal;
}

Output:
     final GraphTraversal traversal = new DefaultGraphTraversal<Object, Vertex>();
-    traversal.strategies().register(SqlGGraphStepStrategy.instance());
-    traversal.strategies().register(SqlgHasStepStrategy.instance());
+    traversal.getStrategies().register(SqlGGraphStepStrategy.instance());
+    traversal.getStrategies().register(SqlgHasStepStrategy.instance());
     traversal.addStep(new SqlgGraphStep(traversal, Vertex.class, this));


Input:
public List getReferableMeasureBindings(String measureName, ICubeQueryDefinition cubeDefn) throws DataException {
    List result = new ArrayList();
    List bindings = cubeDefn.getBindings();
    for (int i = 0; i < bindings.size(); i++) {
        IBinding binding = (IBinding) bindings.get(i);
        final String referencedMeasureName = getReferencedMeasureName(binding.getExpression());
        if (measureName.equals(referencedMeasureName)) {
            List aggrOns = binding.getAggregatOns();
            if (aggrOns.size() == 0 && !isGrandTotal(binding)) {
                result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.MEASURE_TYPE));
            } else {
                if (fromSameEdge(aggrOns, cubeDefn)) {
                    result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.GRAND_TOTAL_TYPE));
                } else
                    result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.SUB_TOTAL_TYPE));
            }
        }
    }
    return result;
}

Output:
             List aggrOns = binding.getAggregatOns();
-            if (aggrOns.size() == 0 && !isGrandTotal(binding)) {
+            if (this.isMeasureBinding(cubeDefn, binding)) {
                 result.add(new BindingMetaInfo(binding.getBindingName(), IBindingMetaInfo.MEASURE_TYPE));


Input:
public FinalSetOperationCTECriteriaBuilder<T> endSet() {
    subListener.verifyBuilderEnded();
    listener.onBuilderEnded(this);
    prepareAndCheck();
    return (FinalSetOperationCTECriteriaBuilder<T>) (FinalSetOperationCTECriteriaBuilder) finalSetOperationBuilder;
}

Output:
     listener.onBuilderEnded(this);
-    prepareAndCheck();
+    if (!isEmpty()) {
+        prepareAndCheck();
+    }
     return (FinalSetOperationCTECriteriaBuilder<T>) (FinalSetOperationCTECriteriaBuilder) finalSetOperationBuilder;


Input:
public static void main(String[] args) throws Exception {
    System.err.printf("String_Node_Str", getVersion());
    if (args.length < 1) {
        System.err.println("String_Node_Str");
        return;
    }
    if (Os.type == Os._32Bit) {
        System.err.println("String_Node_Str");
        return;
    }
    final CharSequenceObjHashMap<String> optHash = hashArgs(args);
    String dir = optHash.get("String_Node_Str");
    extractSite(dir, optHash.get("String_Node_Str") != null);
    File conf = new File(dir, "String_Node_Str");
    if (!conf.exists()) {
        System.err.println("String_Node_Str" + conf);
        return;
    }
    final ServerConfiguration configuration = new ServerConfiguration(conf);
    configureLoggers(configuration);
    final SimpleUrlMatcher matcher = new SimpleUrlMatcher();
    final Factory factory = new Factory(configuration.getDbPath().getAbsolutePath(), configuration.getDbPoolIdleTimeout(), configuration.getDbReaderPoolSize());
    matcher.put("String_Node_Str", new ImportHandler(configuration, factory));
    matcher.put("String_Node_Str", new QueryHandler(factory, configuration));
    matcher.put("String_Node_Str", new CsvHandler(factory, configuration));
    matcher.put("String_Node_Str", new ExistenceCheckHandler(factory));
    matcher.setDefaultHandler(new StaticContentHandler(configuration));
    StringBuilder welcome = Misc.getThreadLocalBuilder();
    final HttpServer server = new HttpServer(configuration, matcher);
    server.getJobs().addAll(LogFactory.INSTANCE.getJobs());
    factory.exportJobs(server.getJobs());
    if (!server.start(configuration.getHttpQueueDepth())) {
        welcome.append("String_Node_Str").append(configuration.getHttpIP()).append(':').append(configuration.getHttpPort());
        welcome.append("String_Node_Str");
        System.err.println(welcome);
        System.out.println(new Date() + "String_Node_Str");
    } else {
        welcome.append("String_Node_Str").append(configuration.getHttpIP()).append(':').append(configuration.getHttpPort());
        if (configuration.getSslConfig().isSecure()) {
            welcome.append("String_Node_Str");
        } else {
            welcome.append("String_Node_Str");
        }
        System.err.println(welcome);
        System.out.println(new Date() + "String_Node_Str");
        if (Os.type != Os.WINDOWS && optHash.get("String_Node_Str") == null) {
            Signal.handle(new Signal("String_Node_Str"), new SignalHandler() {
                public void handle(Signal signal) {
                }
            });
        }
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            public void run() {
                System.out.println(new Date() + "String_Node_Str");
                server.halt();
                factory.close();
            }
        }));
    }
}

Output:
     final HttpServer server = new HttpServer(configuration, matcher);
-    server.getJobs().addAll(LogFactory.INSTANCE.getJobs());
-    factory.exportJobs(server.getJobs());
+    ObjHashSet<Job> jobs = server.getJobs();
+    jobs.addAll(LogFactory.INSTANCE.getJobs());
+    jobs.add(factoryEventLogger);
+    factory.exportJobs(jobs);
+    StringBuilder welcome = Misc.getThreadLocalBuilder();
     if (!server.start(configuration.getHttpQueueDepth())) {


Input:
private void removeRow(int i) throws SQLException {
    index.getPageStore().logUndo(this, data);
    written = false;
    readAllRows();
    Row r = rows[i];
    if (r != null) {
        memorySize += r.getMemorySize();
    }
    entryCount--;
    if (entryCount < 0) {
        Message.throwInternalError();
    }
    freeChildren();
    firstOverflowPageId = 0;
    overflowRowSize = 0;
    rowRef = null;
    int keyOffsetPairLen = 2 + data.getVarLongLen(keys[i]);
    int[] newOffsets = new int[entryCount];
    long[] newKeys = new long[entryCount];
    Row[] newRows = new Row[entryCount];
    System.arraycopy(offsets, 0, newOffsets, 0, i);
    System.arraycopy(keys, 0, newKeys, 0, i);
    System.arraycopy(rows, 0, newRows, 0, i);
    int startNext = i > 0 ? offsets[i - 1] : index.getPageStore().getPageSize();
    int rowLength = startNext - offsets[i];
    int clearStart = offsets[entryCount];
    Arrays.fill(data.getBytes(), clearStart, clearStart + rowLength, (byte) 0);
    for (int j = i; j < entryCount; j++) {
        newOffsets[j] = offsets[j + 1] + rowLength;
    }
    System.arraycopy(keys, i + 1, newKeys, i, entryCount - i);
    System.arraycopy(rows, i + 1, newRows, i, entryCount - i);
    start -= keyOffsetPairLen;
    offsets = newOffsets;
    keys = newKeys;
    rows = newRows;
}

Output:
     }
-    freeChildren();
+    freeOverflow();
     firstOverflowPageId = 0;


Input:
private void buildNewGroupList() {
    if (iAlClusterNodes.size() < 1) {
        groupList = new GroupList(iAlClusterNodes.size());
        Group temp = new Group(tree.getRoot().getNrElements(), false, 0, ESelectionType.NORMAL, tree.getRoot());
        groupList.append(temp);
        if (bRenderGeneTree) {
            NewGroupInfoEvent newGroupInfoEvent = new NewGroupInfoEvent();
            newGroupInfoEvent.setSender(this);
            newGroupInfoEvent.setEVAType(EVAType.CONTENT);
            newGroupInfoEvent.setGroupList(groupList);
            newGroupInfoEvent.setDeleteTree(false);
            eventPublisher.triggerEvent(newGroupInfoEvent);
        } else {
            NewGroupInfoEvent newGroupInfoEvent = new NewGroupInfoEvent();
            newGroupInfoEvent.setSender(this);
            newGroupInfoEvent.setEVAType(EVAType.STORAGE);
            newGroupInfoEvent.setGroupList(groupList);
            newGroupInfoEvent.setDeleteTree(false);
            eventPublisher.triggerEvent(newGroupInfoEvent);
        }
        return;
    }
    groupList = new GroupList(iAlClusterNodes.size());
    bEnableDepthCheck = true;
    int cnt = 0;
    int iExample = 0;
    IVirtualArray currentVA = null;
    if (bRenderGeneTree) {
        currentVA = contentVA;
    } else {
        currentVA = storageVA;
    }
    for (ClusterNode iter : iAlClusterNodes) {
        Group temp = new Group(iter.getNrElements(), false, currentVA.get(iExample), ESelectionType.NORMAL, iter);
        groupList.append(temp);
        cnt++;
        iExample += iter.getNrElements();
    }
    if (bRenderGeneTree) {
        NewGroupInfoEvent newGroupInfoEvent = new NewGroupInfoEvent();
        newGroupInfoEvent.setSender(this);
        newGroupInfoEvent.setEVAType(EVAType.CONTENT);
        newGroupInfoEvent.setGroupList(groupList);
        newGroupInfoEvent.setDeleteTree(false);
        eventPublisher.triggerEvent(newGroupInfoEvent);
    } else {
        NewGroupInfoEvent newGroupInfoEvent = new NewGroupInfoEvent();
        newGroupInfoEvent.setSender(this);
        newGroupInfoEvent.setEVAType(EVAType.STORAGE);
        newGroupInfoEvent.setGroupList(groupList);
        newGroupInfoEvent.setDeleteTree(false);
        eventPublisher.triggerEvent(newGroupInfoEvent);
    }
}

Output:
     for (ClusterNode iter : iAlClusterNodes) {
-        Group temp = new Group(iter.getNrElements(), false, currentVA.get(iExample), ESelectionType.NORMAL, iter);
+        Group temp = new Group(iter.getNrElements(), false, currentVA.indexOf(iExample), ESelectionType.NORMAL, iter);
         groupList.append(temp);