Input:
private void showSearchMessage() {
    if (!isAdded())
        return;
    boolean isLandscape = DisplayUtils.isLandscape(getActivity());
    boolean isTablet = DisplayUtils.isXLarge(getActivity());
    if (!isLandscape || isTablet) {
        TextView txtSearchMsg = (TextView) getView().findViewById(R.id.text_search_message);
        if (txtSearchMsg.getVisibility() != View.VISIBLE) {
            AniUtils.fadeIn(txtSearchMsg, AniUtils.Duration.MEDIUM);
        }
    }
    RecyclerView recycler = mRecyclerView.getInternalRecyclerView();
    if (recycler != null && recycler.getVisibility() == View.VISIBLE) {
        AniUtils.fadeOut(recycler, AniUtils.Duration.MEDIUM);
    }
    mEmptyView.setVisibility(View.GONE);
}

Output:
     if (!isLandscape || isTablet) {
-        TextView txtSearchMsg = (TextView) getView().findViewById(R.id.text_search_message);
-        if (txtSearchMsg.getVisibility() != View.VISIBLE) {
-            AniUtils.fadeIn(txtSearchMsg, AniUtils.Duration.MEDIUM);
-        }
+        setEmptyTitleAndDescription(getString(R.string.reader_label_post_search_explainer), null);
+        mEmptyView.setVisibility(View.VISIBLE);
     }


Input:
private boolean isPlayerAffordToBuild(Player player, Room room) {
    int playerMoney = getWorldHandler().getGameState().getPlayer(player.getPlayerId()).getGoldControl().getGold();
    if (playerMoney == 0) {
        return false;
    }
    int buildablePlots = 0;
    for (int x = (int) Math.max(0, selectionHandler.getSelectionArea().getStart().x); x < Math.min(getWorldHandler().getMapData().getWidth(), selectionHandler.getSelectionArea().getEnd().x + 1); x++) {
        for (int y = (int) Math.max(0, selectionHandler.getSelectionArea().getStart().y); y < Math.min(getWorldHandler().getMapData().getHeight(), selectionHandler.getSelectionArea().getEnd().y + 1); y++) {
            if (getWorldHandler().isBuildable(x, y, player, room)) {
                buildablePlots++;
            }
            if (buildablePlots > 3) {
                return false;
            }
        }
    }
    return true;
}

Output:
             }
