Input:
void extractInfo(String link) throws Exception {
    try {
        String url = "String_Node_Str" + link;
        Document doc1 = Jsoup.connect(url).get();
        Element element = doc1.body().child(0).child(0).child(1).child(0).child(0).child(0).child(0).child(1).child(5).child(0).child(2).child(0).child(1);
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("String_Node_Str", strDate);
        jsonGenerator.writeStringField("String_Node_Str", strName);
        jsonGenerator.writeStringField("String_Node_Str", strTitle);
        String body = element.ownText();
        int index = body.indexOf("String_Node_Str");
        if (index == -1)
            index = body.indexOf("String_Node_Str");
        if (strTitle.toLowerCase().contains("String_Node_Str") && index != -1) {
            jsonGenerator.writeArrayFieldStart("String_Node_Str");
            jsonGenerator.writeStartObject();
            jsonGenerator.writeStringField("String_Node_Str", body.substring(0, index));
            jsonGenerator.writeStringField("String_Node_Str", body.substring(index + 1));
            jsonGenerator.writeEndObject();
            String speaker = "String_Node_Str";
            for (Element el : element.getElementsByTag("String_Node_Str")) {
                if (index != -1)
                    speaker = body.substring(0, index);
                body = el.text();
                index = body.indexOf("String_Node_Str");
                if (index == -1)
                    index = body.indexOf("String_Node_Str");
                jsonGenerator.writeStartObject();
                if (index == -1) {
                    jsonGenerator.writeStringField("String_Node_Str", speaker);
                    jsonGenerator.writeStringField("String_Node_Str", body);
                } else {
                    jsonGenerator.writeStringField("String_Node_Str", body.substring(0, index));
                    jsonGenerator.writeStringField("String_Node_Str", body.substring(index + 1));
                }
                jsonGenerator.writeEndObject();
            }
            jsonGenerator.writeEndArray();
        } else {
            jsonGenerator.writeArrayFieldStart("String_Node_Str");
            for (Element el : element.getElementsByTag("String_Node_Str")) body += el.text() + "String_Node_Str";
            jsonGenerator.writeStartObject();
            jsonGenerator.writeStringField("String_Node_Str", "String_Node_Str");
            jsonGenerator.writeStringField("String_Node_Str", body);
            jsonGenerator.writeEndObject();
            jsonGenerator.writeEndArray();
        }
        jsonGenerator.writeEndObject();
    } catch (Exception e) {
        e.printStackTrace();
        throw e;
    }
}

Output:
         String url = "String_Node_Str" + link;
-        Document doc1 = Jsoup.connect(url).get();
+        Connection conn = Jsoup.connect(url);
+        conn.timeout(5000000);
+        Document doc1 = conn.get();
         Element element = doc1.body().child(0).child(0).child(1).child(0).child(0).child(0).child(0).child(1).child(5).child(0).child(2).child(0).child(1);


Input:
public void attribute(String namespaceURI, String localName, String qName, String value) {
    try {
        outputStreamWrite(SPACE);
        outputStreamWrite(qName.getBytes(XMLConstants.DEFAULT_XML_ENCODING));
        outputStreamWrite((byte) '=');
        outputStreamWrite((byte) '"');
        writeValue(value, true, true);
        outputStreamWrite(CLOSE_ATTRIBUTE_VALUE);
    } catch (UnsupportedEncodingException e) {
        throw XMLMarshalException.marshalException(e);
    }
}

Output:
         outputStreamWrite((byte) '"');
-        writeValue(value, true, true);
+        writeValue(value, true, true, this.outputStream);
         outputStreamWrite(CLOSE_ATTRIBUTE_VALUE);