-            if (buildablePlots > 3) {
+            if (playerMoney < buildablePlots * room.getCost()) {
                 return false;


Input:
public static String autoGetUnrarCommand() {
    String programm = null;
    String OS = System.getProperty("String_Node_Str").toLowerCase();
    if ((OS.indexOf("String_Node_Str") > -1) || (OS.indexOf("String_Node_Str") > -1)) {
        try {
            File unrarexe = new File(JDUtilities.getJDHomeDirectory(), "String_Node_Str");
            if (unrarexe.isFile())
                programm = unrarexe.getAbsolutePath();
            else {
                File winrarexe = new File(new File(System.getenv("String_Node_Str"), "String_Node_Str"), "String_Node_Str");
                if (winrarexe.isFile()) {
                    logger.info("String_Node_Str" + winrarexe.getAbsolutePath());
                    logger.info("String_Node_Str" + unrarexe.getAbsolutePath());
                    copy(winrarexe, unrarexe);
                    programm = unrarexe.getAbsolutePath();
                }
            }
        } catch (Throwable e) {
        }
    } else {
        try {
            String[] charset = System.getenv("String_Node_Str").split("String_Node_Str");
            String Programmname = "String_Node_Str";
            for (int i = 0; i < charset.length; i++) {
                File fi = new File(charset[i], Programmname);
                if (fi.isFile()) {
                    programm = fi.getAbsolutePath();
                    break;
                }
            }
        } catch (Throwable e) {
        }
    }
    return programm;
}

Output:
                     logger.info("String_Node_Str" + unrarexe.getAbsolutePath());
-                    copy(winrarexe, unrarexe);
+                    JDUtilities.copyFile(winrarexe, unrarexe);
                     programm = unrarexe.getAbsolutePath();


Input:
public void accept(Visitor<Contract> visitor) {
    boolean descend = visitor.preVisit(this);
    if (descend) {
        if (visitor.preVisit(this)) {
            for (Contract c : this.input1) {
                c.accept(visitor);
            }
            for (Contract c : this.input2) {
                c.accept(visitor);
            }
        }
        visitor.postVisit(this);
    }
}

Output:
     if (descend) {
-        if (visitor.preVisit(this)) {
-            for (Contract c : this.input1) {
-                c.accept(visitor);
-            }
-            for (Contract c : this.input2) {
-                c.accept(visitor);
-            }
+        for (Contract c : this.input1) {
+            c.accept(visitor);
+        }
+        for (Contract c : this.input2) {
+            c.accept(visitor);
         }


Input:
public static void main(String[] args) {
    final int size = 8;
    HeuristicSearchProblem<Void, NQueens, Double> p = ProblemBuilder.create().initialState(new NQueens(size)).defineProblemWithoutActions().useTransitionFunction(new StateTransitionFunction<NQueens>() {

        public Iterable<NQueens> successorsOf(NQueens state) {
            Set<NQueens> states = new HashSet<NQueens>();
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                    if (state.getQueens()[i] != j) {
                        int[] queens = Arrays.copyOf(state.getQueens(), size);
                        queens[i] = j;
                        states.add(new NQueens(queens));
                    }
                }
            }
            return states;
        }
    }).useCostFunction(new CostFunction<Void, NQueens, Double>() {
        public Double evaluate(Transition<Void, NQueens> transition) {
            return 0d;
        }
    }).useHeuristicFunction(new HeuristicFunction<NQueens, Double>() {
        public Double estimate(NQueens state) {
            return (double) state.attackedQueens();
        }
    }).build();
    System.out.println("String_Node_Str" + p.getInitialState().attackedQueens() + "String_Node_Str");
    System.out.println(p.getInitialState());
    System.out.println("String_Node_Str");
    System.out.println(Hipster.createHillClimbing(p, true).search(new Predicate<WeightedNode<Void, NQueens, Double>>() {
        public boolean apply(WeightedNode<Void, NQueens, Double> node) {
            return node.getScore().equals(0d);
        }
    }));
    System.out.println("String_Node_Str");
    HillClimbing<Void, NQueens, Double, WeightedNode<Void, NQueens, Double>>.EHCIter it = Hipster.createHillClimbing(p, true).iterator();
    int iteration = 0;
    Double best = it.getBestScore();
    while (it.hasNext()) {
        iteration++;
        WeightedNode<Void, NQueens, Double> node = it.next();
        if (node.getScore() < best) {
            best = node.getScore();
            System.out.println("String_Node_Str" + best + "String_Node_Str" + iteration);
        }
        int attacked = node.state().attackedQueens();
        if (attacked == 0) {
            System.out.println("String_Node_Str");
            System.out.println(node);
            break;
        }
    }
}

Output:
     final int size = 8;
-    HeuristicSearchProblem<Void, NQueens, Double> p = ProblemBuilder.create().initialState(new NQueens(size)).defineProblemWithoutActions().useTransitionFunction(new StateTransitionFunction<NQueens>() {
+    Hipster.SearchProblem<Void, NQueens, WeightedNode<Void, NQueens, Double>> p = ProblemBuilder.create().initialState(new NQueens(size)).defineProblemWithoutActions().useTransitionFunction(new StateTransitionFunction<NQueens>() {


Input:
public static void resetMXBeanMemoryCheck() {
    String threshold = TroubleshootingBootstrapper.SIMPLE_MEMORY_CHECK_THRESHOLD;
    String pollTime = TroubleshootingBootstrapper.SIMPLE_MEMORY_CHECK_POLL_TIME;
    if (mxBeanMemoryCheckerScheduledFuture != null) {
        mxBeanMemoryCheckerScheduledFuture.cancel(true);
    }
    MXBeanInfo info = null;
    if (threshold.endsWith("String_Node_Str")) {
        info = new MXBeanInfo(Double.parseDouble(threshold.substring(0, threshold.length() - 1)));
    } else {
        info = new MXBeanInfo(Long.parseLong(threshold));
    }
    MXBeanMemoryChecker checker = new MXBeanMemoryChecker(info, Eucalyptus.class, Long.parseLong(pollTime));
    mxBeanMemoryCheckerScheduledFuture = MXBeanMemoryResourceCheck.start(checker);
}

Output:
 public static void resetMXBeanMemoryCheck() {
-    String threshold = TroubleshootingBootstrapper.SIMPLE_MEMORY_CHECK_THRESHOLD;
-    String pollTime = TroubleshootingBootstrapper.SIMPLE_MEMORY_CHECK_POLL_TIME;
+    String threshold = TroubleshootingBootstrapper.MXBEAN_MEMORY_CHECK_THRESHOLD;
+    String pollTime = TroubleshootingBootstrapper.MXBEAN_MEMORY_CHECK_POLL_TIME;
     if (mxBeanMemoryCheckerScheduledFuture != null) {


Input:
public E get(int index) {
    return list.get(index);
}

Output:
 public E get(int index) {
-    return list.get(index);
+    lock.lock();
+    try {
+        return list.get(index);
+    } finally {
+        lock.unlock();
+    }
 }


Input:
private void sampleZ(int iterationNumber) {
    for (int p = 0; p < numberOfDomains; p++) {
        dp.remove_topic_assignment(zSamples[iterationNumber][p]);
        int total_cnt = dp.prob_topics();
        double[] z_probabilities = new double[total_cnt];
        for (int i = 0; i < total_cnt; i++) {
            z_probabilities[i] = Math.log(dp.pdf[i].prob);
        }
        for (int j = 0; j < numberOfFunctions; j++) {
            disagreements[j][p] = 0;
            for (int i = 0; i < numberOfDataSamples[p]; i++) if (functionOutputsArray[j][p][i] != labelsSamples[iterationNumber][p][i])
                disagreements[j][p]++;
            for (int i = 0; i < total_cnt - 1; i++) {
                int k = dp.pdf[i].topic;
                z_probabilities[i] += disagreements[j][p] * Math.log(errorRateSamples[iterationNumber + 1][k][j]);
                z_probabilities[i] += (numberOfDataSamples[p] - disagreements[j][p]) * Math.log(1 - errorRateSamples[iterationNumber + 1][k][j]);
            }
            z_probabilities[total_cnt - 1] += logBeta(alpha_e + disagreements[j][p], beta_e + numberOfDataSamples[p] - disagreements[j][p]) - logBeta(alpha_e, beta_e);
        }
        for (int i = 1; i < total_cnt; i++) {
            z_probabilities[i] = MatrixUtilities.computeLogSumExp(z_probabilities[i - 1], z_probabilities[i]);
        }
        double uniform = Math.log(random.nextDouble()) + z_probabilities[total_cnt - 1];
        zSamples[iterationNumber + 1][p] = dp.pdf[total_cnt - 1].topic;
        for (int i = 0; i < total_cnt - 1; i++) {
            if (z_probabilities[i] > uniform) {
                zSamples[iterationNumber + 1][p] = dp.pdf[i].topic;
                for (int j = 0; j < numberOfFunctions; j++) {
                    sum_1[j][dp.pdf[i].topic] += numberOfDataSamples[p];
                    sum_2[j][dp.pdf[i].topic] += disagreements[j][p];
                }
                dp.add_topic_assingment(dp.pdf[i].topic);
                break;
            }
        }
        if (zSamples[iterationNumber + 1][p] == dp.pdf[total_cnt - 1].topic) {
            for (int j = 0; j < numberOfFunctions; j++) {
                sum_1[j][dp.pdf[total_cnt - 1].topic] += numberOfDataSamples[p];
                sum_2[j][dp.pdf[total_cnt - 1].topic] += disagreements[j][p];
            }
            dp.add_topic_assingment(dp.pdf[total_cnt - 1].topic);
        }
    }
}

Output:
         }
-        if (zSamples[iterationNumber + 1][p] == dp.pdf[total_cnt - 1].topic) {
-            for (int j = 0; j < numberOfFunctions; j++) {
-                sum_1[j][dp.pdf[total_cnt - 1].topic] += numberOfDataSamples[p];
-                sum_2[j][dp.pdf[total_cnt - 1].topic] += disagreements[j][p];
-            }
+        if (zSamples[iterationNumber + 1][p] == dp.pdf[total_cnt - 1].topic)
             dp.add_topic_assingment(dp.pdf[total_cnt - 1].topic);


Input:
public void onSuccess(IRCChannel channel) {
    LOGGER.trace("String_Node_Str" + chatroom.getIdentifier() + "String_Node_Str");
    ChatRoomIrcImpl actualChatRoom = chatroom;
    synchronized (joinSignal) {
        try {
            if (!channel.getName().equals(actualChatRoom.getIdentifier())) {
                actualChatRoom = new ChatRoomIrcImpl(channel.getName(), IrcStack.this.provider);
                MessageIrcImpl message = new MessageIrcImpl("String_Node_Str" + channel.getName(), "String_Node_Str", "String_Node_Str", null);
                IrcStack.this.provider.getMUC().registerChatRoomInstance(actualChatRoom);
                chatroom.fireMessageReceivedEvent(message, null, new Date(), MessageReceivedEvent.SYSTEM_MESSAGE_RECEIVED);
            }
            IrcStack.this.joined.put(actualChatRoom.getIdentifier(), actualChatRoom);
            IrcStack.this.irc.addListener(new ChatRoomListener(actualChatRoom));
            IRCTopic topic = channel.getTopic();
            actualChatRoom.updateSubject(topic.getValue());
            for (IRCUser user : channel.getUsers()) {
                ChatRoomMemberRole role = ChatRoomMemberRole.SILENT_MEMBER;
                Set<IRCUserStatus> statuses = channel.getStatusesForUser(user);
                for (IRCUserStatus status : statuses) {
                    role = convertMemberMode(status.getChanModeType().charValue());
                }
                if (IrcStack.this.getNick().equals(user.getNick())) {
                    actualChatRoom.prepUserRole(role);
                } else {
                    ChatRoomMemberIrcImpl member = new ChatRoomMemberIrcImpl(IrcStack.this.provider, actualChatRoom, user.getNick(), role);
                    actualChatRoom.addChatRoomMember(member.getContactAddress(), member);
                }
            }
        } finally {
            IrcStack.this.provider.getMUC().fireLocalUserPresenceEvent(actualChatRoom, LocalUserChatRoomPresenceChangeEvent.LOCAL_USER_JOINED, null);
            LOGGER.trace("String_Node_Str" + "String_Node_Str" + chatroom.getIdentifier() + "String_Node_Str");
            joinSignal.setDone();
            joinSignal.notifyAll();
        }
    }
}

Output:
         try {
-            if (!channel.getName().equals(actualChatRoom.getIdentifier())) {
+            if (!channel.getName().equalsIgnoreCase(actualChatRoom.getIdentifier())) {
                 actualChatRoom = new ChatRoomIrcImpl(channel.getName(), IrcStack.this.provider);


Input:
public boolean isSetWasDerivedFrom() {
    return wasDerivedFrom != null;
}

Output:
 public boolean isSetWasDerivedFrom() {
-    return wasDerivedFrom != null;
+    return wasDerivedFroms.size() > 0;
 }


Input:
public void addType(IType type) {
    int index = this.upperBoundCount++;
    if (index >= this.upperBounds.length) {
        IType[] temp = new IType[this.upperBoundCount];
        System.arraycopy(this.upperBounds, 0, temp, 0, this.upperBounds.length);
        this.upperBounds = temp;
    }
    this.upperBounds[index] = type;
}

Output:
         IType[] temp = new IType[this.upperBoundCount];
-        System.arraycopy(this.upperBounds, 0, temp, 0, this.upperBounds.length);
+        System.arraycopy(this.upperBounds, 0, temp, 0, index);
         this.upperBounds = temp;


Input:
public static String getAggregationExpression(ComputedColumnHandle bindingColumn) {
    if (bindingColumn.getExpression() != null)
        return bindingColumn.getExpression();
    String functionName = bindingColumn.getAggregateFunction();
    try {
        IAggrFunction function = getAggregationManager().getAggregation(functionName);
        for (IParameterDefn param : function.getParameterDefn()) {
            if (param.isDataField()) {
                for (Iterator iterator = bindingColumn.argumentsIterator(); iterator.hasNext(); ) {
                    AggregationArgumentHandle arg = (AggregationArgumentHandle) iterator.next();
                    if (arg.getName().equals(param.getName())) {
                        return arg.getValue();
                    }
                }
            }
        }
    } catch (BirtException e) {
    }
    return null;
}

Output:
                     AggregationArgumentHandle arg = (AggregationArgumentHandle) iterator.next();
-                    if (arg.getName().equals(param.getName())) {
+                    if (DataAdapterUtil.adaptArgumentName(arg.getName()).equals(param.getName())) {
                         return arg.getValue();


Input:
private void testFactTableSaveAndLoad2(IDocumentManager documentManager) throws IOException, BirtException {
    Dimension[] dimensions = new Dimension[3];
    ILevelDefn[] levelDefs = new ILevelDefn[1];
    String[] levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension1Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension2Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension3Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    IDatasetIterator factTableIterator = new LevelsAndFactTableDataset();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    assertEquals(factTable.getDimensionInfo()[0].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[0].getDimensionLength(), 3);
    assertEquals(factTable.getDimensionInfo()[1].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[1].getDimensionLength(), 7);
    assertEquals(factTable.getDimensionInfo()[2].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[2].getDimensionLength(), 14);
    assertEquals(factTable.getMeasureInfo()[0].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[0].getDataType(), DataType.INTEGER_TYPE);
    assertEquals(factTable.getMeasureInfo()[1].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[1].getDataType(), DataType.DOUBLE_TYPE);
    String[] dimensionNames = new String[3];
    dimensionNames[0] = "String_Node_Str";
    dimensionNames[1] = "String_Node_Str";
    dimensionNames[2] = "String_Node_Str";
    IDiskArray[] dimensionPosition = new IDiskArray[3];
    dimensionPosition[0] = new BufferedPrimitiveDiskArray();
    dimensionPosition[0].add(new Integer(1));
    dimensionPosition[0].add(new Integer(2));
    dimensionPosition[1] = new BufferedPrimitiveDiskArray();
    dimensionPosition[1].add(new Integer(1));
    dimensionPosition[1].add(new Integer(2));
    dimensionPosition[2] = new BufferedPrimitiveDiskArray();
    dimensionPosition[2].add(new Integer(1));
    dimensionPosition[2].add(new Integer(2));
    dimensionPosition[2].add(new Integer(3));
    dimensionPosition[2].add(new Integer(4));
    dimensionPosition[2].add(new Integer(5));
    dimensionPosition[2].add(new Integer(6));
    FactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNames, dimensionPosition, new StopSign());
    assertTrue(facttableRowIterator != null);
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(5, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(211), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(211), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(6, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(212), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(212), facttableRowIterator.getMeasure(1));
    assertFalse(facttableRowIterator.next());
}

Output:
     FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
-    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign());
+    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign(), false);
     assertEquals(factTable.getSegmentCount(), 1);


Input:
public void writeSet(MethodWriter writer, IValue instance, IValue value) {
    if (value != null) {
        value.writeExpression(writer);
    }
    if (this.index == -1) {
        writer.writeVarInsn(this.type.getStoreOpcode(), this.index = writer.registerLocal());
    } else {
        writer.writeVarInsn(this.type.getStoreOpcode(), this.index);
    }
}

Output:
     }
-    if (this.index == -1) {
-        writer.writeVarInsn(this.type.getStoreOpcode(), this.index = writer.registerLocal());
-    } else {
-        writer.writeVarInsn(this.type.getStoreOpcode(), this.index);
-    }
+    writer.writeVarInsn(this.type.getStoreOpcode(), this.index);
 }


Input:
private static GenericLocation parseGenericLocation(NestedDocument<QName> typeGenLoc) {
    URI persistentIdentity = null;
    String displayId = null;
    URI orientation = null;
    String version = null;
    URI wasDerivedFrom = null;
    List<Annotation> annotations = new ArrayList<>();
    for (NamedProperty<QName> namedProperty : typeGenLoc.getProperties()) {
        if (namedProperty.getName().equals(Sbol2Terms.GenericLocation.orientation)) {
            orientation = URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString());
        } else if (namedProperty.getName().equals(Sbol2Terms.Documented.displayId)) {
            displayId = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.persistentIdentity)) {
            persistentIdentity = URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString());
        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.version)) {
            version = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
        } else if (namedProperty.getName().equals(ProvTerms.Prov.wasDerivedFrom)) {
            wasDerivedFrom = URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString());
        } else {
            annotations.add(new Annotation(namedProperty));
        }
    }
    GenericLocation gl = new GenericLocation(typeGenLoc.getIdentity());
    if (displayId != null)
        gl.setDisplayId(displayId);
    if (orientation != null)
        gl.setOrientation(orientation);
    if (persistentIdentity != null)
        gl.setPersistentIdentity(persistentIdentity);
    if (version != null)
        gl.setVersion(version);
    if (wasDerivedFrom != null)
        gl.setWasDerivedFrom(wasDerivedFrom);
    if (!annotations.isEmpty())
        gl.setAnnotations(annotations);
    return gl;
}

Output:
             version = ((Literal<QName>) namedProperty.getValue()).getValue().toString();
-        } else if (namedProperty.getName().equals(ProvTerms.Prov.wasDerivedFrom)) {
+        } else if (namedProperty.getName().equals(Sbol2Terms.Identified.wasDerivedFrom)) {
             wasDerivedFrom = URI.create(((Literal<QName>) namedProperty.getValue()).getValue().toString());


Input:
public List<Warp> getWarpsForUser(String playerName, Player requestingPlayer) {
    List<Warp> retVal = new ArrayList<Warp>();
    List<Warp> warpsFromDB = database.find(Warp.class).findList();
    for (Warp warp : warpsFromDB) {
        if (warp.getWarpType() == WarpType.PUBLIC_LISTED) {
            retVal.add(warp);
        } else {
            if (warp.getOwner().equals(playerName)) {
                retVal.add(warp);
            }
        }
    }
    return retVal;
}

Output:
     List<Warp> retVal = new ArrayList<Warp>();
-    List<Warp> warpsFromDB = database.find(Warp.class).findList();
+    List<Warp> warpsFromDB = plugin.getDatabase().find(Warp.class).findList();
     for (Warp warp : warpsFromDB) {


Input:
public void openProject(Project project) {
    final ProjectImpl projectImpl = (ProjectImpl) project;
    final ProjectInformationImpl projectInformationImpl = projectImpl.getLookup().lookup(ProjectInformationImpl.class);
    final WorkspaceProviderImpl workspaceProviderImpl = project.getLookup().lookup(WorkspaceProviderImpl.class);
    if (projects.hasCurrentProject()) {
        closeCurrentProject();
    }
    projects.addProject(projectImpl);
    projects.setCurrentProject(projectImpl);
    projectInformationImpl.open();
    if (!workspaceProviderImpl.hasCurrentWorkspace()) {
        if (workspaceProviderImpl.getWorkspaces().length == 0) {
            Workspace workspace = newWorkspace(project);
            openWorkspace(workspace);
        } else {
            Workspace workspace = workspaceProviderImpl.getWorkspaces()[0];
            openWorkspace(workspace);
        }
    } else {
        fireWorkspaceEvent(EventType.SELECT, workspaceProviderImpl.getCurrentWorkspace());
    }
    saveProject = true;
    saveAsProject = true;
    projectProperties = true;
    closeProject = true;
    newWorkspace = true;
    if (workspaceProviderImpl.hasCurrentWorkspace()) {
        deleteWorkspace = true;
        cleanWorkspace = true;
        duplicateWorkspace = true;
    }
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            JFrame frame = (JFrame) WindowManager.getDefault().getMainWindow();
            String title = frame.getTitle() + "String_Node_Str" + projectInformationImpl.getName();
            frame.setTitle(title);
        }
    });
    StatusDisplayer.getDefault().setStatusText(NbBundle.getMessage(ProjectControllerImpl.class, "String_Node_Str", projectInformationImpl.getName()));
}

Output:
     if (projects.hasCurrentProject()) {
-        closeCurrentProject();
+        if (!closeCurrentProject()) {
+            return;
+        }
     }


Input:
private void findCandidateShapes(T gray, ImageUInt8 binary) {
    int maxSidesConsider = (int) Math.ceil(maxSides * 1.2);
    fitPolygon.setAbortSplits(2 * maxSides);
    contourFinder.process(binary, labeled);
    FastQueue<Contour> blobs = contourFinder.getContours();
    for (int i = 0; i < blobs.size; i++) {
        Contour c = blobs.get(i);
        if (c.external.size() >= minimumContour) {
            if (touchesBorder(c.external))
                continue;
            if (toUndistorted != null) {
                removeDistortionFromContour(c.external);
            }
            if (!fitPolygon.process(c.external)) {
                if (verbose)
                    System.out.println("String_Node_Str" + c.external.size());
                continue;
            }
            GrowQueue_I32 splits = fitPolygon.getSplits();
            if (splits.size() > maxSidesConsider) {
                if (verbose)
                    System.out.println("String_Node_Str" + c.external.size());
            }
            if (!improveContour.fit(c.external, splits)) {
                if (verbose)
                    System.out.println("String_Node_Str" + c.external.size());
                continue;
            }
            boolean wasPruned = pruner.fit(c.external, splits, pruned);
            splits = pruned;
            if (!expectedNumberOfSides(splits)) {
                if (verbose)
                    System.out.println("String_Node_Str" + splits.size() + "String_Node_Str" + c.external.size());
                continue;
            }
            if (wasPruned && !improveContour.fit(c.external, splits)) {
                if (verbose)
                    System.out.println("String_Node_Str" + c.external.size());
                continue;
            }
            if (helper != null) {
                if (!helper.filterPolygon(c.external, splits)) {
                    if (verbose)
                        System.out.println("String_Node_Str");
                    continue;
                }
            }
            workPoly.vertexes.resize(splits.size());
            for (int j = 0; j < splits.size(); j++) {
                Point2D_I32 p = c.external.get(splits.get(j));
                workPoly.get(j).set(p.x, p.y);
            }
            if (helper != null) {
                helper.adjustBeforeOptimize(workPoly);
            }
            if (convex && !UtilPolygons2D_F64.isConvex(workPoly)) {
                if (verbose)
                    System.out.println("String_Node_Str");
                continue;
            }
            double area = Area2D_F64.polygonSimple(workPoly);
            if (area < minimumArea) {
                if (verbose)
                    System.out.println("String_Node_Str");
                continue;
            }
            if (checkEdgeBefore && differenceScore != null && !differenceScore.validate(workPoly)) {
                if (verbose)
                    System.out.println("String_Node_Str" + differenceScore.getAverageEdgeIntensity());
                continue;
            }
            Polygon2D_F64 refined = found.grow();
            refined.vertexes.resize(splits.size);
            boolean success;
            if (refinePolygon != null) {
                refinePolygon.setImage(gray);
                success = refinePolygon.refine(workPoly, c.external, splits, refined);
                if (verbose)
                    System.out.println("String_Node_Str");
            } else {
                refined.set(workPoly);
                success = true;
            }
            if (!checkEdgeBefore && differenceScore != null && !differenceScore.validate(refined)) {
                if (verbose)
                    System.out.println("String_Node_Str" + differenceScore.getAverageEdgeIntensity());
                continue;
            }
            if (outputClockwise == refined.isCCW())
                refined.flip();
            if (success) {
                c.id = found.size();
                foundContours.add(c);
            } else {
                found.removeTail();
            }
        }
    }
}

Output:
 private void findCandidateShapes(T gray, ImageUInt8 binary) {
-    int maxSidesConsider = (int) Math.ceil(maxSides * 1.2);
+    int maxSidesConsider = (int) Math.ceil(maxSides * 1.5);
     fitPolygon.setAbortSplits(2 * maxSides);


Input:
private int spawnChildJVMForTest(Configuration.ConfigurationTest test, boolean jsoar) {
    List<String> arguments = new ArrayList<String>();
    URL baseURL = PerformanceTesting.class.getProtectionDomain().getCodeSource().getLocation();
    String jarPath = null;
    try {
        jarPath = new File(baseURL.toURI().getPath()).getCanonicalPath();
    } catch (IOException | URISyntaxException e1) {
        throw new AssertionError(e1);
    }
    jarPath = jarPath.replace("String_Node_Str", "String_Node_Str");
    if (jarPath.endsWith("String_Node_Str") != true) {
        String originalPath = jarPath;
        jarPath += "String_Node_Str";
        jarPath += originalPath + "String_Node_Str";
        File directory = new File(originalPath + "String_Node_Str");
        File[] listOfFiles = directory.listFiles();
        for (File file : listOfFiles) {
            if (file.isFile()) {
                String path = file.getPath();
                if (!path.endsWith("String_Node_Str")) {
                    continue;
                }
                path = path.replace("String_Node_Str", "String_Node_Str");
                jarPath += path + "String_Node_Str";
            }
        }
        directory = new File(originalPath + "String_Node_Str");
        listOfFiles = directory.listFiles();
        for (File file : listOfFiles) {
            if (file.isFile()) {
                String path = file.getPath();
                if (!path.endsWith("String_Node_Str")) {
                    continue;
                }
                path = path.replace("String_Node_Str", "String_Node_Str");
                jarPath += path + "String_Node_Str";
            }
        }
    }
    arguments.add("String_Node_Str");
    arguments.addAll(Arrays.asList(test.getTestSettings().getJVMSettings().split("String_Node_Str")));
    arguments.add("String_Node_Str");
    arguments.add("String_Node_Str" + jarPath + "String_Node_Str");
    arguments.add(PerformanceTesting.class.getCanonicalName());
    arguments.add("String_Node_Str");
    arguments.add(test.getTestFile());
    arguments.add("String_Node_Str");
    arguments.add(test.getTestSettings().getCSVDirectory());
    arguments.add("String_Node_Str");
    arguments.add(new Integer(test.getTestSettings().getWarmUpCount()).toString());
    arguments.add("String_Node_Str");
    arguments.add(new Integer(test.getTestSettings().getDecisionCycles()).toString());
    arguments.add("String_Node_Str");
    arguments.add(test.getTestName());
    arguments.add("String_Node_Str");
    arguments.add("String_Node_Str");
    int exitCode = 0;
    if (jsoar) {
        arguments.add("String_Node_Str");
        exitCode = runJVM(test, arguments);
    } else {
        arguments.add("String_Node_Str");
        for (String path : csoarPaths) {
            List<String> argumentsPerTest = new ArrayList<String>(arguments);
            argumentsPerTest.add("String_Node_Str" + path + "String_Node_Str");
            exitCode = runJVM(test, argumentsPerTest);
        }
    }
    if (exitCode != 0) {
        return EXIT_FAILURE_TEST;
    } else {
        return EXIT_SUCCESS;
    }
}

Output:
         arguments.add("String_Node_Str");
-        for (String path : csoarPaths) {
+        for (String path : test.getTestSettings().getCSoarVersions()) {
             List<String> argumentsPerTest = new ArrayList<String>(arguments);


Input:
private void zoomOut() {
    int M = communities.size();
    LinkedList<ModEdge>[] newTopology = new LinkedList[M];
    int index = 0;
    nodeCommunities = new Community[M];
    nodeConnections = new HashMap[M];
    HashMap<Integer, Community> newInvMap = new HashMap<Integer, Community>();
    for (int i = 0; i < communities.size(); i++) {
        Community com = communities.get(i);
        nodeConnections[index] = new HashMap<Community, Integer>();
        newTopology[index] = new LinkedList<ModEdge>();
        nodeCommunities[index] = new Community(com);
        Set<Community> iter = com.connections.keySet();
        double weightSum = 0;
        Community hidden = new Community(structure);
        for (Integer nodeInt : com.nodes) {
            Community oldHidden = invMap.get(nodeInt);
            hidden.nodes.addAll(oldHidden.nodes);
        }
        newInvMap.put(index, hidden);
        for (Community adjCom : iter) {
            int target = communities.indexOf(adjCom);
            int weight = com.connections.get(adjCom);
            weightSum += weight;
            ModEdge e = new ModEdge(index, target, weight);
            newTopology[index].add(e);
        }
        weights[index] = weightSum;
        nodeCommunities[index].seed(index);
        index++;
    }
    communities.clear();
    for (int i = 0; i < M; i++) {
        Community com = nodeCommunities[i];
        communities.add(com);
        for (ModEdge e : newTopology[i]) {
            nodeConnections[i].put(nodeCommunities[e.target], e.weight);
            com.connections.put(nodeCommunities[e.target], e.weight);
        }
    }
    N = M;
    topology = newTopology;
    invMap = newInvMap;
}

Output:
             int weight = com.connections.get(adjCom);
-            weightSum += weight;
+            if (target == index)
+                weightSum += 2 * weight;
+            else
+                weightSum += weight;
             ModEdge e = new ModEdge(index, target, weight);


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_bottombar);
    ButterKnife.bind(this);
    context = this;
    currentVersionName = UpdateChecker.getAppVersion(context);
    homeFragment = HomeFragment.newInstance(Constants.HOME_PAGETYPE, null);
    searchFragment = HomeFragment.newInstance(Constants.SEARCH_PAGETYPE, null);
    categoriesGridFragment = new CategoriesGridFragment();
    myWallFragment = new MyWallFragment();
    settingToolbar();
    settingBottomBar(savedInstanceState);
    mToolbarNewGiftBtnTv.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            if (AppController.getStoredString(Constants.Authorization) != null) {
                startActivity(RegisterGiftActivity.createIntent());
            } else {
                startActivity(LoginActivity.createIntent());
            }
        }
    });
    mBottomBar.selectTabAtPosition(3, false);
}