Input:
public void translateCategoryForm(final ViewDefinitionState viewDefinitionState) {
    FormComponent categoryForm = (FormComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
    Entity categoryFormEntity = categoryForm.getEntity();
    Entity categoryDbEntity = null;
    if (categoryFormEntity != null && categoryFormEntity.getId() != null) {
        categoryDbEntity = dataDefinitionService.get(QcadooViewConstants.PLUGIN_IDENTIFIER, QcadooViewConstants.MODEL_CATEGORY).get(categoryFormEntity.getId());
    }
    if (categoryDbEntity != null && categoryDbEntity.getStringField(L_PLUGIN_IDENTIFIER) != null) {
        ComponentState categoryNameField = viewDefinitionState.getComponentByReference("String_Node_Str");
        categoryNameField.setEnabled(false);
        categoryNameField.setFieldValue(translationUtilsService.getCategoryTranslation(categoryDbEntity, viewDefinitionState.getLocale()));
    }
    GridComponent categoryItemsGrid = (GridComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
    for (Entity itemEntity : categoryItemsGrid.getEntities()) {
        if (itemEntity.getStringField(L_PLUGIN_IDENTIFIER) != null) {
            itemEntity.setField("String_Node_Str", translationUtilsService.getItemTranslation(itemEntity, viewDefinitionState.getLocale()));
        }
    }
}

Output:
 public void translateCategoryForm(final ViewDefinitionState viewDefinitionState) {
-    FormComponent categoryForm = (FormComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
-    Entity categoryFormEntity = categoryForm.getEntity();
-    Entity categoryDbEntity = null;
-    if (categoryFormEntity != null && categoryFormEntity.getId() != null) {
-        categoryDbEntity = dataDefinitionService.get(QcadooViewConstants.PLUGIN_IDENTIFIER, QcadooViewConstants.MODEL_CATEGORY).get(categoryFormEntity.getId());
-    }
-    if (categoryDbEntity != null && categoryDbEntity.getStringField(L_PLUGIN_IDENTIFIER) != null) {
-        ComponentState categoryNameField = viewDefinitionState.getComponentByReference("String_Node_Str");
-        categoryNameField.setEnabled(false);
-        categoryNameField.setFieldValue(translationUtilsService.getCategoryTranslation(categoryDbEntity, viewDefinitionState.getLocale()));
-    }
-    GridComponent categoryItemsGrid = (GridComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
-    for (Entity itemEntity : categoryItemsGrid.getEntities()) {
-        if (itemEntity.getStringField(L_PLUGIN_IDENTIFIER) != null) {
-            itemEntity.setField("String_Node_Str", translationUtilsService.getItemTranslation(itemEntity, viewDefinitionState.getLocale()));
+    FormComponent categoryForm = (FormComponent) viewDefinitionState.getComponentByReference(L_FORM);
+    Long categoryId = categoryForm.getEntityId();
+    if (categoryId != null) {
+        Entity category = dataDefinitionService.get(QcadooViewConstants.PLUGIN_IDENTIFIER, QcadooViewConstants.MODEL_CATEGORY).get(categoryId);
+        if ((category != null) && (category.getStringField(MenuCategoryFields.PLUGIN_IDENTIFIER) != null)) {
+            FieldComponent categoryNameField = (FieldComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
+            categoryNameField.setEnabled(false);
+            categoryNameField.setFieldValue(translationUtilsService.getCategoryTranslation(category, viewDefinitionState.getLocale()));
+        }
+        GridComponent categoryItemsGrid = (GridComponent) viewDefinitionState.getComponentByReference("String_Node_Str");
+        for (Entity item : categoryItemsGrid.getEntities()) {
+            if (item.getStringField(MenuItemFields.PLUGIN_IDENTIFIER) != null) {
+                item.setField(MenuItemFields.NAME, translationUtilsService.getItemTranslation(item, viewDefinitionState.getLocale()));
+            }
         }


Input:
public String getTextField(String field) {
    if (field == null)
        throw new IllegalArgumentException("String_Node_Str");
    return this.textFields.get(field);
}

Output:
 public String getTextField(String field) {
-    if (field == null)
+    if (field == null) {
         throw new IllegalArgumentException("String_Node_Str");


Input:
public static <T extends IBasicBlock> PrunedCFG<T> make(ControlFlowGraph<T> cfg) {
    return PrunedCFG.make(cfg, new ExceptionEdgePruner<T>());
}

Output:
 public static <T extends IBasicBlock> PrunedCFG<T> make(ControlFlowGraph<T> cfg) {
-    return PrunedCFG.make(cfg, new ExceptionEdgePruner<T>());
+    return PrunedCFG.make(cfg, new ExceptionEdgePruner<T>(cfg));
 }


Input:
public boolean equals(Object o) {
    boolean isEqual = o instanceof Session;
    if (isEqual) {
        Session other = (Session) o;
        isEqual = accessToken.equals(other.accessToken) && refreshToken.equals(other.refreshToken) && expiresMillis == other.expiresMillis;
    }
    return isEqual;
}

Output:
         Session other = (Session) o;
-        isEqual = accessToken.equals(other.accessToken) && refreshToken.equals(other.refreshToken) && expiresMillis == other.expiresMillis;
+        boolean accessTokensEquals = accessToken == null && other.accessToken == null || accessToken.equals(other.accessToken);
+        boolean refreshTokensEquals = refreshToken == null && other.refreshToken == null || refreshToken.equals(other.refreshToken);
+        boolean timeStampsEquals = expiresMillis == other.expiresMillis;
+        isEqual = accessTokensEquals && refreshTokensEquals && timeStampsEquals;
     }


Input:
public void render(Graphics2D g, VisualItem item) {
    super.render(g, item);
    if (m_curArrow != null && !isSelfEdge(item)) {
        g.setPaint(ColorLib.getColor(item.getFillColor()));
        g.fill(m_curArrow);
    }
}

Output:
 public void render(Graphics2D g, VisualItem item) {
-    super.render(g, item);
+    Shape shape = getShape(item);
+    if (shape != null)
+        drawShape(g, item, shape);
     if (m_curArrow != null && !isSelfEdge(item)) {


Input:
protected void parseRecord() {
    if (ch <= ' ' && ignoreLeadingWhitespace) {
        ch = input.skipWhitespace(ch);
    }
    while (ch != newLine) {
        if (ch <= ' ' && ignoreLeadingWhitespace) {
            ch = input.skipWhitespace(ch);
        }
        if (ch == delimiter) {
            output.emptyParsed();
        } else {
            if (ch == quote) {
                output.trim = false;
                if (normalizeLineEndingsInQuotes) {
                    parseQuotedValue('\0');
                } else {
                    input.enableNormalizeLineEndings(false);
                    parseQuotedValue('\0');
                    input.enableNormalizeLineEndings(true);
                }
            } else if (doNotEscapeUnquotedValues) {
                output.trim = ignoreTrailingWhitespace;
                ch = input.appendUntilDelimiter(ch, output.appender);
            } else {
                output.trim = ignoreTrailingWhitespace;
                parseValueProcessingEscape('\0');
            }
            output.valueParsed();
        }
        if (ch != newLine) {
            ch = input.nextChar();
            if (ch == newLine) {
                output.emptyParsed();
            }
        }
    }
}

Output:
                 if (normalizeLineEndingsInQuotes) {
-                    parseQuotedValue('\0');
+                    parseQuotedValue();
                 } else {


Input:
public <T> T manufacturePojoWithFullData(Class<T> pojoClass, Type... genericTypeArgs) {
    ManufacturingContext manufacturingCtx = new ManufacturingContext();
    manufacturingCtx.getPojos().put(pojoClass, 0);
    manufacturingCtx.setConstructorOrdering(Order.HEAVY_FIRST);
    return doManufacturePojo(pojoClass, manufacturingCtx, genericTypeArgs);
}

Output:
     ManufacturingContext manufacturingCtx = new ManufacturingContext();
-    manufacturingCtx.getPojos().put(pojoClass, 0);
+    manufacturingCtx.getPojos().put(pojoClass, 1);
     manufacturingCtx.setConstructorOrdering(Order.HEAVY_FIRST);


Input:
private Pool create2DPoolBuffer(Pool pool) {
    Pool bufferPool = new Pool(pool.getName());
    for (int i = 0; i < pool.size(); i++) {
        float[][] element = (float[][]) pool.get(i);
        int poolSize = element.length;
        Buffer[] bufferArray = new Buffer[poolSize];
        for (int j = 0; j < poolSize; j++) {
            bufferArray[j] = new Buffer(element[j].length);
        }
        bufferPool.put(i, bufferArray);
    }
    return bufferPool;
}

Output:
         for (int j = 0; j < poolSize; j++) {
-            bufferArray[j] = new Buffer(element[j].length);
+            bufferArray[j] = new Buffer(element[j].length, isLog);
         }


Input:
private static WebClient getHCatalogRootClient(HCatalogConnection connection) {
    String host = StringUtils.trimToEmpty(connection.getHostName());
    String port = StringUtils.trimToEmpty(connection.getPort());
    String userName = StringUtils.trimToEmpty(connection.getUserName());
    String path = "String_Node_Str" + host + "String_Node_Str" + port + "String_Node_Str" + userName;
    return WebClient.create(path);
}

Output:
     String path = "String_Node_Str" + host + "String_Node_Str" + port + "String_Node_Str" + userName;
-    return WebClient.create(path);
+    WebClient client = WebClient.create(path);
+    addKerberos2Client(client, connection);
+    return client;
 }


Input:
public void windowIconified(WindowEvent arg0) {
    if (subConfig.getBooleanProperty(PROPERTY_MINIMIZE_TO_TRAY, true)) {
        if (new Date().getTime() > this.lastDeIconifiedEvent + 750) {
            guiFrame.setVisible(false);
        } else {
            guiFrame.setExtendedState(Frame.NORMAL);
            guiFrame.setVisible(true);
        }
    }
}

Output:
     if (subConfig.getBooleanProperty(PROPERTY_MINIMIZE_TO_TRAY, true)) {
-        if (new Date().getTime() > this.lastDeIconifiedEvent + 750) {
-            guiFrame.setVisible(false);
-        } else {
-            guiFrame.setExtendedState(Frame.NORMAL);
-            guiFrame.setVisible(true);
-        }
+        miniIt();
     }


Input:
public void setMembers(List<MemberImpl> lsMembers) {
    Set<Member> setNew = new LinkedHashSet<Member>(lsMembers.size());
    ArrayList<Runnable> notifications = new ArrayList<Runnable>();
    for (MemberImpl member : lsMembers) {
        final MemberImpl dummy = new MemberImpl(member.getAddress(), member.localMember(), member.getNodeType());
        Member clusterMember = clusterMembers.get(dummy);
        if (clusterMember == null) {
            clusterMember = dummy;
            if (listeners.size() > 0) {
                notifications.add(new Runnable() {

                    public void run() {
                        MembershipEvent membershipEvent = new MembershipEvent(ClusterImpl.this, dummy, MembershipEvent.MEMBER_ADDED);
                        for (MembershipListener listener : listeners) {
                            listener.memberAdded(membershipEvent);
                        }
                    }
                });
            }
        }
        if (clusterMember.localMember()) {
            localMember.set(clusterMember);
        }
        setNew.add(clusterMember);
    }
    if (listeners.size() > 0) {
        Set<Member> it = clusterMembers.keySet();
        for (final Member member : it) {
            if (!setNew.contains(member)) {
                notifications.add(new Runnable() {
                    public void run() {
                        MembershipEvent membershipEvent = new MembershipEvent(ClusterImpl.this, member, MembershipEvent.MEMBER_REMOVED);
                        for (MembershipListener listener : listeners) {
                            listener.memberRemoved(membershipEvent);
                        }
                    }
                });
            }
        }
    }
    clusterMembers.clear();
    for (Member member : setNew) {
        clusterMembers.put(member, member);
    }
    members.set(setNew);
    distances.clear();
    for (Runnable notification : notifications) {
        node.executorManager.getEventExecutorService().execute(notification);
    }
}

Output:
     for (MemberImpl member : lsMembers) {
-        final MemberImpl dummy = new MemberImpl(member.getAddress(), member.localMember(), member.getNodeType());
-        Member clusterMember = clusterMembers.get(dummy);
-        if (clusterMember == null) {
-            clusterMember = dummy;
-            if (listeners.size() > 0) {
-                notifications.add(new Runnable() {
+        if (member != null) {
+            final MemberImpl dummy = new MemberImpl(member.getAddress(), member.localMember(), member.getNodeType());
+            Member clusterMember = clusterMembers.get(dummy);
+            if (clusterMember == null) {
+                clusterMember = dummy;
+                if (listeners.size() > 0) {
+                    notifications.add(new Runnable() {


Input:
private void setNodesAndParents() throws ExceptionHugin {
    List<Attribute> atts = new ArrayList<>();
    NodeList huginNodes = this.huginBN.getNodes();
    int numNodes = huginNodes.size();
    for (int i = 0; i < numNodes; i++) {
        Node n = (Node) huginNodes.get(i);
        if (n.getKind().compareTo(NetworkModel.H_KIND_DISCRETE) == 0) {
            int numStates = (int) ((DiscreteChanceNode) n).getNumberOfStates();
            atts.add(new Attribute(i, n.getName(), "String_Node_Str", StateSpaceType.MULTINOMIAL, numStates));
        } else if (n.getKind().compareTo(NetworkModel.H_KIND_CONTINUOUS) == 0) {
            atts.add(new Attribute(i, n.getName(), "String_Node_Str", StateSpaceType.REAL, 0));
        }
    }
    StaticVariables staticVariables = new StaticVariables(new Attributes(atts));
    DAG dag = new DAG(staticVariables);
    StaticVariables amidstVariables = staticVariables;
    for (int i = 0; i < huginNodes.size(); i++) {
        Node huginChild = (Node) huginNodes.get(i);
        NodeList huginParents = huginChild.getParents();
        Variable amidstChild = amidstVariables.getVariableByName(huginChild.getName());
        List<Integer> positionsMultinomialParents = new ArrayList<>();
        for (int j = 0; j < huginParents.size(); j++) {
            Node huginParent = (Node) huginParents.get(j);
            if (huginParent.getKind().compareTo(NetworkModel.H_KIND_DISCRETE) == 0) {
                int indexParent = huginNodes.indexOf(huginParent);
                positionsMultinomialParents.add(indexParent);
            }
        }
        Collections.reverse(positionsMultinomialParents);
        for (int j = 0; j < huginParents.size(); j++) {
            Node huginParent = (Node) huginParents.get(j);
            int indexParent;
            if (huginParent.getKind().compareTo(NetworkModel.H_KIND_DISCRETE) == 0) {
                indexParent = positionsMultinomialParents.get(j);
            } else {
                indexParent = huginNodes.indexOf(huginParent);
            }
            Variable amidstParent = amidstVariables.getVariableByName(huginChild.getName());
            dag.getParentSet(amidstChild).addParent(amidstParent);
        }
        System.out.print(amidstChild.getName() + "String_Node_Str");
        for (Variable var : dag.getParentSet(amidstChild)) System.out.print(var.getName() + "String_Node_Str");
        System.out.println();
    }
    this.amidstBN = BayesianNetwork.newBayesianNetwork(dag);
}

Output:
             Node huginParent = (Node) huginParents.get(j);
-            int indexParent;
-            if (huginParent.getKind().compareTo(NetworkModel.H_KIND_DISCRETE) == 0) {
-                indexParent = positionsMultinomialParents.get(j);
-            } else {
-                indexParent = huginNodes.indexOf(huginParent);
-            }
-            Variable amidstParent = amidstVariables.getVariableByName(huginChild.getName());
+            Variable amidstParent = amidstVariables.getVariableByName(huginParent.getName());
             dag.getParentSet(amidstChild).addParent(amidstParent);


Input:
public void colorChanged(ColorChangedEvent event) {
    switch(event.getColorId()) {
        case Theme.FILE_TABLE_BORDER_COLOR:
            borderColor = event.getColor();
            if (fileTable.hasFocus()) {
                ((MutableLineBorder) scrollPane.getBorder()).setLineColor(borderColor);
                scrollPane.repaint();
            }
            break;
        case Theme.FILE_TABLE_INACTIVE_BORDER_COLOR:
            unfocusedBorderColor = event.getColor();
            if (!fileTable.hasFocus()) {
                ((MutableLineBorder) scrollPane.getBorder()).setLineColor(unfocusedBorderColor);
                scrollPane.repaint();
            }
            break;
        case Theme.FILE_TABLE_BACKGROUND_COLOR:
            backgroundColor = event.getColor();
            if (fileTable.hasFocus())
                scrollPane.getViewport().setBackground(backgroundColor);
            break;
        case Theme.FILE_TABLE_INACTIVE_BACKGROUND_COLOR:
            unfocusedBackgroundColor = event.getColor();
            if (!fileTable.hasFocus())
                scrollPane.getViewport().setBackground(unfocusedBackgroundColor);
            break;
        case Theme.FILE_TABLE_UNMATCHED_BACKGROUND_COLOR:
            unmatchedBackgroundColor = event.getColor();
            break;
    }
}

Output:
             if (fileTable.hasFocus()) {
-                ((MutableLineBorder) scrollPane.getBorder()).setLineColor(borderColor);
+                setBorderColor(borderColor);
                 scrollPane.repaint();


Input:
public IValue withType(IType type, ITypeContext typeContext, MarkerList markers, IContext context) {
    if (this.valueCount == 1) {
        return this.values[0].withType(type, typeContext, markers, context);
    }
    IAnnotation annotation = type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
    if (annotation != null) {
        return new LiteralExpression(this, annotation, new ArgumentList(this.values, this.valueCount)).withType(type, typeContext, markers, context);
    }
    IClass tupleClass = TupleType.getTupleClass(this.valueCount);
    if (!tupleClass.isSubTypeOf(type)) {
        return null;
    }
    IClass iclass = type.getTheClass();
    for (int i = 0; i < this.valueCount; i++) {
        IType elementType = type.resolveTypeSafely(iclass.getTypeVariable(i));
        IValue value = this.values[i];
        IValue value1 = value.withType(elementType, typeContext, markers, context);
        if (value1 == null) {
            Marker m = markers.create(value.getPosition(), "String_Node_Str");
            m.addInfo("String_Node_Str" + value.getType());
            m.addInfo("String_Node_Str" + elementType);
        } else {
            this.values[i] = value = value1;
        }
    }
    this.tupleType = this.getType();
    return this;
}

Output:
     for (int i = 0; i < this.valueCount; i++) {
-        IType elementType = type.resolveTypeSafely(iclass.getTypeVariable(i));
+        IType elementType = iclass == dyvil.tools.compiler.ast.type.Types.OBJECT_CLASS ? dyvil.tools.compiler.ast.type.Types.ANY : type.resolveTypeSafely(iclass.getTypeVariable(i));
         IValue value = this.values[i];


Input:
public void onTick(long millisUntilFinished) {
    millisLeft = millisUntilFinished;
    updateTime();
}

Output:
 public void onTick(long millisUntilFinished) {
-    millisLeft = millisUntilFinished;
-    updateTime();
+    if (!isPaused) {
+        millisLeft = millisUntilFinished;
+        updateTime();
+    }
 }


Input:
protected SqlStatement createChangeToTagSQL() {
    return new RawSqlStatement("String_Node_Str" + getDatabaseChangeLogTableName());
}

Output:
 protected SqlStatement createChangeToTagSQL() {
-    return new RawSqlStatement("String_Node_Str" + getDatabaseChangeLogTableName());
+    return new RawSqlStatement("String_Node_Str" + escapeTableName(getDefaultSchemaName(), getDatabaseChangeLogTableName()));
 }


Input:
public static byte[] bip38Stretch1(String passphrase, byte[] salt, SCryptProgress progressTracker, int outputSize) throws InterruptedException {
    byte[] derived;
    try {
        derived = SCrypt.scrypt(passphrase.getBytes("String_Node_Str"), salt, SCRYPT_N, SCRYPT_R, SCRYPT_P, outputSize, progressTracker);
        return derived;
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    }
}

Output:
     try {
-        derived = SCrypt.scrypt(passphrase.getBytes("String_Node_Str"), salt, SCRYPT_N, SCRYPT_R, SCRYPT_P, outputSize, progressTracker);
+        derived = SCrypt.scrypt(normalizedPassphrase.getBytes("String_Node_Str"), salt, SCRYPT_N, SCRYPT_R, SCRYPT_P, outputSize, progressTracker);
         return derived;


Input:
protected OQueryContextNative query(OQueryContextNative record, QCharacter e) {
    return record;
}

Output:
 protected OQueryContextNative query(OQueryContextNative record, QCharacter e) {
-    return record;
+    return null;
 }


Input:
public int getRflevel() {
    return rflevel.getValue();
}

Output:
 public int getRflevel() {
-    return rflevel.getValue();
+    Integer value = rflevel.getValue();
+    if (value == null) {
+        return 0;
+    }
+    return value;
 }


Input:
public int parseArguments(Parameters params) throws CmdLineException {
    String param = params.getParameter(0);
    try {
        setter.addValue(new URL(param));
        return 1;
    } catch (MalformedURLException e) {
        throw new CmdLineException(owner, Messages.ILLEGAL_OPERAND.format(param));
    }
}

Output:
     } catch (MalformedURLException e) {
-        throw new CmdLineException(owner, Messages.ILLEGAL_OPERAND.format(param));
+        throw new CmdLineException(owner, Messages.ILLEGAL_OPERAND.format(params.getParameter(-1), param));
     }


Input:
public void listWithJpqlWhenUniqueResult() {
    Query q = em.createQuery("String_Node_Str");
    List<Long> list = jpaResultMapper.list(q, Long.class);
    Assert.assertNotNull(list);
    Assert.assertEquals(1, list.size());
    Assert.assertEquals(employeeId, list.get(0).longValue());
}

Output:
     Query q = em.createQuery("String_Node_Str");
-    List<Long> list = jpaResultMapper.list(q, Long.class);
+    List<Integer> list = jpaResultMapper.list(q, Integer.class);
     Assert.assertNotNull(list);


Input:
public AddressResponse address(AddressRequest addressRequest, String authorizationHeader) throws AddressException {
    String emailConfirmationToken = getEmailConfirmationToken(authorizationHeader);
    Optional<Investor> oInvestor = investorRepository.findOptionalByEmailConfirmationToken(emailConfirmationToken);
    if (!oInvestor.isPresent()) {
        throw new EmailConfirmationTokenNotFoundException();
    }
    String walletAddress = addressRequest.getAddress();
    String refundBitcoinAddress = addressRequest.getRefundBTC();
    String refundEthereumAddress = addressRequest.getRefundETH();
    Keys bitcoinKeys = bitcoinKeyGenerator.getKeys();
    Keys ethereumKeys = ethereumKeyGenerator.getKeys();
    try {
        Investor investor = oInvestor.get();
        investor.setWalletAddress(walletAddress).setPayInBitcoinAddress(bitcoinKeys.getAddressBase16()).setPayInBitcoinPrivateKey(bitcoinKeys.getPrivateKeyBase16()).setPayInEtherAddress(ethereumKeys.getAddressBase16()).setPayInEtherPrivateKey(ethereumKeys.getPrivateKeyBase16()).setRefundBitcoinAddress(refundBitcoinAddress).setRefundEtherAddress(refundEthereumAddress);
        investorRepository.save(investor);
    } catch (Exception e) {
        throw new AddressException();
    }
    return new AddressResponse().setBtc(bitcoinKeys.getAddressBase16()).setEther(ethereumKeys.getAddressBase16());
}

Output:
     }
-    String walletAddress = addressRequest.getAddress();
+    String walletAddress = replacePrefixAddress(addressRequest.getAddress());
+    String refundEthereumAddress = replacePrefixAddress(addressRequest.getRefundETH());
     String refundBitcoinAddress = addressRequest.getRefundBTC();


Input:
void destroy() {
    Log.d(TAG, "String_Node_Str" + this.ownerId);
    this.observersList.clear();
    this.mavlinkObserversList.clear();
    this.apiListener.asBinder().unlinkToDeath(this, 0);
    try {
        this.service.disconnectDroneManager(this.droneMgr, this.ownerId);
    } catch (ConnectionException e) {
        Log.e(TAG, e.getMessage(), e);
    }
}

Output:
 void destroy() {
-    Log.d(TAG, "String_Node_Str" + this.ownerId);
+    Timber.d("String_Node_Str", this.ownerId);
     this.observersList.clear();


Input:
private static boolean isAllowed(List<Object> source, List<Object> destination) {
    boolean isSame = source.equals(destination);
    int i = 0;
    int j = 0;
    while (i < source.size() && j < destination.size()) {
        Object srcValue = source.get(i);
        Object dstValue = destination.get(j);
        if (isInteger(srcValue.toString()) && isInteger(dstValue.toString())) {
            Integer srcInt = Integer.parseInt(srcValue.toString());
            Integer dstInt = Integer.parseInt(dstValue.toString());
            if (srcInt > dstInt) {
                return false;
            }
        }
        i++;
        j++;
    }
    return !isSame;
}

Output:
         Object dstValue = destination.get(j);
-        if (isInteger(srcValue.toString()) && isInteger(dstValue.toString())) {
-            Integer srcInt = Integer.parseInt(srcValue.toString());
-            Integer dstInt = Integer.parseInt(dstValue.toString());
-            if (srcInt > dstInt) {
+        String srcStr = srcValue.toString();
+        String dstStr = dstValue.toString();
+        if (isNumber(srcStr) && isNumber(dstStr)) {
+            if (srcStr.compareTo(dstStr) > 0) {
                 return false;


Input:
public List<Object> getFirstObsWithValues(Concept concept, List<String> attrs) throws Exception {
    attrs.add(0, null);
    List<List<Object>> obs = getObsWithValues(concept, attrs);
    if (obs == null) {
        List<Object> blankRow = new Vector<Object>();
        for (String attr : attrs) blankRow.add("String_Node_Str");
        return blankRow;
    }
    if (obs.size() > 0) {
        return obs.get(0);
    }
    log.info("String_Node_Str" + concept + "String_Node_Str" + patientId);
    return null;
}

Output:
     if (obs.size() > 0) {
-        return obs.get(0);
+        return obs.get(obs.size() - 1);
     }


Input:
public void modifyText(ModifyEvent e) {
    verify();
}

Output:
 public void modifyText(ModifyEvent e) {
-    verify();
+    verify(false);
 }


Input:
public static void render500(Exception e) {
    log.error("String_Node_Str", e);
    if (HuluSetting.isDevMode == false) {
        render(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "String_Node_Str");
    }
    final ByteArrayOutputStream ostr = new ByteArrayOutputStream();
    try {
        e.printStackTrace(new PrintStream(ostr));
        render(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ostr.toString(HuluSetting.charset).replace("String_Node_Str", "String_Node_Str"));
    } catch (IOException e2) {
        log.error("String_Node_Str", e2);
    }
}

Output:
     if (HuluSetting.isDevMode == false) {
-        render(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "String_Node_Str");
-    }
-    final ByteArrayOutputStream ostr = new ByteArrayOutputStream();
-    try {
-        e.printStackTrace(new PrintStream(ostr));
-        render(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ostr.toString(HuluSetting.charset).replace("String_Node_Str", "String_Node_Str"));
-    } catch (IOException e2) {
-        log.error("String_Node_Str", e2);
+        sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "String_Node_Str");
+        return;
     }


Input:
public void getUI(JPanel panel) {
    panel.setLayout(new ListDownLayout());
    JComboBox<FacadeFinder.FacadeMode> granularity = new JComboBox<>();
    granularity.addItem(FacadeMode.PER_GIS);
    granularity.addItem(FacadeMode.PER_MEGA);
    granularity.addItem(FacadeMode.PER_CAMERA);
    granularity.addItem(FacadeMode.PER_CAMERA_CROPPED);
    granularity.addItem(FacadeMode.PER_FETCH);
    granularity.setSelectedItem(FacadeFinder.facadeMode);
    granularity.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            FacadeFinder.facadeMode = (FacadeMode) granularity.getSelectedItem();
        }
    });
    JCheckBox singleFolderCheck = new JCheckBox("String_Node_Str");
    singleFolderCheck.setSelected(FacadeTool.this.singleFolder);
    singleFolderCheck.addActionListener(e -> FacadeTool.this.singleFolder = singleFolderCheck.isSelected());
    JButton forAll = new JButton("String_Node_Str");
    forAll.addActionListener(l -> tweed.frame.getGenOf(GISGen.class).startRender(-1));
    panel.add(granularity);
    panel.add(singleFolderCheck);
    panel.add(forAll);
    panel.add(new JLabel("String_Node_Str"));
}

Output:
     granularity.addItem(FacadeMode.PER_CAMERA_CROPPED);
-    granularity.addItem(FacadeMode.PER_FETCH);
+    granularity.addItem(FacadeMode.KANGAROO);
     granularity.setSelectedItem(FacadeFinder.facadeMode);


Input:
public boolean loadTrainingData(String pathname) {
    IJ.log("String_Node_Str" + pathname + "String_Node_Str");
    loadedTrainingData = readDataFromARFF(pathname);
    Enumeration<Attribute> attributes = loadedTrainingData.enumerateAttributes();
    final int numFeatures = FeatureStack.availableFeatures.length;
    boolean[] usedFeatures = new boolean[numFeatures];
    while (attributes.hasMoreElements()) {
        final Attribute a = attributes.nextElement();
        for (int i = 0; i < numFeatures; i++) if (a.name().startsWith(FeatureStack.availableFeatures[i]))
            usedFeatures[i] = true;
    }
    Attribute classAttribute = loadedTrainingData.classAttribute();
    Enumeration<String> classValues = classAttribute.enumerateValues();
    loadedClassNames = new ArrayList<String>();
    int j = 0;
    while (classValues.hasMoreElements()) {
        final String className = classValues.nextElement().trim();
        loadedClassNames.add(className);
        IJ.log("String_Node_Str" + className);
        if (!className.equals(this.classLabels[j])) {
            String s = classLabels[0];
            for (int i = 1; i < numOfClasses; i++) s = s.concat("String_Node_Str" + classLabels[i]);
            IJ.error("String_Node_Str" + s);
            loadedTrainingData = null;
            return false;
        }
        j++;
    }
    if (j != numOfClasses) {
        IJ.error("String_Node_Str");
        loadedTrainingData = null;
        return false;
    }
    IJ.log("String_Node_Str" + loadedTrainingData.numInstances() + "String_Node_Str" + wholeImageData.numAttributes() + "String_Node_Str");
    boolean featuresChanged = false;
    final boolean[] oldEnableFeatures = this.featureStack.getEnableFeatures();
    for (int i = 0; i < numFeatures; i++) {
        if (usedFeatures[i] != oldEnableFeatures[i])
            featuresChanged = true;
    }
    if (featuresChanged) {
        this.setButtonsEnabled(false);
        this.featureStack.setEnableFeatures(usedFeatures);
        this.featureStack.updateFeatures();
        this.setButtonsEnabled(true);
        updateWholeData = true;
    }
    return true;
}

Output:
     }
-    IJ.log("String_Node_Str" + loadedTrainingData.numInstances() + "String_Node_Str" + wholeImageData.numAttributes() + "String_Node_Str");
+    IJ.log("String_Node_Str" + loadedTrainingData.numInstances() + "String_Node_Str" + loadedTrainingData.numAttributes() + "String_Node_Str");
     boolean featuresChanged = false;


Input:
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    ChannelBuffer buf = (ChannelBuffer) msg;
    int apiNumber = buf.readUnsignedShort();
    int commandType = buf.readUnsignedByte();
    int messageType = buf.getUnsignedByte(buf.readerIndex()) >> 4;
    boolean needAck = (buf.readUnsignedByte() & 0xf) == 1;
    long mask = defaultMask;
    if (buf.readUnsignedByte() == 4) {
        mask = buf.readUnsignedInt();
    }
    if (apiNumber == 5 && commandType == 2 && messageType == 1 && BitUtil.check(mask, 0)) {
        Position position = new Position();
        position.setProtocol(getProtocolName());
        if (BitUtil.check(mask, 1)) {
            position.set(Event.KEY_STATUS, buf.readUnsignedInt());
        }
        String id = null;
        if (BitUtil.check(mask, 23)) {
            id = buf.toString(buf.readerIndex(), 8, Charset.defaultCharset()).trim();
            buf.skipBytes(8);
        } else if (BitUtil.check(mask, 2)) {
            id = buf.toString(buf.readerIndex(), 22, Charset.defaultCharset()).trim();
            buf.skipBytes(22);
        } else {
            Log.warning("String_Node_Str");
            return null;
        }
        if (!identify(id, channel)) {
            return null;
        }
        position.setDeviceId(getDeviceId());
        if (BitUtil.check(mask, 3)) {
            buf.readUnsignedShort();
        }
        if (BitUtil.check(mask, 4)) {
            buf.readUnsignedShort();
        }
        if (BitUtil.check(mask, 5)) {
            buf.readUnsignedShort();
        }
        if (BitUtil.check(mask, 7)) {
            buf.readUnsignedByte();
        }
        Calendar time = Calendar.getInstance(TimeZone.getTimeZone("String_Node_Str"));
        time.clear();
        if (BitUtil.check(mask, 8)) {
            time.set(Calendar.DAY_OF_MONTH, buf.readUnsignedByte());
            time.set(Calendar.MONTH, buf.readUnsignedByte() - 1);
            time.set(Calendar.YEAR, 2000 + buf.readUnsignedByte());
        }
        if (BitUtil.check(mask, 9)) {
            position.setValid(buf.readUnsignedByte() == 1);
        }
        if (BitUtil.check(mask, 10)) {
            position.setLatitude(convertCoordinate(buf.readUnsignedInt()));
        }
        if (BitUtil.check(mask, 11)) {
            position.setLongitude(convertCoordinate(buf.readUnsignedInt()));
        }
        if (BitUtil.check(mask, 12)) {
            position.setSpeed(buf.readUnsignedShort() / 10.0);
        }
        if (BitUtil.check(mask, 13)) {
            position.setCourse(buf.readUnsignedShort() / 10.0);
        }
        if (BitUtil.check(mask, 14)) {
            time.set(Calendar.HOUR_OF_DAY, buf.readUnsignedByte());
            time.set(Calendar.MINUTE, buf.readUnsignedByte());
            time.set(Calendar.SECOND, buf.readUnsignedByte());
        }
        position.setTime(time.getTime());
        if (BitUtil.check(mask, 15)) {
            position.setAltitude(buf.readMedium());
        }
        if (BitUtil.check(mask, 16)) {
            position.set(Event.KEY_SATELLITES, buf.readUnsignedByte());
        }
        if (BitUtil.check(mask, 17)) {
            buf.readUnsignedShort();
        }
        if (BitUtil.check(mask, 20)) {
            position.set("String_Node_Str", buf.readUnsignedInt());
        }
        if (BitUtil.check(mask, 21)) {
            position.set(Event.KEY_ODOMETER, buf.readUnsignedInt());
        }
        if (BitUtil.check(mask, 22)) {
            buf.skipBytes(6);
        }
        if (BitUtil.check(mask, 24)) {
            position.set(Event.KEY_POWER, buf.readUnsignedShort() / 1000.0);
        }
        if (BitUtil.check(mask, 25)) {
            buf.skipBytes(18);
        }
        if (BitUtil.check(mask, 26)) {
            buf.skipBytes(54);
        }
        if (BitUtil.check(mask, 28)) {
            position.set(Event.KEY_INDEX, buf.readUnsignedShort());
        }
        return position;
    }
    return null;
}

Output:
     int commandType = buf.readUnsignedByte();
-    int messageType = buf.getUnsignedByte(buf.readerIndex()) >> 4;
-    boolean needAck = (buf.readUnsignedByte() & 0xf) == 1;
+    int messageType = BitUtil.from(buf.readUnsignedByte(), 4);
     long mask = defaultMask;


Input:
public void sortSubTerms() {
    final int subTermNum = subTerms.size();
    if (subTerms != null && subTermNum > 0) {
        Collections.sort(subTerms);
        for (int i = 0; i < subTermNum; i++) {
            final IndexTerm subTerm = subTerms.get(i);
            subTerm.sortSubTerms();
        }
    }
}

Output:
         Collections.sort(subTerms);
-        for (int i = 0; i < subTermNum; i++) {
-            final IndexTerm subTerm = subTerms.get(i);
+        for (final IndexTerm subTerm : subTerms) {
             subTerm.sortSubTerms();


Input:
public static void main(String... argv) throws Exception {
    Preconditions.checkElementIndex(0, argv.length, "String_Node_Str");
    String url = argv[0];
    System.setProperty(ClientProperties.AMQP_VERSION, "String_Node_Str");
    System.setProperty(ClientProperties.DEST_SYNTAX, "String_Node_Str");
    AMQConnectionFactory factory = new AMQConnectionFactory(url);
    Connection connection = factory.createConnection();
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    System.out.printf("String_Node_Str", MESSAGE_TIMEOUT_MILLIS, MESSAGE_COUNT);
    try {
        Queue destination = session.createQueue(QUEUE);
        MessageConsumer messageConsumer = session.createConsumer(destination);
        int n = MESSAGE_COUNT;
        do {
            TextMessage msg = (TextMessage) messageConsumer.receive(MESSAGE_TIMEOUT_MILLIS);
            if (msg == null)
                break;
            System.out.printf("String_Node_Str", msg.getText());
        } while (n-- > 0);
    } catch (Exception e) {
        System.err.printf("String_Node_Str", e.getMessage());
        System.err.printf("String_Node_Str", Throwables.getStackTraceAsString(e));
    } finally {
        session.close();
        connection.close();
    }
}

Output:
             System.out.printf("String_Node_Str", msg.getText());
-        } while (n-- > 0);
+        } while (--n > 0);
     } catch (Exception e) {


Input:
private static void parseItemset(FormDef f, QuestionDef q, Element e, IFormElement qparent) {
    ItemsetBinding itemset = new ItemsetBinding();
    String nodesetStr = e.getAttributeValue("String_Node_Str", "String_Node_Str");
    XPathPathExpr path = XPathReference.getPathExpr(nodesetStr);
    itemset.nodesetExpr = new XPathConditional(path);
    itemset.nodesetRef = FormInstance.unpackReference(getAbsRef(new XPathReference(path.getReference(true)), qparent));
    for (int i = 0; i < e.getChildCount(); i++) {
        int type = e.getType(i);
        Element child = (type == Node.ELEMENT ? e.getElement(i) : null);
        String childName = (child != null ? child.getName() : null);
        if ("String_Node_Str".equals(childName)) {
            String labelXpath = child.getAttributeValue("String_Node_Str", "String_Node_Str");
            boolean labelItext = false;
            if (labelXpath != null) {
                if (labelXpath.startsWith("String_Node_Str") && labelXpath.endsWith("String_Node_Str")) {
                    labelXpath = labelXpath.substring("String_Node_Str".length(), labelXpath.indexOf("String_Node_Str"));
                    labelItext = true;
                }
            } else {
                throw new XFormParseException("String_Node_Str");
            }
            XPathPathExpr labelPath = XPathReference.getPathExpr(labelXpath);
            itemset.labelRef = FormInstance.unpackReference(getAbsRef(new XPathReference(labelPath), itemset.nodesetRef));
            itemset.labelExpr = new XPathConditional(labelPath);
            itemset.labelIsItext = labelItext;
        } else if ("String_Node_Str".equals(childName)) {
            String copyRef = child.getAttributeValue("String_Node_Str", "String_Node_Str");
            if (copyRef == null) {
                throw new XFormParseException("String_Node_Str");
            }
            itemset.copyRef = FormInstance.unpackReference(getAbsRef(new XPathReference(copyRef), itemset.nodesetRef));
            itemset.copyMode = true;
        } else if ("String_Node_Str".equals(childName)) {
            String valueXpath = child.getAttributeValue("String_Node_Str", "String_Node_Str");
            if (valueXpath == null) {
                throw new XFormParseException("String_Node_Str");
            }
            XPathPathExpr valuePath = XPathReference.getPathExpr(valueXpath);
            itemset.valueRef = FormInstance.unpackReference(getAbsRef(new XPathReference(valuePath), itemset.nodesetRef));
            itemset.valueExpr = new XPathConditional(valuePath);
            itemset.copyMode = false;
        }
    }
    if (itemset.labelRef == null) {
        throw new XFormParseException("String_Node_Str");
    } else if (itemset.copyRef == null && itemset.valueRef == null) {
        throw new XFormParseException("String_Node_Str");
    }
    q.setDynamicChoices(itemset);
    itemsets.addElement(itemset);
}

Output:
     itemset.nodesetExpr = new XPathConditional(path);
-    itemset.nodesetRef = FormInstance.unpackReference(getAbsRef(new XPathReference(path.getReference(true)), qparent));
+    itemset.contextRef = getFormElementRef(qparent);
+    itemset.nodesetRef = FormInstance.unpackReference(getAbsRef(new XPathReference(path.getReference(true)), itemset.contextRef));
     for (int i = 0; i < e.getChildCount(); i++) {


Input:
public Schema outputSchema(Schema input) {
    try {
        Schema tupleSchema = new Schema();
        for (int i = 0; i < this.outputNames.size(); i++) {
            String name = this.outputNames.get(i);
            if (i < 2 + validMetaSize) {
                tupleSchema.add(new FieldSchema(name, DataType.CHARARRAY));
            } else {
                tupleSchema.add(new FieldSchema(name, DataType.DOUBLE));
            }
        }
        return new Schema(new FieldSchema("String_Node_Str", tupleSchema, DataType.TUPLE));
    } catch (IOException e) {
        log.error("String_Node_Str", e);
        return null;
    }
}

Output:
             } else {
-                tupleSchema.add(new FieldSchema(name, DataType.DOUBLE));
+                tupleSchema.add(new FieldSchema(ZscoreLocalTransformCreator.genPmmlColumnName(name, this.modelConfig.getNormalizeType()), DataType.DOUBLE));
             }


Input:
private void initGlobal() {
    try {
        SSLSocketFactory sslfactory;
        SSLContext ctx = SSLContext.getInstance("String_Node_Str");
        if (anon) {
            ctx.init(null, null, null);
        } else {
            TrustManager[] myTM = new TrustManager[] { new MyX509TrustManager() };
            ctx.init(null, myTM, null);
        }
        sslfactory = ctx.getSocketFactory();
        try {
            ssl = (SSLSocket) sslfactory.createSocket(cc.sock, cc.sock.getInetAddress().getHostName(), cc.sock.getPort(), true);
        } catch (java.io.IOException e) {
            throw new Exception(e.toString());
        }
        if (anon) {
            String[] supported;
            ArrayList enabled = new ArrayList();
            supported = ssl.getSupportedCipherSuites();
            for (int i = 0; i < supported.length; i++) if (supported[i].matches("String_Node_Str"))
                enabled.add(supported[i]);
            ssl.setEnabledCipherSuites((String[]) enabled.toArray(new String[0]));
        } else {
            ssl.setEnabledCipherSuites(ssl.getSupportedCipherSuites());
        }
        ssl.setEnabledProtocols(new String[] { "String_Node_Str", "String_Node_Str" });
        ssl.addHandshakeCompletedListener(new MyHandshakeListener());
    } catch (java.security.GeneralSecurityException e) {
        vlog.error("String_Node_Str" + e.toString());
        return;
    }
}

Output:
             String[] supported;
-            ArrayList enabled = new ArrayList();
+            ArrayList<String> enabled = new ArrayList<String>();
             supported = ssl.getSupportedCipherSuites();


Input:
private static Map<String, Category> getCategoryMap() {
    if (categories != null)
        return categories;
    categories = new HashMap<String, Category>();
    IExtensionRegistry extReg = Platform.getExtensionRegistry();
    IExtensionPoint extPoint = extReg.getExtensionPoint(EXTENSION_POINT);
    if (extPoint == null)
        return categories;
    IExtension[] exts = extPoint.getExtensions();
    if (exts == null) {
        return categories;
    }
    for (int e = 0; e < exts.length; e++) {
        IConfigurationElement[] configElems = exts[e].getConfigurationElements();
        if (configElems == null)
            continue;
        for (int i = 0; i < configElems.length; i++) {
            if (configElems[i].getName().equals(ELEMENT_CATEGORY)) {
                Category category = new Category(configElems[i].getAttribute(ATTRIBUTE_NAME), configElems[i].getAttribute(ATTRIBUTE_DESC));
                categories.put(category.getName(), category);
                IScriptFunctionFactory factory;
                try {
                    factory = (IScriptFunctionFactory) configElems[i].createExecutableExtension(ATTRIBUTE_FACTORYCLASS);
                    IConfigurationElement[] functions = configElems[i].getChildren(ELEMENT_FUNCTION);
                    for (int j = 0; j < functions.length; j++) {
                        IScriptFunction function = getScriptFunction(category, factory, functions[j]);
                        if (function != null)
                            category.addFunction(function);
                    }
                } catch (FrameworkException e1) {
                }
            } else if (configElems[i].getName().equals(ELEMENT_FUNCTION)) {
                if (categories.get(DEFAULT_CATEGORYNAME) == null) {
                    categories.put(DEFAULT_CATEGORYNAME, new Category(DEFAULT_CATEGORYNAME, null));
                }
                IScriptFunction function = getScriptFunction(categories.get(DEFAULT_CATEGORYNAME), null, configElems[i]);
                if (function != null)
                    categories.get(DEFAULT_CATEGORYNAME).addFunction(function);
            } else if (configElems[i].getName().equals(ELEMENT_JSLIB)) {
                populateResources(jsLibs, "String_Node_Str", configElems[i]);
            }
        }
    }
    return categories;
}

Output:
                 categories.put(category.getName(), category);
-                IScriptFunctionFactory factory;
+                IScriptFunctionFactory factory = null;
                 try {


Input:
void add(Watcher w, Ref r) {
    Thread.holdsLock(GLOBAL);
    if (w == null) {
        return;
    }
    Iterator<Ref> it = observers.iterator();
    while (it.hasNext()) {
        Ref ref = it.next();
        if (r == ref) {
            return;
        }
        final Watcher rw = ref.get();
        if (rw == null) {
            it.remove();
            continue;
        }
        if (rw == w && r.prop.equals(r.prop)) {
            return;
        }
    }
    observers.add(r);
}

Output:
         }
-        if (rw == w && r.prop.equals(r.prop)) {
+        if (rw == w && ref.prop.equals(r.prop)) {
             return;


Input:
private String expendValue(Map labels, String value) {
    if (labels != null && value != null) {
        int offset = 0;
        while (offset < value.length()) {
            int start = value.indexOf("String_Node_Str", offset);
            if (start != -1) {
                int end = value.indexOf("String_Node_Str", start);
                if (end != -1) {
                    String exp = value.substring(start, end + 1);
                    String expStr = exp.substring(2, exp.length() - 1);
                    if (expStr.endsWith("String_Node_Str"))
                        expStr = expStr.substring(0, expStr.length() - 2);
                    Object expend = labels.get(expStr);
                    String expended = "String_Node_Str";
                    if (expend instanceof String)
                        expended = expendValue(labels, (String) expend);
                    else if (expend instanceof ExValue)
                        expended = expendValue(labels, ((ExValue) expend).getValue());
                    value = value.substring(0, start) + expended + value.substring(start + exp.length());
                    offset += start + expended.length();
                } else {
                    break;
                }
            } else {
                break;
            }
        }
    }
    return value;
}

Output:
                     value = value.substring(0, start) + expended + value.substring(start + exp.length());
-                    offset += start + expended.length();
+                    offset = start + expended.length();
                 } else {


Input:
public void run() {
    NodeEntry state = Preconditions.checkNotNull(graph.get(null, Reason.EVALUATION, skyKey), skyKey);
    Preconditions.checkState(state.isReady(), "String_Node_Str", skyKey, state);
    if (maybeHandleDirtyNode(state) == DirtyOutcome.ALREADY_PROCESSED) {
        return;
    }
    Set<SkyKey> oldDeps = state.getAllRemainingDirtyDirectDeps();
    SkyFunctionEnvironment env = new SkyFunctionEnvironment(skyKey, state.getTemporaryDirectDeps(), oldDeps, visitor);
    SkyFunctionName functionName = skyKey.functionName();
    SkyFunction factory = skyFunctions.get(functionName);
    Preconditions.checkState(factory != null, "String_Node_Str", functionName, skyKey, state);
    SkyValue value = null;
    long startTime = BlazeClock.instance().nanoTime();
    try {
        value = factory.compute(skyKey, env);
    } catch (final SkyFunctionException builderException) {
        ReifiedSkyFunctionException reifiedBuilderException = new ReifiedSkyFunctionException(builderException, skyKey);
        if ((!keepGoing || !env.valuesMissing()) && reifiedBuilderException.getRootCauseSkyKey().equals(skyKey)) {
            boolean shouldFailFast = !keepGoing || builderException.isCatastrophic();
            if (shouldFailFast) {
                if (!visitor.preventNewEvaluations()) {
                    return;
                }
            }
            Map<SkyKey, NodeEntry> newlyRequestedDeps = getBatchValues(skyKey, Reason.RDEP_ADDITION, env.newlyRequestedDeps);
            boolean isTransitivelyTransient = reifiedBuilderException.isTransient();
            for (NodeEntry depEntry : Iterables.concat(env.directDeps.values(), newlyRequestedDeps.values())) {
                if (!isDoneForBuild(depEntry)) {
                    continue;
                }
                ErrorInfo depError = depEntry.getErrorInfo();
                if (depError != null) {
                    isTransitivelyTransient |= depError.isTransient();
                }
            }
            ErrorInfo errorInfo = ErrorInfo.fromException(reifiedBuilderException, isTransitivelyTransient);
            registerNewlyDiscoveredDepsForDoneEntry(skyKey, state, newlyRequestedDeps, oldDeps, env);
            env.setError(state, errorInfo, reifiedBuilderException.isTransient());
            env.commit(state, keepGoing);
            if (!shouldFailFast) {
                return;
            }
            throw SchedulerException.ofError(errorInfo, skyKey);
        }
    } catch (InterruptedException ie) {
        throw SchedulerException.ofInterruption(ie, skyKey);
    } catch (RuntimeException re) {
        String msg = prepareCrashMessage(skyKey, state.getInProgressReverseDeps());
        RuntimeException ex = new RuntimeException(msg, re);
        visitor.noteCrash(ex);
        throw ex;
    } finally {
        env.doneBuilding();
        long elapsedTimeNanos = BlazeClock.instance().nanoTime() - startTime;
        if (elapsedTimeNanos > 0) {
            if (progressReceiver != null) {
                progressReceiver.computed(skyKey, elapsedTimeNanos);
            }
            Profiler.instance().logSimpleTaskDuration(startTime, elapsedTimeNanos, ProfilerTask.SKYFUNCTION, skyKey);
        }
    }
    GroupedListHelper<SkyKey> newDirectDeps = env.newlyRequestedDeps;
    if (value != null) {
        Preconditions.checkState(!env.valuesMissing(), "String_Node_Str" + "String_Node_Str", skyKey, newDirectDeps, state);
        env.setValue(value);
        registerNewlyDiscoveredDepsForDoneEntry(skyKey, state, graph.getBatch(skyKey, Reason.RDEP_ADDITION, env.newlyRequestedDeps), oldDeps, env);
        env.commit(state, true);
        return;
    }
    if (env.getDepErrorKey() != null) {
        Preconditions.checkState(!keepGoing, "String_Node_Str", skyKey, state, env.getDepErrorKey());
        SkyKey childErrorKey = env.getDepErrorKey();
        NodeEntry childErrorEntry = Preconditions.checkNotNull(graph.get(skyKey, Reason.OTHER, childErrorKey), "String_Node_Str", skyKey, state, childErrorKey);
        Preconditions.checkState(!state.getTemporaryDirectDeps().expensiveContains(childErrorKey), "String_Node_Str", skyKey, state, childErrorKey, childErrorEntry);
        Preconditions.checkState(newDirectDeps.contains(childErrorKey), "String_Node_Str", state, childErrorKey, newDirectDeps);
        state.addTemporaryDirectDeps(GroupedListHelper.create(ImmutableList.of(childErrorKey)));
        DependencyState childErrorState;
        if (oldDeps.contains(childErrorKey)) {
            childErrorState = childErrorEntry.checkIfDoneForDirtyReverseDep(skyKey);
        } else {
            childErrorState = childErrorEntry.addReverseDepAndCheckIfDone(skyKey);
        }
        Preconditions.checkState(childErrorState == DependencyState.DONE, "String_Node_Str", skyKey, state, childErrorKey, childErrorEntry);
        ErrorInfo childErrorInfo = Preconditions.checkNotNull(childErrorEntry.getErrorInfo());
        visitor.preventNewEvaluations();
        throw SchedulerException.ofError(childErrorInfo, childErrorKey);
    }
    state.addTemporaryDirectDeps(newDirectDeps);
    if (newDirectDeps.isEmpty()) {
        Preconditions.checkState(!env.childErrorInfos.isEmpty(), "String_Node_Str", skyKey, state);
        Preconditions.checkState(keepGoing, "String_Node_Str", skyKey, state, env.childErrorInfos);
        env.commit(state, true);
        return;
    }
    for (Map.Entry<SkyKey, NodeEntry> e : graph.createIfAbsentBatch(skyKey, Reason.ENQUEUING_CHILD, newDirectDeps).entrySet()) {
        SkyKey newDirectDep = e.getKey();
        NodeEntry newDirectDepEntry = e.getValue();
        enqueueChild(skyKey, state, newDirectDep, newDirectDepEntry, oldDeps.contains(newDirectDep));
    }
}

Output:
         NodeEntry childErrorEntry = Preconditions.checkNotNull(graph.get(skyKey, Reason.OTHER, childErrorKey), "String_Node_Str", skyKey, state, childErrorKey);
-        Preconditions.checkState(!state.getTemporaryDirectDeps().expensiveContains(childErrorKey), "String_Node_Str", skyKey, state, childErrorKey, childErrorEntry);
-        Preconditions.checkState(newDirectDeps.contains(childErrorKey), "String_Node_Str", state, childErrorKey, newDirectDeps);
-        state.addTemporaryDirectDeps(GroupedListHelper.create(ImmutableList.of(childErrorKey)));
-        DependencyState childErrorState;
-        if (oldDeps.contains(childErrorKey)) {
-            childErrorState = childErrorEntry.checkIfDoneForDirtyReverseDep(skyKey);
-        } else {
-            childErrorState = childErrorEntry.addReverseDepAndCheckIfDone(skyKey);
+        if (newDirectDeps.contains(childErrorKey)) {
+            state.addTemporaryDirectDeps(GroupedListHelper.create(ImmutableList.of(childErrorKey)));
+            DependencyState childErrorState;
+            if (oldDeps.contains(childErrorKey)) {
+                childErrorState = childErrorEntry.checkIfDoneForDirtyReverseDep(skyKey);
+            } else {
+                childErrorState = childErrorEntry.addReverseDepAndCheckIfDone(skyKey);
+            }
+            Preconditions.checkState(childErrorState == DependencyState.DONE, "String_Node_Str", skyKey, state, childErrorKey, childErrorEntry);
         }


Input:
private ByteArrayArray getByteArrayArray() {
    int count = 0;
    boolean interrupted = false;
    try {
        while (true) {
            ByteArrayArray baa = baaRef.get();
            if (baa != null) {
                if (!baa.isClosed()) {
                    return baa;
                }
                baaRef.compareAndSet(baa, null);
                continue;
            }
            if (baaRef.compareAndSet(null, openInProgress)) {
                baa = null;
                try {
                    try {
                        baa = new SimpleRegionFile(file, segmentSize, entries, timeout);
                    } catch (ClosedByInterruptException e1) {
                        interrupted |= Thread.interrupted();
                        baa = null;
                        continue;
                    } catch (IOException e) {
                        System.out.println("String_Node_Str" + file);
                        baa = null;
                    }
                    return baa;
                } finally {
                    if (!baaRef.compareAndSet(openInProgress, baa)) {
                        throw new IllegalStateException("String_Node_Str");
                    }
                }
            }
            count++;
            if (count > 10) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                }
            } else if (count > 0) {
                Thread.yield();
            }
        }
    } finally {
        if (interrupted) {
            Thread.currentThread().interrupt();
        }
    }
}

Output:
     int count = 0;
-    boolean interrupted = false;
-    try {
-        while (true) {
-            ByteArrayArray baa = baaRef.get();
-            if (baa != null) {
-                if (!baa.isClosed()) {
-                    return baa;
-                }
-                baaRef.compareAndSet(baa, null);
-                continue;
+    while (true) {
+        ByteArrayArray baa = baaRef.get();
+        if (baa != null) {
+            if (!baa.isClosed()) {
+                return baa;
             }


Input:
static public byte[] encrypteRSAPkcs1Twice(byte[] clearData, byte[] server_key_public_exponent, byte[] server_key_public_modulus, byte[] host_key_public_exponent, byte[] host_key_public_modulus) {
    byte[] EncryptionBlock;
    int offset = 0;
    EncryptionBlock = new byte[server_key_public_modulus.length];
    EncryptionBlock[0] = 0;
    EncryptionBlock[1] = 2;
    offset = 2;
    for (int i = 2; i < (EncryptionBlock.length - clearData.length - 1); i++) EncryptionBlock[offset++] = SshMisc.getNotZeroRandomByte();
    EncryptionBlock[offset++] = 0;
    for (int i = 0; i < clearData.length; i++) EncryptionBlock[offset++] = clearData[i];
    BigInteger m, e, message;
    byte[] messageByte;
    m = new BigInteger(1, server_key_public_modulus);
    e = new BigInteger(1, server_key_public_exponent);
    message = new BigInteger(1, EncryptionBlock);
    message = message.modPow(e, m);
    byte[] messageByteTemp = message.toByteArray();
    messageByte = new byte[server_key_public_modulus.length];
    int tempOffset = 0;
    while (messageByteTemp[tempOffset] == 0) tempOffset++;
    for (int i = messageByte.length - messageByteTemp.length + tempOffset; i < messageByte.length; i++) messageByte[i] = messageByteTemp[tempOffset++];
    clearData = messageByte;
    offset = 0;
    EncryptionBlock = new byte[host_key_public_modulus.length];
    EncryptionBlock[0] = 0;
    EncryptionBlock[1] = 2;
    offset = 2;
    for (int i = 2; i < (EncryptionBlock.length - clearData.length - 1); i++) EncryptionBlock[offset++] = SshMisc.getNotZeroRandomByte();
    EncryptionBlock[offset++] = 0;
    for (int i = 0; i < clearData.length; i++) EncryptionBlock[offset++] = clearData[i];
    m = new BigInteger(1, host_key_public_modulus);
    e = new BigInteger(1, host_key_public_exponent);
    message = new BigInteger(1, EncryptionBlock);
    message = message.modPow(e, m);
    messageByteTemp = message.toByteArray();
    messageByte = new byte[host_key_public_modulus.length];
    tempOffset = 0;
    while (messageByteTemp[tempOffset] == 0) tempOffset++;
    for (int i = messageByte.length - messageByteTemp.length + tempOffset; i < messageByte.length; i++) messageByte[i] = messageByteTemp[tempOffset++];
    byte[] encrypted_session_key = new byte[host_key_public_modulus.length + 2];
    encrypted_session_key[1] = (byte) ((8 * host_key_public_modulus.length) & 0xff);
    encrypted_session_key[0] = (byte) (((8 * host_key_public_modulus.length) >> 8) & 0xff);
    for (int i = 0; i < host_key_public_modulus.length; i++) encrypted_session_key[i + 2] = messageByte[i];
    return encrypted_session_key;
}

Output:
     int offset = 0;
-    EncryptionBlock = new byte[server_key_public_modulus.length];
+    EncryptionBlock = new byte[key1mod.length];
     EncryptionBlock[0] = 0;


Input:
public int replace(final int offset, final int length, final String text, int undoId) {
    int docLength = _text.length();
    int insLength = text.length();
    final int cutStart = Math.max(0, offset + Math.min(length, 0));
    int cutEnd = Math.min(docLength, offset + Math.max(length, 0));
    String ntext = new StringBuilder().append(_text, 0, cutStart).append(text).append(_text, cutEnd, docLength).toString();
    if (!validateEdit(_text, ntext)) {
        return -1;
    }
    if (undoId > 0) {
        if (undoId != _lastUndoId) {
            _undosup.postEdit(_compoundEdit = new AbstractUndoableEdit() {
                public boolean addEdit(UndoableEdit edit) {
                    return edit.isSignificant() ? false : _edits.add(edit);
                }
                public void undo() {
                    super.undo();
                    for (int ii = _edits.size() - 1; ii >= 0; ii--) {
                        _edits.get(ii).undo();
                    }
                }
                public void redo() {
                    super.redo();
                    for (int ii = 0, nn = _edits.size(); ii < nn; ii++) {
                        _edits.get(ii).redo();
                    }
                }
                protected ArrayList<UndoableEdit> _edits = new ArrayList<UndoableEdit>();
            });
        }
        final String otext = _text.substring(cutStart, cutEnd);
        _compoundEdit.addEdit(new AbstractUndoableEdit() {
            public void undo() {
                super.undo();
                replace(cutStart, text.length(), otext, -1);
            }
            public void redo() {
                super.redo();
                replace(offset, length, text, -1);
            }
            public boolean isSignificant() {
                return false;
            }
        });
    }
    _lastUndoId = undoId;
    _text = ntext;
    int cutLength = cutEnd - cutStart;
    if (cutLength > 0) {
        notify(false, cutStart, cutLength);
    }
    if (insLength > 0) {
        notify(true, cutEnd, insLength);
    }
    return cutStart + insLength;
}

Output:
     if (insLength > 0) {
-        notify(true, cutEnd, insLength);
+        notify(true, cutStart, insLength);
     }


Input:
protected void calculateNormal() {
    Vector2D temp = vB.sub(vA);
    temp.normalize();
    vN.x = -temp.x;
    vN.y = temp.y;
}

Output:
     temp.normalize();
-    vN.x = -temp.x;
-    vN.y = temp.y;
+    vN = new Vector2D(-temp.x, temp.y);
 }


Input:
public void run() {
    while (!stop) {
        synchronized (sync) {
            while (!newTask && !stop) {
                try {
                    sync.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        long endTime = System.currentTimeMillis() + nextDelay;
        long currentTime = System.currentTimeMillis();
        synchronized (sync) {
            while ((currentTime <= endTime) && newTask && !stop) {
                try {
                    sync.wait(endTime - currentTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                currentTime = System.currentTimeMillis();
            }
        }
        if (newTask && !stop) {
            newTask = false;
            executor.handleTimeout();
        }
    }
}

Output:
         synchronized (sync) {
-            while ((currentTime <= endTime) && newTask && !stop) {
+            while ((currentTime < endTime) && newTask && !stop) {
                 try {


Input:
public DictAndProximity createDictAndProximity(final Locale locale) {
    final ProximityInfo proximityInfo = ProximityInfo.createSpellCheckerProximityInfo();
    final Resources resources = getResources();
    final int fallbackResourceId = Utils.getMainDictionaryResourceId(resources);
    final DictionaryCollection dictionaryCollection = DictionaryFactory.createDictionaryFromManager(this, locale, fallbackResourceId);
    final String localeStr = locale.toString();
    Dictionary userDict = mUserDictionaries.get(localeStr);
    if (null == userDict) {
        userDict = new UserDictionary(this, localeStr);
        mUserDictionaries.put(localeStr, userDict);
    }
    dictionaryCollection.addDictionary(userDict);
    return new DictAndProximity(dictionaryCollection, proximityInfo);
}

Output:
     if (null == userDict) {
-        userDict = new UserDictionary(this, localeStr);
+        userDict = new SynchronouslyLoadedUserDictionary(this, localeStr);
         mUserDictionaries.put(localeStr, userDict);


Input:
public Enumeration getParameterNames() {
    init();
    Set keys = params.keySet();
    ArrayList<String> keyColl = new ArrayList<String>(keys);
    Collections.sort(keyColl);
    final Iterator iter = keyColl.iterator();
    return new Enumeration() {
        public boolean hasMoreElements() {
            return iter.hasNext();
        }
        public Object nextElement() {
            return iter.next();
        }
    };
}

Output:
     init();
-    Set keys = params.keySet();
-    ArrayList<String> keyColl = new ArrayList<String>(keys);
-    Collections.sort(keyColl);
-    final Iterator iter = keyColl.iterator();
+    final Iterator iter = paramNames.iterator();
     return new Enumeration() {


Input:
public void finish() {
    implicitDependencyExtractor.accumulate(context, checkingTreeScanner.getSeenClasses());
    if (!missingTargets.isEmpty()) {
        String canonicalizedLabel = dependencyModule.getTargetLabel() == null ? null : canonicalizeTarget(dependencyModule.getTargetLabel());
        List<JarOwner> canonicalizedMissing = new ArrayList<>();
        for (JarOwner owner : Ordering.natural().onResultOf(JarOwner.LABEL).immutableSortedCopy(missingTargets)) {
            canonicalizedMissing.add(JarOwner.create(canonicalizeTarget(owner.label()), owner.aspect()));
        }
        errWriter.print(dependencyModule.getFixMessage().get(canonicalizedMissing, canonicalizedLabel, USE_COLOR));
    }
}

Output:
         for (JarOwner owner : Ordering.natural().onResultOf(JarOwner.LABEL).immutableSortedCopy(missingTargets)) {
-            canonicalizedMissing.add(JarOwner.create(canonicalizeTarget(owner.label()), owner.aspect()));
+            String actualTarget = canonicalizeTarget(remapTarget(owner.label()));
+            canonicalizedMissing.add(JarOwner.create(actualTarget, owner.aspect()));
         }


Input:
public void doDelete_A$String() throws Exception {
    final HttpServer deleteServer = new HttpServer(new DeleteHandler());
    try {
        Runnable runnable = new Runnable() {
            public void run() {
                deleteServer.start();
            }
        };
        new Thread(runnable).start();
        OAuthRealm realm = null;
        SignatureMethod signatureMethod = SignatureMethod.HMAC_SHA1;
        SignedRequest request = new SignedRequestImpl(realm, HttpServerSpec.SINGLETON_CONSUMER(), signatureMethod);
        request.doDelete("String_Node_Str");
    } finally {
        deleteServer.stop();
    }
}

Output:
 public void doDelete_A$String() throws Exception {
-    final HttpServer deleteServer = new HttpServer(new DeleteHandler());
+    final HttpServer server = new HttpServer(new DeleteHandler());
     try {


Input:
public void warn(String messageFormat, Object... args) {
    if (messagePriorityThreshold <= Priority.WARN.getPrio()) {
        return;
    }
    addMessage(new Message(Priority.WARN, currentTimestamp(), String.format(messageFormat, args)));
}

Output:
 public void warn(String messageFormat, Object... args) {
-    if (messagePriorityThreshold <= Priority.WARN.getPrio()) {
+    if (messagePriorityThreshold > Priority.WARN.getPrio()) {
         return;


Input:
private SnapshotVO createSnapshotInDb(VolumeInfo volume) {
    Snapshot.Type snapshotType = Snapshot.Type.MANUAL;
    SnapshotVO snapshotVO = new SnapshotVO(volume.getDataCenterId(), 2, 1, volume.getId(), 1L, UUID.randomUUID().toString(), (short) snapshotType.ordinal(), snapshotType.name(), volume.getSize(), HypervisorType.XenServer);
    return this.snapshotDao.persist(snapshotVO);
}

Output:
     Snapshot.Type snapshotType = Snapshot.Type.MANUAL;
-    SnapshotVO snapshotVO = new SnapshotVO(volume.getDataCenterId(), 2, 1, volume.getId(), 1L, UUID.randomUUID().toString(), (short) snapshotType.ordinal(), snapshotType.name(), volume.getSize(), HypervisorType.XenServer);
+    SnapshotVO snapshotVO = new SnapshotVO(volume.getDataCenterId(), 2, 1, volume.getId(), 1L, UUID.randomUUID().toString(), (short) snapshotType.ordinal(), snapshotType.name(), volume.getSize(), 1L, 100L, HypervisorType.XenServer, LocationType.PRIMARY);
     return this.snapshotDao.persist(snapshotVO);


Input:
public KVMPhysicalDisk createDiskFromTemplate(KVMPhysicalDisk template, String name, KVMStoragePool destPool) {
    StorageAdaptor adaptor = getStorageAdaptor(destPool.getType());
    if (destPool.getType() == StoragePoolType.RBD) {
        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.RAW, template.getSize(), destPool);
    } else if (destPool.getType() == StoragePoolType.CLVM) {
        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.RAW, template.getSize(), destPool);
    } else if (template.getFormat() == PhysicalDiskFormat.DIR) {
        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.DIR, template.getSize(), destPool);
    } else {
        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.QCOW2, template.getSize(), destPool);
    }
}

Output:
     if (destPool.getType() == StoragePoolType.RBD) {
-        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.RAW, template.getSize(), destPool);
+        return adaptor.createDiskFromTemplate(template, name, PhysicalDiskFormat.RAW, template.getSize(), destPool, timeout);
     } else if (destPool.getType() == StoragePoolType.CLVM) {


Input:
protected int innerExportRestData(IResultObject resultObject, IRowResultSet rs, int dataCountOfUnit, StopSign stopSign) throws DataException, IOException {
    addNewRow(resultObject);
    int columnCount = rs.getMetaData().getFieldCount();
    int currDataCount = 1;
    IResultObject odaObject = null;
    while ((odaObject = rs.next()) != null) {
        if (stopSign.isStopped())
            return 0;
        Object[] ob = new Object[columnCount];
        for (int i = 0; i < columnCount; i++) ob[i] = odaObject.getFieldValue(i + 1);
        IResultObject rowData = resultObjectUtil.newResultObject(ob);
        addNewRow(rowData);
        currDataCount++;
    }
    processLastUnit(stopSign);
    return currDataCount;
}

Output:
     IResultObject odaObject = null;
-    while ((odaObject = rs.next()) != null) {
+    while ((odaObject = rs.next(stopSign)) != null) {
         if (stopSign.isStopped())


Input:
public void updateModelMerger(SModelMergerPluginConfiguration modelMerger) throws ServerException, UserException {
    requireRealUserAuthentication();
    DatabaseSession session = getBimServer().getDatabase().createSession();
    try {
        ModelMergerPluginConfiguration convert = getBimServer().getSConverter().convertFromSObject(modelMerger, session);
        session.executeAndCommitAction(new UpdateModelMergerDatabaseAction(session, getInternalAccessMethod(), convert));
    } catch (Exception e) {
        handleException(e);
    } finally {
        session.close();
    }
}

Output:
     try {
-        ModelMergerPluginConfiguration convert = getBimServer().getSConverter().convertFromSObject(modelMerger, session);
+        ModelMergerPluginConfiguration convert = session.get(modelMerger.getOid(), OldQuery.getDefault());
+        getBimServer().getSConverter().convertFromSObject(modelMerger, convert, session);
         session.executeAndCommitAction(new UpdateModelMergerDatabaseAction(session, getInternalAccessMethod(), convert));


Input:
public AbstractCommandLineMode configure(final String[] args) throws IOException, JSAPException {
    final JSAPResult jsapResult = parseJsapArguments(args);
    registeredDOClients.add(QualityScoreFilter.doc);
    registeredDOClients.add(VCFAveragingWriter.doc);
    dymamicOptions = jsapResult.getStringArray("String_Node_Str");
    for (final String dymamicOption : dymamicOptions) {
        boolean parsed = false;
        for (final DynamicOptionClient doc : registeredDOClients) {
            if (doc.acceptsOption(dymamicOption)) {
                parsed = true;
                break;
            }
        }
        if (!parsed) {
            System.err.println("String_Node_Str" + dymamicOption);
            System.exit(1);
        }
    }
    inputFilenames = jsapResult.getStringArray("String_Node_Str");
    outputFile = jsapResult.getString("String_Node_Str");
    outWriter = "String_Node_Str".equals(outputFile) ? new PrintWriter(System.out) : new PrintWriter(outputFile);
    String groupsDefinition = jsapResult.getString("String_Node_Str");
    String groupsDefinitionFile = jsapResult.getString("String_Node_Str");
    if (groupsDefinition != null && groupsDefinitionFile != null) {
        System.err.println("String_Node_Str");
        System.exit(1);
    }
    if (groupsDefinitionFile != null) {
        groupsDefinition = parseGroupFile(groupsDefinitionFile, inputFilenames);
    }
    String compare = jsapResult.getString("String_Node_Str");
    deAnalyzer.parseGroupsDefinition(groupsDefinition, deCalculator, inputFilenames);
    groupComparisonsList = deAnalyzer.parseCompare(compare);
    boolean parallel = jsapResult.getBoolean("String_Node_Str", false);
    deAnalyzer.setRunInParallel(parallel);
    Map<String, String> sampleToGroupMap = deCalculator.getSampleToGroupMap();
    readerIndexToGroupIndex = new int[inputFilenames.length];
    groups = deAnalyzer.getGroups();
    numberOfGroups = groups.length;
    IndexedIdentifier groupIds = new IndexedIdentifier();
    for (String group : groups) {
        groupIds.registerIdentifier(new MutableString(group));
    }
    maxThresholdPerSite = jsapResult.getInt("String_Node_Str");
    minimumVariationSupport = jsapResult.getInt("String_Node_Str");
    thresholdDistinctReadIndices = jsapResult.getInt("String_Node_Str");
    CompactAlignmentToAnnotationCountsMode.parseEval(jsapResult, deAnalyzer);
    for (String sample : sampleToGroupMap.keySet()) {
        final String group = sampleToGroupMap.get(sample);
        System.out.printf("String_Node_Str", sample, group);
        for (int readerIndex = 0; readerIndex < inputFilenames.length; readerIndex++) {
            if (AlignmentReaderImpl.getBasename(inputFilenames[readerIndex]).endsWith(sample)) {
                readerIndexToGroupIndex[readerIndex] = groupIds.get(new MutableString(group));
            }
        }
    }
    File statFile = jsapResult.getFile("String_Node_Str");
    if (statFile != null) {
        loadStatFile(statFile);
    } else {
        if (deAnalyzer.eval("String_Node_Str")) {
            System.err.println("String_Node_Str");
            System.exit(1);
        }
    }
    callIndels = jsapResult.getBoolean("String_Node_Str");
    realignmentFactory = configureProcessor(jsapResult);
    final String formatString = jsapResult.getString("String_Node_Str");
    final OutputFormat format = OutputFormat.valueOf(formatString.toUpperCase());
    SequenceVariationOutputFormat formatter = null;
    switch(format) {
        case VARIANT_DISCOVERY:
        case BETWEEN_GROUPS:
            stopWhenDefaultGroupOptions();
            formatter = new BetweenGroupSequenceVariationOutputFormat();
            break;
        case COMPARE_GROUPS:
            stopWhenDefaultGroupOptions();
            formatter = new CompareGroupsVCFOutputFormat();
            break;
        case ALLELE_FREQUENCIES:
            stopWhenDefaultGroupOptions();
            formatter = new AlleleFrequencyOutputFormat();
            break;
        case GENOTYPES:
            formatter = new GenotypesOutputFormat();
            break;
        case METHYLATION_REGIONS:
            formatter = new MethylationRegionsOutputFormat();
            methylFormat((MethylationRateVCFOutputFormat) formatter);
            break;
        case METHYLATION:
            formatter = new MethylationRateVCFOutputFormat();
            methylFormat((MethylationRateVCFOutputFormat) formatter);
            break;
        case INDEL_COUNTS:
            formatter = new IndelCountOutputFormat();
            callIndels = true;
            break;
        default:
            ObjectArrayList<OutputFormat> values = ObjectArrayList.wrap(OutputFormat.values());
            System.err.printf("String_Node_Str", values.toString());
            System.exit(1);
    }
    genotypeFilters = new ObjectArrayList<GenotypeFilter>();
    switch(format) {
        case METHYLATION:
        case METHYLATION_REGIONS:
            if (callIndels) {
                genotypeFilters.add(new RemoveIndelArtifactsFilter());
            }
            break;
        case COMPARE_GROUPS:
        case ALLELE_FREQUENCIES:
        case BETWEEN_GROUPS:
        case VARIANT_DISCOVERY:
            genotypeFilters.add(new QualityScoreFilter());
            genotypeFilters.add(new LeftOverFilter());
            if (callIndels) {
                genotypeFilters.add(new RemoveIndelArtifactsFilter());
            }
            if (!disableAtLeastQuarterFilter && callIndels) {
                System.out.println("String_Node_Str");
                genotypeFilters.add(new AtLeastAQuarterFilter());
            }
            break;
        case GENOTYPES:
            genotypeFilters.add(new QualityScoreFilter());
            genotypeFilters.add(new LeftOverFilter());
            if (callIndels) {
                genotypeFilters.add(new RemoveIndelArtifactsFilter());
            }
            if (!disableAtLeastQuarterFilter) {
                genotypeFilters.add(new AtLeastAQuarterFilter());
            }
            break;
        case INDEL_COUNTS:
            genotypeFilters.add(new QualityScoreFilter());
            genotypeFilters.add(new LeftOverFilter());
            genotypeFilters.add(new RemoveIndelArtifactsFilter());
            if (!disableAtLeastQuarterFilter) {
                genotypeFilters.add(new AtLeastAQuarterFilter());
            }
            break;
        default:
            throw new InternalError("String_Node_Str");
    }
    System.out.println("String_Node_Str");
    for (final GenotypeFilter filter : genotypeFilters) {
        System.out.println(filter.describe());
    }
    final RandomAccessSequenceInterface genome = configureGenome(testGenome, jsapResult);
    final int startFlapSize = jsapResult.getInt("String_Node_Str", 100);
    if (callIndels) {
        System.err.println("String_Node_Str");
    }
    formatConfigurator.configureFormatter(formatter);
    sortedPositionIterator = new DiscoverVariantIterateSortedAlignments(formatter);
    sortedPositionIterator.setCallIndels(callIndels);
    sortedPositionIterator.setGenome(genome);
    sortedPositionIterator.setStartFlapLength(startFlapSize);
    sortedPositionIterator.parseIncludeReferenceArgument(jsapResult);
    sortedPositionIterator.setMinimumVariationSupport(minimumVariationSupport);
    sortedPositionIterator.setThresholdDistinctReadIndices(thresholdDistinctReadIndices);
    return this;
}

Output:
             formatter = new MethylationRegionsOutputFormat();
-            methylFormat((MethylationRateVCFOutputFormat) formatter);
+            methylFormat((MethylationFormat) formatter);
             break;


Input:
int invokeEditFilter() {
    ExtendedItemHandle handle = getItemHandle();
    handle.getModuleHandle().getCommandStack().startTrans(null);
    ExtendedItemFilterDialog page = new ExtendedItemFilterDialog(handle);
    if (handle.getCube() != null && getDataServiceProvider().isInvokingSupported()) {
        try {
            if (handle.getReportItem() instanceof ChartReportItemImpl) {
                ((ChartReportItemImpl) handle.getReportItem()).setModel(getContext().getModel());
            }
        } catch (ExtendedElementException e) {
            WizardBase.displayException(e);
            return Window.CANCEL;
        }
        page.setFilterHandleProvider(new ChartCubeUIFilterHandleProvider());
    }
    int openStatus = page.open();
    if (openStatus == Window.OK) {
        handle.getModuleHandle().getCommandStack().commit();
    } else {
        handle.getModuleHandle().getCommandStack().rollback();
    }
    return openStatus;
}

Output:
     ExtendedItemFilterDialog page = new ExtendedItemFilterDialog(handle);
-    if (handle.getCube() != null && getDataServiceProvider().isInvokingSupported()) {
-        try {
-            if (handle.getReportItem() instanceof ChartReportItemImpl) {
-                ((ChartReportItemImpl) handle.getReportItem()).setModel(getContext().getModel());
-            }
-        } catch (ExtendedElementException e) {
-            WizardBase.displayException(e);
-            return Window.CANCEL;
-        }
-        page.setFilterHandleProvider(new ChartCubeUIFilterHandleProvider());
+    AbstractFilterHandleProvider provider = ChartFilterProviderDelegate.createFilterProvider(handle, handle);
+    if (provider instanceof ChartCubeFilterHandleProvider) {
+        ((ChartCubeFilterHandleProvider) provider).setContext(getContext());
     }


Input:
private void setUpViewPager() {
    mImageViewBg.setVisibility(View.INVISIBLE);
    List<SongEntity> songData = MusicManager.getInstance().getMusicService().getSongData();
    PlayViewAdapter adapter = new PlayViewAdapter(songData);
    mVpPlayView.setPageTransformer(false, new PlayPagerTransformer());
    mVpPlayView.setAdapter(adapter);
    ArgbEvaluator argbEvaluator = new ArgbEvaluator();
    mVpPlayView.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
            int color = adapter.getColorArr().get(position % songData.size());
            int nextColor = adapter.getColorArr().get((position + 1) % songData.size());
            int evaluateColor = (int) argbEvaluator.evaluate(positionOffset, color, nextColor);
            mClPlay.setBackgroundColor(evaluateColor);
        }
        public void onPageSelected(int position) {
            if (MusicManager.getInstance().getCurPosition() > position) {
                MusicManager.getInstance().skipToPrevious();
            } else if (MusicManager.getInstance().getCurPosition() < position) {
                MusicManager.getInstance().skipToNext();
            }
        }
        public void onPageScrollStateChanged(int state) {
        }
    });
}

Output:
     List<SongEntity> songData = MusicManager.getInstance().getMusicService().getSongData();
-    PlayViewAdapter adapter = new PlayViewAdapter(songData);
+    mPagerAdapter = new PlayViewAdapter(songData);
     mVpPlayView.setPageTransformer(false, new PlayPagerTransformer());


Input:
public int compare(Component o1, Component o2) {
    return Long.valueOf(getLastActivity(o1)).compareTo(Long.valueOf(getLastActivity(o2)));
}

Output:
 public int compare(Component o1, Component o2) {
-    return Long.valueOf(getLastActivity(o1)).compareTo(Long.valueOf(getLastActivity(o2)));
+    return Long.valueOf(getLastActivity(o2)).compareTo(getLastActivity(o1));
 }


Input:
public ItemStack onItemRightClick(ItemStack var1, World var2, EntityPlayer var3) {
    boolean var4 = var3.capabilities.isCreativeMode;
    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.wildWoodDust)) {
        return var1;
    } else {
        if (var1.getItem() == TwilightItemsWeapons.wildwoodBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzWildWood(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.wildWoodDust);
        }
    }
    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.mortumDust)) {
        return var1;
    } else {
        if (var1.getItem() == TwilightItemsWeapons.haliteBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzHalite(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.mortumDust);
        }
        if (var1.getItem() == TwilightItemsWeapons.mortumBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzMortum(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.mortumDust);
        }
    }
    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.apalachiaDust)) {
        return var1;
    } else {
        if (var1.getItem() == TwilightItemsWeapons.apalachiaBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzAlapachia(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.apalachiaDust);
        }
    }
    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.skythernDust)) {
        return var1;
    } else {
        if (var1.getItem() == TwilightItemsWeapons.skythernBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzSkythern(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.skythernDust);
        }
    }
    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.edenDust)) {
        return var1;
    } else {
        if (var1.getItem() == TwilightItemsWeapons.edenBlitz) {
            if (!var2.isRemote) {
                var2.playSoundAtEntity(var3, sound, 1.0F, 1.0F);
                var2.spawnEntityInWorld(new EntityBlitzEden(var2, var3));
            }
            var3.inventory.consumeInventoryItem(TwilightItemsOther.edenDust);
        }
    }
    var1.damageItem(1, var3);
    return var1;
}

Output:
     boolean var4 = var3.capabilities.isCreativeMode;
-    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.wildWoodDust)) {
+    if (!var4 && !var3.inventory.hasItem(TwilightItemsOther.wildwoodDust)) {
         return var1;


Input:
public void createCluster(final String name, final String distro, final String specFilePath, final String rpNames, final String dsNames, final String networkName, final boolean resume, final boolean skipConfigValidation) {
    if (name.indexOf("String_Node_Str") != -1) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_CLUSTER + Constants.PARAM_NOT_CONTAIN_HORIZONTAL_LINE);
        return;
    }
    if (resume) {
        resumeCreateCluster(name);
        return;
    }
    ClusterCreate clusterCreate = new ClusterCreate();
    clusterCreate.setName(name);
    if (distro != null) {
        List<String> distroNames = getDistroNames();
        if (validName(distro, distroNames)) {
            clusterCreate.setDistro(distro);
        } else {
            CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_DISTRO + Constants.PARAM_NOT_SUPPORTED + distroNames);
            return;
        }
    }
    if (rpNames != null) {
        List<String> rpNamesList = CommandsUtils.inputsConvert(rpNames);
        if (rpNamesList.isEmpty()) {
            CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.INPUT_RPNAMES_PARAM + Constants.MULTI_INPUTS_CHECK);
            return;
        } else {
            clusterCreate.setRpNames(rpNamesList);
        }
    }
    if (dsNames != null) {
        List<String> dsNamesList = CommandsUtils.inputsConvert(dsNames);
        if (dsNamesList.isEmpty()) {
            CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.INPUT_DSNAMES_PARAM + Constants.MULTI_INPUTS_CHECK);
            return;
        } else {
            clusterCreate.setDsNames(dsNamesList);
        }
    }
    try {
        if (specFilePath != null) {
            ClusterCreate clusterSpec = CommandsUtils.getObjectByJsonString(ClusterCreate.class, CommandsUtils.dataFromFile(specFilePath));
            clusterCreate.setNodeGroups(clusterSpec.getNodeGroups());
            clusterCreate.setConfiguration(clusterSpec.getConfiguration());
            if (!skipConfigValidation) {
                if (!validateConfiguration(clusterCreate)) {
                    return;
                }
            } else {
                clusterCreate.setValidateConfig(false);
            }
        }
    } catch (Exception e) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, e.getMessage());
        return;
    }
    List<String> networkNames = getNetworkNames();
    if (networkNames.isEmpty()) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_NETWORK_NAME + Constants.PARAM_NOT_EXISTED);
        return;
    } else {
        if (networkName != null) {
            if (validName(networkName, networkNames)) {
                clusterCreate.setNetworkName(networkName);
            } else {
                CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_NETWORK_NAME + Constants.PARAM_NOT_SUPPORTED + networkNames);
                return;
            }
        } else {
            if (networkNames.size() == 1) {
                clusterCreate.setNetworkName(networkNames.get(0));
            } else {
                CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, Constants.PARAM_NETWORK_NAME + Constants.PARAM_NOT_SPECIFIED);
                return;
            }
        }
    }
    if (specFilePath != null) {
        if (!validateClusterCreate(clusterCreate)) {
            return;
        }
    }
    try {
        restClient.create(clusterCreate);
        CommandsUtils.printCmdSuccess(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_RESULT_CREAT);
    } catch (CliRestException e) {
        CommandsUtils.printCmdFailure(Constants.OUTPUT_OBJECT_CLUSTER, name, Constants.OUTPUT_OP_CREATE, Constants.OUTPUT_OP_RESULT_FAIL, e.getMessage());
    }
}

Output:
             if (!skipConfigValidation) {
-                if (!validateConfiguration(clusterCreate)) {
+                ValidateResult whiteListResult = validateWhiteList(clusterCreate);
+                if (!showWhiteListWarning(clusterCreate.getName(), whiteListResult)) {
                     return;


Input:
protected MElementInfo<T, C> getElementInfo(EI info) {
    return elementInfos.get(info);
}

Output:
 protected MElementInfo<T, C> getElementInfo(EI info) {
-    return elementInfos.get(info);
+    MElementInfo<T, C> elementInfo = elementInfos.get(info);
+    if (elementInfo == null) {
+        elementInfo = createElementInfo(info);
+        elementInfos.put(info, elementInfo);
+    }
+    return elementInfo;
 }


Input:
protected void onResume() {
    super.onResume();
    int autoTextSize = AutoText.getSize(getListView());
    if (autoTextSize < 1) {
        ((PreferenceGroup) findPreference(PREDICTION_SETTINGS_KEY)).removePreference(mQuickFixes);
    }
    if (!LatinIME.VOICE_INSTALLED || !RecognitionManager.isRecognitionAvailable(this)) {
        getPreferenceScreen().removePreference(mVoicePreference);
    } else {
        updateVoiceModeSummary();
    }
}

Output:
     }
-    if (!LatinIME.VOICE_INSTALLED || !RecognitionManager.isRecognitionAvailable(this)) {
+    if (!LatinIME.VOICE_INSTALLED || !SpeechRecognizer.isRecognitionAvailable(this)) {
         getPreferenceScreen().removePreference(mVoicePreference);


Input:
protected boolean acceptType(IType type, int acceptFlags, boolean isSourceType) {
    if (acceptFlags == 0 || acceptFlags == ACCEPT_ALL)
        return true;
    if (kind == TypeDeclaration.CLASS_DECL && (acceptFlags & ACCEPT_CLASSES) == 0 && (acceptFlags & ACCEPT_ANNOTATIONS) != 0) {
        IAnnotation[] annos = type.getAnnotations();
        if (annos != null && annos.length > 0) {
            for (IAnnotation anno : annos) {
                if (anno != null && "String_Node_Str".equals(anno.getElementName())) {
                    kind = TypeDeclaration.ANNOTATION_TYPE_DECL;
                    break;
                }
            }
        }
    }
    try {
        int kind = isSourceType ? TypeDeclaration.kind(((SourceTypeElementInfo) ((SourceType) type).getElementInfo()).getModifiers()) : TypeDeclaration.kind(((IBinaryType) ((BinaryType) type).getElementInfo()).getModifiers());
        switch(kind) {
            case TypeDeclaration.CLASS_DECL:
                return (acceptFlags & ACCEPT_CLASSES) != 0;
            case TypeDeclaration.INTERFACE_DECL:
                return (acceptFlags & ACCEPT_INTERFACES) != 0;
            case TypeDeclaration.ENUM_DECL:
                return (acceptFlags & ACCEPT_ENUMS) != 0;
            default:
                return (acceptFlags & ACCEPT_ANNOTATIONS) != 0;
        }
    } catch (JavaModelException npe) {
        return false;
    }
}

Output:
         return true;
-    if (kind == TypeDeclaration.CLASS_DECL && (acceptFlags & ACCEPT_CLASSES) == 0 && (acceptFlags & ACCEPT_ANNOTATIONS) != 0) {
-        IAnnotation[] annos = type.getAnnotations();
-        if (annos != null && annos.length > 0) {
-            for (IAnnotation anno : annos) {
-                if (anno != null && "String_Node_Str".equals(anno.getElementName())) {
-                    kind = TypeDeclaration.ANNOTATION_TYPE_DECL;
-                    break;
+    try {
+        int kind = isSourceType ? TypeDeclaration.kind(((SourceTypeElementInfo) ((SourceType) type).getElementInfo()).getModifiers()) : TypeDeclaration.kind(((IBinaryType) ((BinaryType) type).getElementInfo()).getModifiers());
+        if (kind == TypeDeclaration.CLASS_DECL && (acceptFlags & ACCEPT_CLASSES) == 0 && (acceptFlags & ACCEPT_ANNOTATIONS) != 0) {
+            IAnnotation[] annos = type.getAnnotations();
+            if (annos != null && annos.length > 0) {
+                for (IAnnotation anno : annos) {
+                    if (anno != null && "String_Node_Str".equals(anno.getElementName())) {
+                        kind = TypeDeclaration.ANNOTATION_TYPE_DECL;
+                        break;
+                    }
                 }