Output:
     settingToolbar();
-    settingBottomBar(savedInstanceState);
+    currentVersionName = UpdateChecker.getAppVersion(context);
     mToolbarNewGiftBtnTv.setOnClickListener(new View.OnClickListener() {


Input:
public boolean applies(GameEvent event, Ability source, Game game) {
    if (event.getType() == GameEvent.EventType.ACTIVATE_ABILITY) {
        MageObject object = game.getObject(event.getSourceId());
        Ability ability = game.getAbility(event.getTargetId(), event.getSourceId());
        if (ability != null && object != null) {
            if (ability.getAbilityType() != AbilityType.MANA && object.getName().equals(game.getState().getValue(source.getSourceId().toString() + NameACardEffect.INFO_KEY))) {
                return true;
            }
        }
    }
    return false;
}

Output:
 public boolean applies(GameEvent event, Ability source, Game game) {
-    if (event.getType() == GameEvent.EventType.ACTIVATE_ABILITY) {
-        MageObject object = game.getObject(event.getSourceId());
-        Ability ability = game.getAbility(event.getTargetId(), event.getSourceId());
-        if (ability != null && object != null) {
-            if (ability.getAbilityType() != AbilityType.MANA && object.getName().equals(game.getState().getValue(source.getSourceId().toString() + NameACardEffect.INFO_KEY))) {
-                return true;
-            }
+    MageObject object = game.getObject(event.getSourceId());
+    Ability ability = game.getAbility(event.getTargetId(), event.getSourceId());
+    if (ability != null && object != null) {
+        if (!ability.getAbilityType().equals(AbilityType.MANA) && object.getName().equals(game.getState().getValue(source.getSourceId().toString() + NameACardEffect.INFO_KEY))) {
+            return true;
         }


Input:
public static void writeFully(FileChannel file, long pos, ByteBuffer src) {
    try {
        int off = 0;
        do {
            int len = file.write(src, pos + off);
            off += len;
        } while (src.remaining() > 0);
    } catch (IOException e) {
        throw newIllegalStateException("String_Node_Str", file, src.remaining(), pos, e);
    }
}

Output:
     } catch (IOException e) {
-        throw newIllegalStateException("String_Node_Str", file, src.remaining(), pos, e);
+        throw newIllegalStateException(ERROR_WRITING_FAILED, "String_Node_Str", file, src.remaining(), pos, e);
     }


Input:
public Set<IProject> build(int kind, IProgressMonitor monitor) throws Exception {
    IMaven maven = MavenPlugin.getMaven();
    BuildContext buildContext = getBuildContext();
    File[] sources = maven.getMojoParameterValue(getSession().getCurrentProject(), getMojoExecution(), "String_Node_Str", File[].class, monitor);
    boolean changed = false;
    for (File source : sources) {
        Scanner ds = buildContext.newScanner(source);
        ds.scan();
        String[] includedFiles = ds.getIncludedFiles();
        if (includedFiles != null && includedFiles.length > 0) {
            changed = true;
        }
    }
    if (!changed) {
        return null;
    }
    Set<IProject> result = super.build(kind, monitor);
    YangGeneratorConfiguration[] confs = maven.getMojoParameterValue(getSession().getCurrentProject(), getMojoExecution(), "String_Node_Str", YangGeneratorConfiguration[].class, monitor);
    if (confs != null) {
        for (YangGeneratorConfiguration conf : confs) {
            if (conf.getOutputBaseDir() != null) {
                buildContext.refresh(conf.getOutputBaseDir());
            }
        }
    }
    return result;
}

Output:
     BuildContext buildContext = getBuildContext();
-    File[] sources = maven.getMojoParameterValue(getSession().getCurrentProject(), getMojoExecution(), "String_Node_Str", File[].class, monitor);
-    boolean changed = false;
-    for (File source : sources) {
-        Scanner ds = buildContext.newScanner(source);
-        ds.scan();
-        String[] includedFiles = ds.getIncludedFiles();
-        if (includedFiles != null && includedFiles.length > 0) {
-            changed = true;
-        }
-    }
-    if (!changed) {
+    File source = maven.getMojoParameterValue(getSession().getCurrentProject(), getMojoExecution(), "String_Node_Str", File.class, monitor);
+    Scanner ds = buildContext.newScanner(source);
+    ds.scan();
+    String[] includedFiles = ds.getIncludedFiles();
+    if (includedFiles == null || includedFiles.length <= 0) {
         return null;


Input:
public synchronized void preloadPlan(RecentsTaskLoader loader, boolean isTopTaskHome) {
    if (DEBUG)
        Log.d(TAG, "String_Node_Str");
    RecentsConfiguration config = Recents.getConfiguration();
    SystemServicesProxy ssp = Recents.getSystemServices();
    Resources res = mContext.getResources();
    ArrayList<Task> freeformTasks = new ArrayList<>();
    ArrayList<Task> stackTasks = new ArrayList<>();
    if (mRawTasks == null) {
        preloadRawTasks(isTopTaskHome);
    }
    int taskCount = mRawTasks.size();
    for (int i = 0; i < taskCount; i++) {
        ActivityManager.RecentTaskInfo t = mRawTasks.get(i);
        Task.TaskKey taskKey = new Task.TaskKey(t.persistentId, t.stackId, t.baseIntent, t.userId, t.firstActiveTime, t.lastActiveTime);
        String activityLabel = loader.getAndUpdateActivityLabel(taskKey, t.taskDescription, ssp);
        String contentDescription = loader.getAndUpdateContentDescription(taskKey, activityLabel, ssp, res);
        Drawable activityIcon = loader.getAndUpdateActivityIcon(taskKey, t.taskDescription, ssp, res, false);
        int activityColor = loader.getActivityPrimaryColor(t.taskDescription);
        Bitmap icon = t.taskDescription != null ? t.taskDescription.getInMemoryIcon() : null;
        String iconFilename = t.taskDescription != null ? t.taskDescription.getIconFilename() : null;
        Task task = new Task(taskKey, (t.id != INVALID_TASK_ID), t.affiliatedTaskId, t.affiliatedTaskColor, activityLabel, contentDescription, activityIcon, activityColor, (i == (taskCount - 1)), config.lockToAppEnabled, icon, iconFilename, t.bounds);
        task.thumbnail = loader.getAndUpdateThumbnail(taskKey, ssp, false);
        if (DEBUG) {
            Log.d(TAG, activityLabel + "String_Node_Str" + t.bounds);
        }
        if (task.isFreeformTask()) {
            freeformTasks.add(task);
        } else {
            stackTasks.add(task);
        }
    }
    ArrayList<Task> allTasks = new ArrayList<>();
    allTasks.addAll(stackTasks);
    allTasks.addAll(freeformTasks);
    mStack = new TaskStack();
    mStack.setTasks(allTasks);
    mStack.createAffiliatedGroupings(mContext);
}

Output:
         String iconFilename = t.taskDescription != null ? t.taskDescription.getIconFilename() : null;
-        Task task = new Task(taskKey, (t.id != INVALID_TASK_ID), t.affiliatedTaskId, t.affiliatedTaskColor, activityLabel, contentDescription, activityIcon, activityColor, (i == (taskCount - 1)), config.lockToAppEnabled, icon, iconFilename, t.bounds);
+        Task task = new Task(taskKey, t.affiliatedTaskId, t.affiliatedTaskColor, activityLabel, contentDescription, activityIcon, activityColor, (i == (taskCount - 1)), config.lockToAppEnabled, icon, iconFilename, t.bounds);
         task.thumbnail = loader.getAndUpdateThumbnail(taskKey, ssp, false);


Input:
protected TBase<?, ?> deserialize(HeaderTBaseDeserializer deserializer, ResponseMessage responseMessage) {
    byte[] message = responseMessage.getMessage();
    Message<TBase<?, ?>> deserialize = SerializationUtils.deserialize(message, deserializer, null);
    return deserialize.getData();
}

Output:
 protected TBase<?, ?> deserialize(HeaderTBaseDeserializer deserializer, ResponseMessage responseMessage) {
-    byte[] message = responseMessage.getMessage();
-    Message<TBase<?, ?>> deserialize = SerializationUtils.deserialize(message, deserializer, null);
+    final byte[] message = responseMessage.getMessage();
+    final Message<TBase<?, ?>> deserialize = SerializationUtils.deserialize(message, deserializer, null);
+    if (deserialize == null) {
+        return null;
+    }
     return deserialize.getData();


Input:
public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) throws DatabaseException {
    ContainerPolicy cp = this.getContainerPolicy();
    Object fieldValue = row.getValues(this.getField());
    if ((fieldValue == null) || (fieldValue instanceof String)) {
        return cp.containerInstance();
    }
    Vector nestedRows = this.getDescriptor().buildNestedRowsFromFieldValue(fieldValue, executionSession);
    if (nestedRows == null) {
        return cp.containerInstance();
    }
    Object result = cp.containerInstance(nestedRows.size());
    for (Enumeration stream = nestedRows.elements(); stream.hasMoreElements(); ) {
        AbstractRecord nestedRow = (AbstractRecord) stream.nextElement();
        Object objectToAdd = null;
        ClassDescriptor aDescriptor = getReferenceDescriptor((DOMRecord) nestedRow);
        if (aDescriptor == null) {
            if ((getKeepAsElementPolicy() == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) || (getKeepAsElementPolicy() == UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT)) {
                XMLPlatformFactory.getInstance().getXMLPlatform().namespaceQualifyFragment((Element) ((DOMRecord) nestedRow).getDOM());
                objectToAdd = ((DOMRecord) nestedRow).getDOM();
                if (getConverter() != null) {
                    if (getConverter() instanceof XMLConverter) {
                        objectToAdd = ((XMLConverter) getConverter()).convertDataValueToObjectValue(objectToAdd, executionSession, ((XMLRecord) nestedRow).getUnmarshaller());
                    } else {
                        objectToAdd = getConverter().convertDataValueToObjectValue(objectToAdd, executionSession);
                    }
                }
            } else {
                NodeList children = ((Element) ((DOMRecord) nestedRow).getDOM()).getChildNodes();
                for (int i = 0; i < children.getLength(); i++) {
                    Node nextNode = children.item(i);
                    if (nextNode.getNodeType() == nextNode.ELEMENT_NODE) {
                        throw XMLMarshalException.noDescriptorFound(this);
                    }
                }
                Element theElement = ((Element) ((DOMRecord) nestedRow).getDOM());
                Node textchild = theElement.getFirstChild();
                if ((textchild != null) && (textchild.getNodeType() == Node.TEXT_NODE)) {
                    objectToAdd = ((Text) textchild).getNodeValue();
                }
                if ((objectToAdd != null) && !objectToAdd.equals("String_Node_Str")) {
                    String type = theElement.getAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
                    if ((null != type) && !type.equals("String_Node_Str")) {
                        XPathFragment typeFragment = new XPathFragment(type);
                        String namespaceURI = ((DOMRecord) nestedRow).resolveNamespacePrefix(typeFragment.getPrefix());
                        typeFragment.setNamespaceURI(namespaceURI);
                        QName schemaTypeQName = new QName(namespaceURI, typeFragment.getLocalName());
                        Class theClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(schemaTypeQName);
                        if (theClass != null) {
                            objectToAdd = ((XMLConversionManager) executionSession.getDatasourcePlatform().getConversionManager()).convertObject(objectToAdd, theClass, schemaTypeQName);
                        }
                    }
                }
            }
        } else {
            if (aDescriptor.hasInheritance()) {
                Class newElementClass = aDescriptor.getInheritancePolicy().classFromRow(nestedRow, executionSession);
                if (newElementClass == null) {
                    QName leafElementType = ((XMLField) getField()).getLeafElementType();
                    if (leafElementType != null) {
                        Object indicator = aDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(leafElementType);
                        if (indicator == null) {
                            throw DescriptorException.missingClassForIndicatorFieldValue(leafElementType, aDescriptor.getInheritancePolicy().getDescriptor());
                        }
                        newElementClass = (Class) indicator;
                    }
                }
                if (newElementClass != null) {
                    aDescriptor = this.getReferenceDescriptor(newElementClass, executionSession);
                } else {
                    if (Modifier.isAbstract(aDescriptor.getJavaClass().getModifiers())) {
                        throw DescriptorException.missingClassIndicatorField(nestedRow, aDescriptor.getInheritancePolicy().getDescriptor());
                    }
                }
            }
            objectToAdd = buildCompositeObject(aDescriptor, nestedRow, sourceQuery, joinManager);
            if (hasConverter()) {
                if (getConverter() instanceof XMLConverter) {
                    objectToAdd = ((XMLConverter) getConverter()).convertDataValueToObjectValue(objectToAdd, executionSession, ((XMLRecord) nestedRow).getUnmarshaller());
                } else {
                    objectToAdd = getConverter().convertDataValueToObjectValue(objectToAdd, executionSession);
                }
            }
        }
        cp.addInto(objectToAdd, result, sourceQuery.getSession());
        if (null != containerAccessor) {
            containerAccessor.setAttributeValueInObject(objectToAdd, ((DOMRecord) nestedRow).getOwningObject());
        }
    }
    return result;
}

Output:
                 }
-                Element theElement = ((Element) ((DOMRecord) nestedRow).getDOM());
-                Node textchild = theElement.getFirstChild();
-                if ((textchild != null) && (textchild.getNodeType() == Node.TEXT_NODE)) {
-                    objectToAdd = ((Text) textchild).getNodeValue();
-                }
-                if ((objectToAdd != null) && !objectToAdd.equals("String_Node_Str")) {
-                    String type = theElement.getAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
-                    if ((null != type) && !type.equals("String_Node_Str")) {
-                        XPathFragment typeFragment = new XPathFragment(type);
-                        String namespaceURI = ((DOMRecord) nestedRow).resolveNamespacePrefix(typeFragment.getPrefix());
-                        typeFragment.setNamespaceURI(namespaceURI);
-                        QName schemaTypeQName = new QName(namespaceURI, typeFragment.getLocalName());
-                        Class theClass = (Class) XMLConversionManager.getDefaultXMLTypes().get(schemaTypeQName);
-                        if (theClass != null) {
-                            objectToAdd = ((XMLConversionManager) executionSession.getDatasourcePlatform().getConversionManager()).convertObject(objectToAdd, theClass, schemaTypeQName);
-                        }
-                    }
-                }
+                objectToAdd = convertToSimpleTypeIfPresent(objectToAdd, nestedRow, executionSession);
             }


Input:
public void veryHardShouldConquerHard() throws MapLoadException {
    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 82 * MINUTES);
}

Output:
 public void veryHardShouldConquerHard() throws MapLoadException {
-    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 82 * MINUTES);
+    holdBattleBetween(EPlayerType.AI_VERY_HARD, EPlayerType.AI_HARD, 95 * MINUTES);
 }


Input:
public static void registerJSObject(Scriptable targetScope, ILinkedResult source) {
    int type = ((ILinkedResult) source).getCurrentResultType();
    if (type == ILinkedResult.TYPE_TABLE) {
        targetScope.put("String_Node_Str", targetScope, new JSResultIteratorObject((ILinkedResult) source));
    } else if (type == ILinkedResult.TYPE_CUBE) {
        Scriptable scope = ((ICubeCursor) source.getCurrentResult()).getScope();
        targetScope.put("String_Node_Str", targetScope, scope.get("String_Node_Str", scope));
        targetScope.put("String_Node_Str", targetScope, scope.get("String_Node_Str", scope));
        targetScope.put("String_Node_Str", targetScope, scope.get("String_Node_Str", scope));
    }
}

Output:
     if (type == ILinkedResult.TYPE_TABLE) {
-        targetScope.put("String_Node_Str", targetScope, new JSResultIteratorObject((ILinkedResult) source));
+        targetScope.put("String_Node_Str", targetScope, new JSResultIteratorObject((ILinkedResult) source, context));
     } else if (type == ILinkedResult.TYPE_CUBE) {


Input:
private void toggleViews(boolean enabled) {
    mShowHeader.setEnabled(enabled);
    mShowImages.setEnabled(enabled);
    mPreviewHeader.setEnabled(enabled);
    mRelatedPostsListHeader.setEnabled(enabled);
    mRelatedPostsList.setEnabled(enabled);
}

Output:
     mRelatedPostsListHeader.setEnabled(enabled);
-    mRelatedPostsList.setEnabled(enabled);
+    if (enabled) {
+        mRelatedPostsList.setAlpha(1.0f);
+    } else {
+        mRelatedPostsList.setAlpha(0.5f);
+    }
 }


Input:
public void afterPropertiesSet() {
    client = new TransportClient().addTransportAddress(new InetSocketTransportAddress(serverIP, port));
}

Output:
 public void afterPropertiesSet() {
-    client = new TransportClient().addTransportAddress(new InetSocketTransportAddress(serverIP, port));
+    Settings settings = ImmutableSettings.settingsBuilder().classLoader(ElasticsearchIndexSearcher.class.getClassLoader()).build();
+    client = new TransportClient(settings).addTransportAddress(new InetSocketTransportAddress(serverIP, port));
 }


Input:
private boolean disconnectNetwork(CallbackContext callbackContext, JSONArray data) {
    if (!validateData(data)) {
        return false;
    }
    String ssidToDisconnect = data.get(0);
    int networkIdToDisconnect = ssidToNetworkId(ssidToDisconnect);
    if (networkIdToDisconnect > 0) {
        wifiManager.disableNetwork(networkIdToDisconnect);
        callbackContext.success("String_Node_Str" + ssidToConnect + "String_Node_Str");
        return true;
    } else {
        callbackContext.error("String_Node_Str" + ssidToConnect + "String_Node_Str");
        return false;
    }
}

Output:
     }
-    String ssidToDisconnect = data.get(0);
+    String ssidToDisconnect = data.getString(0);
     int networkIdToDisconnect = ssidToNetworkId(ssidToDisconnect);


Input:
static void ingestDocument(Context context, DSpaceObject parent, PackageParameters params, Document document) throws SQLException, AuthorizeException, PackageException {
    String myEmail = context.getCurrentUser().getEmail();
    String myNetid = context.getCurrentUser().getNetid();
    NodeList users = document.getElementsByTagName(RoleDisseminator.EPERSON);
    for (int i = 0; i < users.getLength(); i++) {
        Element user = (Element) users.item(i);
        NodeList emails = user.getElementsByTagName(RoleDisseminator.EMAIL);
        NodeList netids = user.getElementsByTagName(RoleDisseminator.NETID);
        EPerson eperson;
        EPerson collider;
        String email = null;
        String netid = null;
        String identity;
        if (emails.getLength() > 0) {
            email = emails.item(0).getTextContent();
            if (email.equals(myEmail))
                continue;
            identity = email;
            collider = EPerson.findByEmail(context, identity);
        } else if (netids.getLength() > 0) {
            netid = netids.item(0).getTextContent();
            if (netid.equals(myNetid))
                continue;
            identity = netid;
            collider = EPerson.findByNetid(context, identity);
        } else
            throw new PackageException("String_Node_Str");
        if (null != collider)
            if (params.replaceModeEnabled()) {
                eperson = collider;
            } else if (params.keepExistingModeEnabled()) {
                log.warn("String_Node_Str", identity);
                continue;
            } else
                throw new PackageException("String_Node_Str" + identity + "String_Node_Str");
        else {
            eperson = EPerson.create(context);
            log.info("String_Node_Str", identity);
        }
        eperson.setEmail(email);
        eperson.setNetid(netid);
        NodeList data;
        data = user.getElementsByTagName(RoleDisseminator.FIRST_NAME);
        if (data.getLength() > 0)
            eperson.setFirstName(data.item(0).getTextContent());
        else
            eperson.setFirstName(null);
        data = user.getElementsByTagName(RoleDisseminator.LAST_NAME);
        if (data.getLength() > 0)
            eperson.setLastName(data.item(0).getTextContent());
        else
            eperson.setLastName(null);
        data = user.getElementsByTagName(RoleDisseminator.LANGUAGE);
        if (data.getLength() > 0)
            eperson.setLanguage(data.item(0).getTextContent());
        else
            eperson.setLanguage(null);
        data = user.getElementsByTagName(RoleDisseminator.CAN_LOGIN);
        eperson.setCanLogIn(data.getLength() > 0);
        data = user.getElementsByTagName(RoleDisseminator.REQUIRE_CERTIFICATE);
        eperson.setRequireCertificate(data.getLength() > 0);
        data = user.getElementsByTagName(RoleDisseminator.SELF_REGISTERED);
        eperson.setSelfRegistered(data.getLength() > 0);
        data = user.getElementsByTagName(RoleDisseminator.PASSWORD_HASH);
        if (data.getLength() > 0)
            eperson.setPasswordHash(data.item(0).getTextContent());
        else
            eperson.setPasswordHash(null);
        eperson.update();
    }
    NodeList groups = document.getElementsByTagName(RoleDisseminator.GROUP);
    for (int groupx = 0; groupx < groups.getLength(); groupx++) {
        Element group = (Element) groups.item(groupx);
        String name = group.getAttribute(RoleDisseminator.NAME);
        name = PackageUtils.crosswalkDefaultGroupName(context, name);
        Group groupObj = null;
        Group collider = Group.findByName(context, name);
        if (null != collider) {
            if (params.replaceModeEnabled()) {
                for (Group member : collider.getMemberGroups()) collider.removeMember(member);
                for (EPerson member : collider.getMembers()) collider.removeMember(member);
                log.info("String_Node_Str", name);
                groupObj = collider;
            } else if (params.keepExistingModeEnabled()) {
                log.warn("String_Node_Str", name);
                continue;
            } else
                throw new PackageException("String_Node_Str" + name + "String_Node_Str");
        } else {
            String type = group.getAttribute(RoleDisseminator.TYPE);
            if (type != null && !type.isEmpty() && parent != null) {
                if (parent.getType() == Constants.COLLECTION) {
                    Collection collection = (Collection) parent;
                    if (type.equals(RoleDisseminator.GROUP_TYPE_ADMIN))
                        groupObj = collection.createAdministrators();
                    else if (type.equals(RoleDisseminator.GROUP_TYPE_SUBMIT))
                        groupObj = collection.createSubmitters();
                    else if (type.equals(RoleDisseminator.GROUP_TYPE_WORKFLOW_STEP_1))
                        groupObj = collection.createWorkflowGroup(1);
                    else if (type.equals(RoleDisseminator.GROUP_TYPE_WORKFLOW_STEP_2))
                        groupObj = collection.createWorkflowGroup(2);
                    else if (type.equals(RoleDisseminator.GROUP_TYPE_WORKFLOW_STEP_3))
                        groupObj = collection.createWorkflowGroup(3);
                } else if (parent.getType() == Constants.COMMUNITY) {
                    Community community = (Community) parent;
                    if (type.equals(RoleDisseminator.GROUP_TYPE_ADMIN))
                        groupObj = community.createAdministrators();
                }
            }
            if (groupObj == null) {
                groupObj = Group.create(context);
                groupObj.setName(name);
            }
            log.info("String_Node_Str", groupObj.getName());
        }
        NodeList members = group.getElementsByTagName(RoleDisseminator.MEMBER);
        for (int memberx = 0; memberx < members.getLength(); memberx++) {
            Element member = (Element) members.item(memberx);
            String memberName = member.getAttribute(RoleDisseminator.NAME);
            EPerson memberEPerson = EPerson.findByEmail(context, memberName);
            groupObj.addMember(memberEPerson);
        }
        groupObj.update();
    }
    for (int groupx = 0; groupx < groups.getLength(); groupx++) {
        Element group = (Element) groups.item(groupx);
        String name = group.getAttribute(RoleDisseminator.NAME);
        name = PackageUtils.crosswalkDefaultGroupName(context, name);
        Group groupObj = Group.findByName(context, name);
        NodeList members = group.getElementsByTagName(RoleDisseminator.MEMBER_GROUP);
        for (int memberx = 0; memberx < members.getLength(); memberx++) {
            Element member = (Element) members.item(memberx);
            String memberName = member.getAttribute(RoleDisseminator.NAME);
            memberName = PackageUtils.crosswalkDefaultGroupName(context, memberName);
            Group memberGroup = Group.findByName(context, memberName);
            groupObj.addMember(memberGroup);
        }
        groupObj.update();
    }
}

Output:
         String name = group.getAttribute(RoleDisseminator.NAME);
-        name = PackageUtils.crosswalkDefaultGroupName(context, name);
+        try {
+            name = PackageUtils.translateGroupNameForImport(context, name);
+        } catch (PackageException pe) {
+            log.warn("String_Node_Str" + name + "String_Node_Str" + "String_Node_Str");
+            continue;
+        }
         Group groupObj = null;


Input:
public org.hl7.fhir.dstu2.model.Media convertMedia(org.hl7.fhir.dstu3.model.Media src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.Media tgt = new org.hl7.fhir.dstu2.model.Media();
    copyDomainResource(src, tgt);
    for (org.hl7.fhir.dstu3.model.Identifier t : src.getIdentifier()) tgt.addIdentifier(convertIdentifier(t));
    tgt.setType(convertDigitalMediaType(src.getType()));
    tgt.setSubtype(convertCodeableConcept(src.getSubtype()));
    tgt.setView(convertCodeableConcept(src.getView()));
    tgt.setSubject(convertReference(src.getSubject()));
    tgt.setOperator(convertReference(src.getOperator()));
    tgt.setDeviceName(src.getDeviceName());
    tgt.setHeight(src.getHeight());
    tgt.setWidth(src.getWidth());
    tgt.setFrames(src.getFrames());
    tgt.setDuration(src.getDuration());
    tgt.setContent(convertAttachment(src.getContent()));
    return tgt;
}

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


Input:
public void setMetric(ConsumerMetric m, MetricData result) {
    SummaryPanel panel = null;
    String date1Header = "String_Node_Str";
    String date2Header = "String_Node_Str";
    if (result != null) {
        String d1 = ConsoleUtil.timeFormat.format(new Date(result.getMetricCriteria().date1));
        String d2 = ConsoleUtil.timeFormat.format(new Date(result.getMetricCriteria().date2));
        date1Header = d1 + "String_Node_Str" + (result.getMetricCriteria().durationSec / (60 * 60)) + ConsoleUtil.constants.hr();
        date2Header = d2 + "String_Node_Str" + (result.getMetricCriteria().durationSec / (60 * 60)) + ConsoleUtil.constants.hr();
    }
    switch(m) {
        case CallVolume:
            {
                String[] columns = { ConsoleUtil.constants.consumers(), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        rowData[0] = new Label(rd.getCriteriaInfo().getConsumerName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(callVolumeTable, columns, rows);
                for (int i = 1; i < callVolumeTable.getRowCount(); i++) {
                    Widget w = callVolumeTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = callVolumePanel;
                break;
            }
        case Performance:
            {
                String[] columns = { ConsoleUtil.constants.consumers(), (result == null ? ConsoleUtil.constants.average() : date2Header + "String_Node_Str" + ConsoleUtil.constants.average() + "String_Node_Str"), (result == null ? ConsoleUtil.constants.average() : date1Header + "String_Node_Str" + ConsoleUtil.constants.average() + "String_Node_Str"), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        rowData[0] = new Label(rd.getCriteriaInfo().getConsumerName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(performanceTable, columns, rows);
                for (int i = 1; i < performanceTable.getRowCount(); i++) {
                    Widget w = performanceTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = performancePanel;
                break;
            }
        case Errors:
            {
                String[] columns = { ConsoleUtil.constants.consumers(), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        rowData[0] = new Label(rd.getCriteriaInfo().getConsumerName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(errorsTable, columns, rows);
                for (int i = 1; i < errorsTable.getRowCount(); i++) {
                    Widget w = errorsTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = errorsPanel;
                break;
            }
        case TopVolume:
            {
                String col0 = ConsoleUtil.constants.services();
                if (result != null && result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Operation))
                    col0 = ConsoleUtil.constants.operations();
                String[] columns = { col0, (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        if (result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Service))
                            rowData[0] = new Label(rd.getCriteriaInfo().getServiceName());
                        else if (result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Operation))
                            rowData[0] = new Label(rd.getCriteriaInfo().getOperationName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(topVolumeTable, columns, rows);
                for (int i = 1; i < topVolumeTable.getRowCount(); i++) {
                    Widget w = topVolumeTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = topVolumePanel;
                break;
            }
        case LeastPerformance:
            {
                String col0 = ConsoleUtil.constants.services();
                if (result != null && result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Operation))
                    col0 = ConsoleUtil.constants.operations();
                String[] columns = { col0, (result == null ? ConsoleUtil.constants.average() : date2Header + "String_Node_Str" + ConsoleUtil.constants.average() + "String_Node_Str"), (result == null ? ConsoleUtil.constants.average() : date1Header + "String_Node_Str" + ConsoleUtil.constants.average() + "String_Node_Str"), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        if (result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Service))
                            rowData[0] = new Label(rd.getCriteriaInfo().getServiceName());
                        else if (result.getMetricResourceCriteria().resourceEntityResponseType.equals(Entity.Operation))
                            rowData[0] = new Label(rd.getCriteriaInfo().getOperationName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(leastPerformanceTable, columns, rows);
                for (int i = 1; i < leastPerformanceTable.getRowCount(); i++) {
                    Widget w = leastPerformanceTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = leastPerformancePanel;
                break;
            }
        case TopServiceErrors:
            {
                boolean isOperation = false;
                if (result != null && result.getMetricResourceCriteria() != null && result.getMetricResourceCriteria().resourceEntityRequests != null) {
                    for (ResourceEntityRequest r : result.getMetricResourceCriteria().resourceEntityRequests) {
                        if (r.resourceEntityType == Entity.Operation)
                            isOperation = true;
                    }
                }
                String col0 = ConsoleUtil.constants.services();
                if (isOperation)
                    col0 = ConsoleUtil.constants.operations();
                String[] columns = { col0, ConsoleUtil.constants.errors(), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[5];
                        if (isOperation)
                            rowData[0] = new Label(rd.getCriteriaInfo().getOperationName());
                        else
                            rowData[0] = new Label(rd.getCriteriaInfo().getServiceName());
                        rowData[1] = new Label(rd.getCriteriaInfo().getMetricName());
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[3] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[4] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(topServiceErrorsTable, columns, rows);
                for (int i = 1; i < topServiceErrorsTable.getRowCount(); i++) {
                    Widget w = topServiceErrorsTable.getWidget(i, 0);
                    w.addStyleName("String_Node_Str");
                }
                panel = topServiceErrorsPanel;
                break;
            }
        case TopConsumerErrors:
            {
                String[] columns = { ConsoleUtil.constants.errors(), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                List<Widget[]> rows = new ArrayList<Widget[]>();
                if (result != null) {
                    for (int i = 0; i < result.getReturnData().size(); i++) {
                        MetricGroupData rd = result.getReturnData().get(i);
                        Widget[] rowData = new Widget[4];
                        rowData[0] = new Label(rd.getCriteriaInfo().getMetricName());
                        rowData[1] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount2())));
                        rowData[2] = new Label(NumberFormat.getDecimalFormat().format(Double.parseDouble(rd.getCount1())));
                        rowData[3] = new Label(rd.getDiff());
                        rows.add(rowData);
                    }
                }
                setTabularData(topConsumerErrorsTable, columns, rows);
                panel = topConsumerErrorsPanel;
                break;
            }
    }
    if (result != null && result.getReturnData() != null && panel != null) {
        int rows = result.getReturnData().size() + 1;
        double height = 0;
        if (rows > 10)
            height = 10 * 2.5;
        else
            height = rows * 2.5;
        panel.setContentContainerHeight(String.valueOf(height) + "String_Node_Str");
    }
    if (panel != null) {
        if (result != null)
            panel.setInfo(result.getRestUrl());
        show(panel);
    }
}

Output:
                     col0 = ConsoleUtil.constants.operations();
-                String[] columns = { col0, ConsoleUtil.constants.errors(), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
+                String[] columns = { col0, ConsoleUtil.constants.errors(), (result == null ? ConsoleUtil.constants.count() : date2Header + "String_Node_Str" + ConsoleUtil.constants.count()), (result == null ? ConsoleUtil.constants.count() : date1Header + "String_Node_Str" + ConsoleUtil.constants.count()), "String_Node_Str" + ConsoleUtil.constants.change() };
                 List<Widget[]> rows = new ArrayList<Widget[]>();


Input:
private void convertKeys2csv(String fileName, Date dateObj) {
    DateFormat df = new SimpleDateFormat("String_Node_Str");
    BufferedReader br;
    BufferedWriter bw;
    try {
        br = new BufferedReader(new FileReader(new File(fileName + "String_Node_Str")));
        bw = new BufferedWriter(new FileWriter(new File(fileName + "String_Node_Str" + df.format(dateObj) + "String_Node_Str")));
        String currentLine = "String_Node_Str";
        bw.write(currentLine);
        bw.newLine();
        while ((currentLine = br.readLine()) != null) {
            currentLine = currentLine.replace('\t', ',');
            List<String> wordList = Arrays.asList(currentLine.split("String_Node_Str"));
            bw.write(wordList.get(0) + "String_Node_Str" + wordList.get(2));
            bw.newLine();
        }
        br.close();
        bw.close();
        ConsoleView.printlInConsoleln("String_Node_Str" + fileName + "String_Node_Str" + df.format(dateObj) + "String_Node_Str");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
             List<String> wordList = Arrays.asList(currentLine.split("String_Node_Str"));
-            bw.write(wordList.get(0) + "String_Node_Str" + wordList.get(2));
+            if (wordList.size() > 0)
+                bw.append(wordList.get(0));
+            if (wordList.size() > 2)
+                bw.append("String_Node_Str" + wordList.get(2));
             bw.newLine();


Input:
public void deobfuscateIdentifiers(HashMap<String, String> namesMap, RenameType renameType) {
    Set<Integer> stringUsages = getStringUsages();
    Map<Integer, String> stringUsageTypes = new HashMap<>();
    informListeners("String_Node_Str", "String_Node_Str");
    getStringUsageTypes(stringUsageTypes);
    for (int i = 1; i < instance_info.length; i++) {
        informListeners("String_Node_Str", "String_Node_Str" + i + "String_Node_Str" + instance_info.length);
        if (instance_info[i].name_index != 0) {
            constants.constant_multiname[instance_info[i].name_index].name_index = deobfuscateName(stringUsageTypes, stringUsages, namesMap, constants.constant_multiname[instance_info[i].name_index].name_index, true, renameType);
        }
        if (instance_info[i].super_index != 0) {
            constants.constant_multiname[instance_info[i].super_index].name_index = deobfuscateName(stringUsageTypes, stringUsages, namesMap, constants.constant_multiname[instance_info[i].super_index].name_index, true, renameType);
        }
    }
    for (int i = 1; i < constants.constant_multiname.length; i++) {
        informListeners("String_Node_Str", "String_Node_Str" + i + "String_Node_Str" + constants.constant_multiname.length);
        constants.constant_multiname[i].name_index = deobfuscateName(stringUsageTypes, stringUsages, namesMap, constants.constant_multiname[i].name_index, false, renameType);
    }
    for (int i = 1; i < constants.constant_namespace.length; i++) {
        informListeners("String_Node_Str", "String_Node_Str" + i + "String_Node_Str" + constants.constant_namespace.length);
        constants.constant_namespace[i].name_index = deobfuscateNameSpace(stringUsageTypes, stringUsages, namesMap, constants.constant_namespace[i].name_index, renameType);
    }
}

Output:
         if (instance_info[i].name_index != 0) {
-            constants.constant_multiname[instance_info[i].name_index].name_index = deobfuscateName(stringUsageTypes, stringUsages, namesMap, constants.constant_multiname[instance_info[i].name_index].name_index, true, renameType);
+            constants.constant_multiname[instance_info[i].name_index].name_index = deobfuscateName(stringUsageTypes, stringUsages, namespaceUsages, namesMap, constants.constant_multiname[instance_info[i].name_index].name_index, true, renameType);
+            if (constants.constant_multiname[instance_info[i].name_index].namespace_index != 0) {
+                constants.constant_namespace[constants.constant_multiname[instance_info[i].name_index].namespace_index].name_index = deobfuscateNameSpace(stringUsageTypes, stringUsages, namesMap, constants.constant_namespace[constants.constant_multiname[instance_info[i].name_index].namespace_index].name_index, renameType);
+            }
         }


Input:
public void onOpen(SQLiteDatabase db) {
    databaseHelperDelegate.onOpen(SQLCipherDatabase.from(db));
}

Output:
 public void onOpen(SQLiteDatabase db) {
-    databaseHelperDelegate.onOpen(SQLCipherDatabase.from(db));
+    baseDatabaseHelper.onOpen(SQLCipherDatabase.from(db));
 }


Input:
public void watch(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.MANA_PAYED) {
        MageObject object = game.getObject(event.getSourceId());
        if (object != null && object.getName().equals("String_Node_Str") && event.getFlag()) {
            spells.add(event.getTargetId());
        }
    }
}

Output:
     if (event.getType() == GameEvent.EventType.MANA_PAYED) {
-        MageObject object = game.getObject(event.getSourceId());
-        if (object != null && object.getName().equals("String_Node_Str") && event.getFlag()) {
+        if (event.getData() != null && event.getData().equals(originalId)) {
             spells.add(event.getTargetId());


Input:
public void apply(Table table) throws Exception {
    table.put(getRowKey(logPartition), Bytes.toBytes(startTimeMs), Bytes.toBytes(location.toURI().toString()));
}

Output:
 public void apply(Table table) throws Exception {
-    table.put(getRowKey(logPartition), Bytes.toBytes(startTimeMs), Bytes.toBytes(location.toURI().toString()));
+    String locationPath = Locations.getRelativePath(rootLocationFactory, location.toURI());
+    table.put(getRowKey(logPartition), Bytes.toBytes(startTimeMs), Bytes.toBytes(locationPath));
 }


Input:
public final float getSunlight(int x, int y, int z) {
    int chunkPosX = calcChunkPosX(x) % (int) Configuration.viewingDistanceInChunks.x;
    int chunkPosY = calcChunkPosY(y) % (int) Configuration.viewingDistanceInChunks.y;
    int chunkPosZ = calcChunkPosZ(z) % (int) Configuration.viewingDistanceInChunks.z;
    int blockPosX = calcBlockPosX(x, chunkPosX);
    int blockPosY = calcBlockPosY(y, chunkPosY);
    int blockPosZ = calcBlockPosZ(z, chunkPosZ);
    try {
        Chunk c = chunks[chunkPosX][chunkPosY][chunkPosZ];
        if (c.getPosition().x == calcChunkPosX(x) && c.getPosition().y == calcChunkPosY(y) && c.getPosition().z == calcChunkPosZ(z)) {
            return c.getSunlight(blockPosX, blockPosY, blockPosZ);
        }
    } catch (Exception e) {
    }
    return -1f;
}

Output:
     try {
-        Chunk c = chunks[chunkPosX][chunkPosY][chunkPosZ];
+        Chunk c = getChunk(chunkPosX, chunkPosY, chunkPosZ);
         if (c.getPosition().x == calcChunkPosX(x) && c.getPosition().y == calcChunkPosY(y) && c.getPosition().z == calcChunkPosZ(z)) {


Input:
public void onStopUpdates(View view) {
    if (!servicesConnected()) {
        return;
    }
    mRunning = true;
    mRequestType = ActivityUtils.REQUEST_TYPE.REMOVE;
    mActivityDetectionRemover.removeUpdates(mActivityDetectionRequester.getRequestPendingIntent());
    mActivityDetectionRequester.getRequestPendingIntent().cancel();
    ((TextView) view).setText(R.string.start_updates);
}

Output:
     }
-    mRunning = true;
+    mRunning = false;
     mRequestType = ActivityUtils.REQUEST_TYPE.REMOVE;


Input:
private void initializeGlobals(RenderScript RS, ScriptC_noroot s) {
    Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS));
    int X = 5;
    int Y = 7;
    s.set_dimX(X);
    s.set_dimY(Y);
    typeBuilder.setX(X).setY(Y);
    A = Allocation.createTyped(RS, typeBuilder.create());
    s.bind_a(A);
    return;
}

Output:
     A = Allocation.createTyped(RS, typeBuilder.create());
-    s.bind_a(A);
+    s.set_aRaw(A);
     return;


Input:
private void Bld_kv_ary(Bry_bfr bfr, Keyval[] ary) {
    int len = ary.length;
    bfr.Add_str_a7("String_Node_Str").Add_int_variable(len).Add_str_a7("String_Node_Str");
    for (int i = 0; i < len; i++) {
        Keyval kv = ary[i];
        Bld_obj(bfr, kv.Key_as_obj());
        Bld_obj(bfr, kv.Val());
    }
    bfr.Add_byte(Byte_ascii.Curly_end);
}

Output:
         Keyval kv = ary[i];
-        Bld_obj(bfr, kv.Key_as_obj());
-        Bld_obj(bfr, kv.Val());
+        if (kv == null) {
+            Bld_obj(bfr, gplx.langs.phps.Php_srl_parser.NULL_ARRAY_ITEM);
+        } else {
+            Bld_obj(bfr, kv.Key_as_obj());
+            Bld_obj(bfr, kv.Val());
+        }
     }


Input:
public static void init() {
    SensorManager sensorManager = new SensorManager();
    logger.debug("String_Node_Str");
    List<RegisteredService> allRegisteredServices = sensorManager.getAllRegisteredServices();
    if (allRegisteredServices == null || allRegisteredServices.isEmpty()) {
        logger.debug("String_Node_Str");
        SecurityInitializer securityInitializer = new SecurityInitializer();
        securityInitializer.initialize();
    }
}

Output:
         logger.debug("String_Node_Str");
-        SecurityInitializer securityInitializer = new SecurityInitializer();
+        SecurityInitializer securityInitializer = new SecurityInitializer(securityLsmGraphURL);
         securityInitializer.initialize();


Input:
protected GameState doUpdate(Game game, TimeStep timeStep) {
    if (this.inIntermission) {
        this.currentDelayTime -= timeStep.getDeltaTime();
        if (this.currentDelayTime <= 0) {
            startRound(game);
        }
    } else {
        int numberOfObjectivesInProgress = 0;
        int size = this.outstandingObjectives.size();
        for (int i = 0; i < size; i++) {
            Objective obj = this.outstandingObjectives.get(i);
            if (obj.isCompleted(game)) {
                this.completedObjectives.add(obj);
            } else if (obj.isInProgress(game)) {
                numberOfObjectivesInProgress++;
            }
        }
        this.outstandingObjectives.removeAll(this.completedObjectives);
        if (this.completedObjectives.size() >= this.minimumObjectivesToComplete) {
            endRound(attacker, game);
        } else if (this.outstandingObjectives.isEmpty() && this.completedObjectives.size() > 0) {
            endRound(attacker, game);
        } else if (defender.isTeamDead() && defender.teamSize() > 0) {
            endRound(attacker, game);
        } else if (getRemainingTime() <= 0) {
            endRound(defender, game);
        } else if (attacker.isTeamDead() && attacker.teamSize() > 0 && (!this.outstandingObjectives.isEmpty() ? numberOfObjectivesInProgress < this.outstandingObjectives.size() : true)) {
            endRound(defender, game);
        } else {
            checkSpectating(timeStep, game);
        }
    }
    return this.currentRound >= this.getMaxScore() ? GameState.WINNER : GameState.IN_PROGRESS;
}

Output:
             endRound(defender, game);
-        } else if (attacker.isTeamDead() && attacker.teamSize() > 0 && (!this.outstandingObjectives.isEmpty() ? numberOfObjectivesInProgress < this.outstandingObjectives.size() : true)) {
+        } else if ((attacker.isTeamDead() && attacker.teamSize() > 0) && (numberOfObjectivesInProgress + this.completedObjectives.size() < this.minimumObjectivesToComplete)) {
             endRound(defender, game);


Input:
public List<String> getStoreList(String path) {
    File folder = new File(path);
    File[] listOfFiles = folder.listFiles();
    List<String> storeList = new ArrayList<String>();
    for (File file : listOfFiles) {
        if (file.isDirectory()) {
            storeList.add(file.getName());
        }
    }
    return storeList;
}

Output:
     List<String> storeList = new ArrayList<String>();
-    for (File file : listOfFiles) {
-        if (file.isDirectory()) {
-            storeList.add(file.getName());
+    if (listOfFiles != null) {
+        for (File file : listOfFiles) {
+            if (file.isDirectory()) {
+                storeList.add(file.getName());
+            }
         }


Input:
public IBaseCubeQueryDefinition createCubeQuery(IDataQueryDefinition parent) throws BirtException {
    CubeHandle cubeHandle = handle.getCube();
    ICubeQueryDefinition cubeQuery = null;
    if (cubeHandle == null) {
        cubeHandle = ChartXTabUtil.getBindingCube(handle);
        if (cubeHandle == null) {
            throw new ChartException(ChartReportItemPlugin.ID, ChartException.NULL_DATASET, Messages.getString("String_Node_Str"));
        }
        CrosstabReportItemHandle xtab = ChartXTabUtil.getXtabContainerCell(handle).getCrosstab();
        LevelViewHandle levelColumn = ChartXTabUtil.getInnermostLevel(xtab, ICrosstabConstants.COLUMN_AXIS_TYPE);
        LevelViewHandle levelRow = ChartXTabUtil.getInnermostLevel(xtab, ICrosstabConstants.ROW_AXIS_TYPE);
        if (cm instanceof ChartWithAxes) {
            if (((ChartWithAxes) cm).isTransposed()) {
                if (levelColumn != null) {
                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
                    subCubeQuery.setStartingLevelOnColumn(ChartXTabUtil.createDimensionExpression(levelColumn.getCubeLevel()));
                    return subCubeQuery;
                } else if (ChartXTabUtil.getLevelCount(xtab, ICrosstabConstants.ROW_AXIS_TYPE) > 1) {
                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
                    subCubeQuery.setStartingLevelOnRow(ChartXTabUtil.createDimensionExpression(levelRow.getCubeLevel()));
                    return subCubeQuery;
                }
            } else {
                if (levelRow != null) {
                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
                    subCubeQuery.setStartingLevelOnRow(ChartXTabUtil.createDimensionExpression(levelRow.getCubeLevel()));
                    return subCubeQuery;
                } else if (ChartXTabUtil.getLevelCount(xtab, ICrosstabConstants.COLUMN_AXIS_TYPE) > 1) {
                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
                    subCubeQuery.setStartingLevelOnColumn(ChartXTabUtil.createDimensionExpression(levelColumn.getCubeLevel()));
                    return subCubeQuery;
                }
            }
        }
    }
    cubeQuery = ChartXTabUtil.getCubeElementFactory().createCubeQuery(cubeHandle.getQualifiedName());
    initBindings(cubeQuery, cubeHandle);
    List sdList = getAllSeriesDefinitions(cm);
    for (int i = 0; i < sdList.size(); i++) {
        SeriesDefinition sd = (SeriesDefinition) sdList.get(i);
        List queryList = sd.getDesignTimeSeries().getDataDefinition();
        for (int j = 0; j < queryList.size(); j++) {
            Query query = (Query) queryList.get(j);
            bindSeriesQuery(query, cubeQuery, cubeHandle);
        }
        bindSeriesQuery(sd.getQuery(), cubeQuery, cubeHandle);
    }
    for (int i = 0; i < sdList.size(); i++) {
        SeriesDefinition sd = (SeriesDefinition) sdList.get(i);
        addSorting(cubeQuery, cubeHandle, sd, i);
    }
    addCubeFilter(cubeQuery);
    return cubeQuery;
}

Output:
         }
-        CrosstabReportItemHandle xtab = ChartXTabUtil.getXtabContainerCell(handle).getCrosstab();
-        LevelViewHandle levelColumn = ChartXTabUtil.getInnermostLevel(xtab, ICrosstabConstants.COLUMN_AXIS_TYPE);
-        LevelViewHandle levelRow = ChartXTabUtil.getInnermostLevel(xtab, ICrosstabConstants.ROW_AXIS_TYPE);
-        if (cm instanceof ChartWithAxes) {
-            if (((ChartWithAxes) cm).isTransposed()) {
-                if (levelColumn != null) {
-                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
-                    subCubeQuery.setStartingLevelOnColumn(ChartXTabUtil.createDimensionExpression(levelColumn.getCubeLevel()));
-                    return subCubeQuery;
-                } else if (ChartXTabUtil.getLevelCount(xtab, ICrosstabConstants.ROW_AXIS_TYPE) > 1) {
-                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
-                    subCubeQuery.setStartingLevelOnRow(ChartXTabUtil.createDimensionExpression(levelRow.getCubeLevel()));
-                    return subCubeQuery;
-                }
-            } else {
-                if (levelRow != null) {
-                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
-                    subCubeQuery.setStartingLevelOnRow(ChartXTabUtil.createDimensionExpression(levelRow.getCubeLevel()));
-                    return subCubeQuery;
-                } else if (ChartXTabUtil.getLevelCount(xtab, ICrosstabConstants.COLUMN_AXIS_TYPE) > 1) {
-                    ISubCubeQueryDefinition subCubeQuery = ChartXTabUtil.getCubeElementFactory().createSubCubeQuery(cubeHandle.getQualifiedName());
-                    subCubeQuery.setStartingLevelOnColumn(ChartXTabUtil.createDimensionExpression(levelColumn.getCubeLevel()));
-                    return subCubeQuery;
-                }
-            }
+        ISubCubeQueryDefinition subQuery = createSubCubeQuery();
+        if (subQuery != null) {
+            return subQuery;
         }


Input:
public boolean hasPermission(Player player, String permission) {
    return hasPermission(player, permission);
}

Output:
 public boolean hasPermission(Player player, String permission) {
-    return hasPermission(player, permission);
+    return plugin.hasPermission(player, permission);
 }