Input:
public void validateClusterCreate(List<String> failedMsgList, List<String> warningMsgList, final List<String> distroRoles) {
    boolean namenodeHACheck = false;
    int masterCount = 0, jobtrackerCount = 0, resourcemanagerCount = 0, hbasemasterCount = 0, zookeeperCount = 0, workerCount = 0, numOfJournalNode = 0;
    boolean appendWarningStr = false;
    if (warningMsgList != null && warningMsgList.isEmpty()) {
        appendWarningStr = true;
    }
    NodeGroupCreate[] nodeGroupCreates = getNodeGroups();
    if (nodeGroupCreates == null || nodeGroupCreates.length == 0) {
        failedMsgList.add(Constants.MULTI_INPUTS_CHECK);
        return;
    } else {
        if (hasHDFSUrlConfigured() && !validateHDFSUrl()) {
            failedMsgList.add(new StringBuilder().append("String_Node_Str").append(getExternalHDFS()).toString());
        }
        validateNodeGroupPlacementPolicies(failedMsgList, warningMsgList);
        validateNodeGroupRoles(failedMsgList);
        validateStorageType(failedMsgList);
        validateSwapRatio(nodeGroupCreates, failedMsgList);
        for (NodeGroupCreate nodeGroupCreate : nodeGroupCreates) {
            checkInstanceNum(nodeGroupCreate, failedMsgList);
            makeVmMemoryDivisibleBy4(nodeGroupCreate, warningMsgList);
            checkNodeGroupRoles(nodeGroupCreate, distroRoles, failedMsgList);
            List<NodeGroupRole> groupRoles = getNodeGroupRoles(nodeGroupCreate);
            if (groupRoles != null) {
                for (NodeGroupRole role : groupRoles) {
                    switch(role) {
                        case MASTER:
                            masterCount++;
                            int numOfInstance = nodeGroupCreate.getInstanceNum();
                            if (numOfInstance >= 0 && numOfInstance != 1) {
                                if (numOfInstance != 2) {
                                    collectInstanceNumInvalidateMsg(nodeGroupCreate, failedMsgList);
                                } else {
                                    namenodeHACheck = true;
                                }
                            }
                            break;
                        case JOB_TRACKER:
                            jobtrackerCount++;
                            if (nodeGroupCreate.getInstanceNum() >= 0 && nodeGroupCreate.getInstanceNum() != 1) {
                                failedMsgList.add(Constants.WRONG_NUM_OF_JOBTRACKER);
                            }
                            break;
                        case RESOURCEMANAGER:
                            resourcemanagerCount++;
                            if (nodeGroupCreate.getInstanceNum() >= 0 && nodeGroupCreate.getInstanceNum() != 1) {
                                failedMsgList.add(Constants.WRONG_NUM_OF_RESOURCEMANAGER);
                            }
                            break;
                        case HBASE_MASTER:
                            hbasemasterCount++;
                            if (nodeGroupCreate.getInstanceNum() == 0) {
                                collectInstanceNumInvalidateMsg(nodeGroupCreate, failedMsgList);
                            }
                            break;
                        case ZOOKEEPER:
                            zookeeperCount++;
                            if (nodeGroupCreate.getInstanceNum() > 0 && nodeGroupCreate.getInstanceNum() < 3) {
                                failedMsgList.add(Constants.WRONG_NUM_OF_ZOOKEEPER);
                            } else if (nodeGroupCreate.getInstanceNum() > 0 && nodeGroupCreate.getInstanceNum() % 2 == 0) {
                                warningMsgList.add(Constants.ODD_NUM_OF_ZOOKEEPER);
                            }
                            break;
                        case JOURNAL_NODE:
                            numOfJournalNode += nodeGroupCreate.getInstanceNum();
                            if (nodeGroupCreate.getRoles().contains(HadoopRole.HADOOP_DATANODE.toString()) || nodeGroupCreate.getRoles().contains(HadoopRole.HADOOP_CLIENT_ROLE.toString())) {
                                failedMsgList.add(Constants.DATA_CLIENT_NODE_JOURNALNODE_COEXIST);
                            }
                            break;
                        case WORKER:
                            workerCount++;
                            if (nodeGroupCreate.getInstanceNum() == 0) {
                                collectInstanceNumInvalidateMsg(nodeGroupCreate, failedMsgList);
                            } else if (isHAFlag(nodeGroupCreate)) {
                                warningMsgList.add(Constants.WORKER_CLIENT_HA_FLAG);
                            }
                            List<String> roles = nodeGroupCreate.getRoles();
                            if (roles.contains(HadoopRole.HBASE_REGIONSERVER_ROLE.toString()) && !roles.contains(HadoopRole.HADOOP_DATANODE.toString())) {
                                warningMsgList.add(Constants.REGISONSERVER_DATANODE_SEPERATION);
                            }
                            break;
                        case CLIENT:
                            if (isHAFlag(nodeGroupCreate)) {
                                warningMsgList.add(Constants.WORKER_CLIENT_HA_FLAG);
                            }
                            break;
                        case NONE:
                            warningMsgList.add(Constants.NOT_DEFINED_ROLE);
                            break;
                        default:
                    }
                }
            }
        }
        if (!supportedWithHdfs2()) {
            if (namenodeHACheck || masterCount > 1) {
                failedMsgList.add(Constants.CURRENT_DISTRO_CAN_NOT_SUPPORT_HDFS2);
            }
        } else if (namenodeHACheck) {
            if (numOfJournalNode >= 0 && numOfJournalNode < 3) {
                failedMsgList.add(Constants.WRONG_NUM_OF_JOURNALNODE);
            } else if (numOfJournalNode > 0 && numOfJournalNode % 2 == 0) {
                warningMsgList.add(Constants.ODD_NUM_OF_JOURNALNODE);
            }
            if (zookeeperCount == 0) {
                failedMsgList.add(Constants.NAMENODE_AUTO_FAILOVER_ZOOKEEPER);
            }
        }
        if ((jobtrackerCount > 1) || (resourcemanagerCount > 1) || (zookeeperCount > 1) || (hbasemasterCount > 1)) {
            failedMsgList.add(Constants.WRONG_NUM_OF_NODEGROUPS);
        }
        if (workerCount == 0) {
            warningMsgList.add(Constants.WRONG_NUM_OF_WORKERNODES);
        }
        if (numOfJournalNode > 0 && !namenodeHACheck) {
            failedMsgList.add(Constants.NO_NAMENODE_HA);
        }
        if (!warningMsgList.isEmpty() && appendWarningStr) {
            warningMsgList.set(0, "String_Node_Str" + warningMsgList.get(0));
        }
    }
}

Output:
     NodeGroupCreate[] nodeGroupCreates = getNodeGroups();
-    if (nodeGroupCreates == null || nodeGroupCreates.length == 0) {
-        failedMsgList.add(Constants.MULTI_INPUTS_CHECK);
-        return;
-    } else {
-        if (hasHDFSUrlConfigured() && !validateHDFSUrl()) {
-            failedMsgList.add(new StringBuilder().append("String_Node_Str").append(getExternalHDFS()).toString());
-        }
-        validateNodeGroupPlacementPolicies(failedMsgList, warningMsgList);
-        validateNodeGroupRoles(failedMsgList);
-        validateStorageType(failedMsgList);
-        validateSwapRatio(nodeGroupCreates, failedMsgList);
-        for (NodeGroupCreate nodeGroupCreate : nodeGroupCreates) {
-            checkInstanceNum(nodeGroupCreate, failedMsgList);
-            makeVmMemoryDivisibleBy4(nodeGroupCreate, warningMsgList);
-            checkNodeGroupRoles(nodeGroupCreate, distroRoles, failedMsgList);
-            List<NodeGroupRole> groupRoles = getNodeGroupRoles(nodeGroupCreate);
-            if (groupRoles != null) {
-                for (NodeGroupRole role : groupRoles) {
-                    switch(role) {
-                        case MASTER:
-                            masterCount++;
-                            int numOfInstance = nodeGroupCreate.getInstanceNum();
-                            if (numOfInstance >= 0 && numOfInstance != 1) {
-                                if (numOfInstance != 2) {
-                                    collectInstanceNumInvalidateMsg(nodeGroupCreate, failedMsgList);
-                                } else {
-                                    namenodeHACheck = true;
-                                }
-                            }
-                            break;
-                        case JOB_TRACKER:
-                            jobtrackerCount++;
-                            if (nodeGroupCreate.getInstanceNum() >= 0 && nodeGroupCreate.getInstanceNum() != 1) {
-                                failedMsgList.add(Constants.WRONG_NUM_OF_JOBTRACKER);
-                            }
-                            break;
-                        case RESOURCEMANAGER:
-                            resourcemanagerCount++;
-                            if (nodeGroupCreate.getInstanceNum() >= 0 && nodeGroupCreate.getInstanceNum() != 1) {
-                                failedMsgList.add(Constants.WRONG_NUM_OF_RESOURCEMANAGER);
-                            }
-                            break;
-                        case HBASE_MASTER:
-                            hbasemasterCount++;
-                            if (nodeGroupCreate.getInstanceNum() == 0) {
+    AuAssert.check(nodeGroupCreates != null && nodeGroupCreates.length > 0);
+    if (hasHDFSUrlConfigured() && !validateHDFSUrl()) {
+        failedMsgList.add(new StringBuilder().append("String_Node_Str").append(getExternalHDFS()).toString());
+    }
+    validateNodeGroupPlacementPolicies(failedMsgList, warningMsgList);
+    validateNodeGroupRoles(failedMsgList);
+    validateStorageType(failedMsgList);
+    validateSwapRatio(nodeGroupCreates, failedMsgList);
+    for (NodeGroupCreate nodeGroupCreate : nodeGroupCreates) {
+        checkInstanceNum(nodeGroupCreate, failedMsgList);
+        makeVmMemoryDivisibleBy4(nodeGroupCreate, warningMsgList);
+        checkNodeGroupRoles(nodeGroupCreate, distroRoles, failedMsgList);
+        List<NodeGroupRole> groupRoles = getNodeGroupRoles(nodeGroupCreate);
+        if (groupRoles != null) {
+            for (NodeGroupRole role : groupRoles) {
+                switch(role) {
+                    case MASTER:
+                        masterCount++;
+                        int numOfInstance = nodeGroupCreate.getInstanceNum();
+                        if (numOfInstance >= 0 && numOfInstance != 1) {
+                            if (numOfInstance != 2) {
                                 collectInstanceNumInvalidateMsg(nodeGroupCreate, failedMsgList);


Input:
private static TilePairClient.Parameters getTestParameters(final int zNeighborDistance, final String toJson) throws IllegalArgumentException {
    final TilePairClient.Parameters p = new TilePairClient.Parameters();
    final String argString = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + zNeighborDistance + "String_Node_Str" + toJson;
    p.parse(argString.split("String_Node_Str"));
    return p;
}

Output:
     final TilePairClient.Parameters p = new TilePairClient.Parameters();
-    final String argString = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + zNeighborDistance + "String_Node_Str" + toJson;
+    final String argString = "String_Node_Str" + "String_Node_Str" + maxPairsPerFile + "String_Node_Str" + "String_Node_Str" + zNeighborDistance + "String_Node_Str" + toJson;
     p.parse(argString.split("String_Node_Str"));


Input:
public boolean handleOperationStatus(String clusterName, OperationStatusWithDetail status) {
    logger.info("String_Node_Str" + status.getOperationStatus());
    boolean finished = status.getOperationStatus().isFinished();
    final Map<String, GroupData> groups = status.getClusterData().getGroups();
    ClusterEntity cluster = findByName(clusterName);
    AuAssert.check(cluster.getId() != null);
    for (NodeGroupEntity group : cluster.getNodeGroups()) {
        for (String groupName : groups.keySet()) {
            if (groupName.equals(group.getName())) {
                for (ServerData serverData : groups.get(groupName).getInstances()) {
                    logger.debug("String_Node_Str" + serverData.getName() + "String_Node_Str" + serverData.getAction() + "String_Node_Str" + serverData.getStatus());
                    Iterator<NodeEntity> iter = group.getNodes().iterator();
                    while (iter.hasNext()) {
                        NodeEntity oldNode = iter.next();
                        if (oldNode.getVmName().equals(serverData.getName())) {
                            logger.debug("String_Node_Str" + oldNode.getVmName() + "String_Node_Str" + oldNode.getStatus());
                            oldNode.setAction(serverData.getAction());
                            logger.debug("String_Node_Str" + NodeStatus.fromString(serverData.getStatus()));
                            String errorMsg = serverData.getError_msg();
                            if (errorMsg != null && !errorMsg.isEmpty()) {
                                oldNode.setActionFailed(true);
                                oldNode.setErrMessage(errorMsg);
                                logger.debug("String_Node_Str" + errorMsg);
                            }
                            if (!oldNode.isDisconnected()) {
                                oldNode.setStatus(NodeStatus.fromString(serverData.getStatus()), false);
                                logger.debug("String_Node_Str" + oldNode.getVmName() + "String_Node_Str" + oldNode.getStatus());
                            } else {
                                logger.debug("String_Node_Str");
                            }
                            update(oldNode);
                            break;
                        }
                    }
                }
            }
        }
    }
    logger.debug("String_Node_Str");
    return finished;
}

Output:
                             String errorMsg = serverData.getError_msg();
-                            if (errorMsg != null && !errorMsg.isEmpty()) {
+                            if (lastUpdate && errorMsg != null && !errorMsg.isEmpty()) {
                                 oldNode.setActionFailed(true);


Input:
private final void showBottomValue(IPrimitiveRenderer ipr, Location lo, Label la, boolean bShadow) {
    Graphics2D g2d = (Graphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
    double dX = lo.getX(), dY = lo.getY();
    FontDefinition fd = la.getCaption().getFont();
    double dAngleInDegrees = fd.getRotation();
    Color clrText = (Color) _sxs.getColor(la.getCaption().getColor());
    Color clrBackground = null;
    if (la.getBackground() != null) {
        clrBackground = (Color) _sxs.getColor((ColorDefinition) la.getBackground());
    }
    double dAngleInRadians = ((-dAngleInDegrees * Math.PI) / 180.0);
    final ITextMetrics itm = new SVGTextMetrics(_sxs, la);
    final double dFW = itm.getFullWidth();
    final double dH = itm.getHeight();
    final double dD = itm.getDescent();
    final double dFH = itm.getFullHeight();
    double dXOffset = 0, dW = 0;
    final int iLC = itm.getLineCount();
    final Insets ins = la.getInsets().scaledInstance(_sxs.getDpiResolution() / 72d);
    SVGTextLayout tl;
    final HorizontalAlignment ha = la.getCaption().getFont().getAlignment().getHorizontalAlignment();
    final boolean bRightAligned = ha.getValue() == HorizontalAlignment.RIGHT;
    final boolean bCenterAligned = ha.getValue() == HorizontalAlignment.CENTER;
    dX -= dFW / 2;
    dY += dH;
    if (dAngleInDegrees == 0) {
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) (dY - dD + dH * i + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
    } else if (dAngleInDegrees > 0 && dAngleInDegrees < 90) {
        double dSineTheta = Math.abs(Math.sin(dAngleInRadians));
        double dCosTheta = Math.abs(Math.cos(dAngleInRadians));
        double dDeltaX = dFW * dCosTheta - dH * dSineTheta - dFW / 2.0;
        double dDeltaY = dH * dCosTheta + dFW * dSineTheta - dH;
        dX -= dDeltaX;
        dY += dDeltaY;
        g2d.rotate(dAngleInRadians, dX, dY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) (dY - dD + dH * i + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY);
    } else if (dAngleInDegrees < 0 && dAngleInDegrees > -90) {
        dX += dFW / 2;
        g2d.rotate(dAngleInRadians, dX, dY - dH);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dH) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dH) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dH) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dH, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) (dY - dD + dH * i + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY - dH);
    } else if (dAngleInDegrees == 90) {
        double dYHalfOffset = (dFH + dH) / 2.0;
        double dDeltaX = (dFW + dH) / 2;
        double dDeltaY = (dFW - dH);
        dX += dDeltaX;
        dY += dDeltaY;
        g2d.rotate(dAngleInRadians, dX, dY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dYHalfOffset) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dYHalfOffset) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dYHalfOffset) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dYHalfOffset, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) (((dY - dD) - ((iLC - i) * dH - (iLC + 1) * dH / 2)) + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY);
    } else if (dAngleInDegrees == -90) {
        dX += dFW / 2;
        dY -= dH;
        double dYHalfOffset = (dFH + dH) / 2d;
        double dDeltaX = dYHalfOffset - dFH / 2d;
        dX -= dDeltaX;
        g2d.rotate(dAngleInRadians, dX, dY);
        if (bShadow) {
            g2d.setPaint(new GradientPaint(new Point2D.Double(dX + 3, (dY - dYHalfOffset) + 3), (Color) _sxs.getColor(la.getShadowColor()), new Point2D.Double(dX + 3 + dFW, (dY - dYHalfOffset) + 3 + dFH), (Color) _sxs.getColor(la.getShadowColor().translucent())));
            g2d.fill(new Rectangle2D.Double(dX + 3, (dY - dYHalfOffset) + 3, dFW, dFH));
        } else {
            final Rectangle2D.Double r2d = new Rectangle2D.Double(dX, dY - dYHalfOffset, dFW, dFH);
            if (clrBackground != null) {
                g2d.setColor(clrBackground);
                g2d.fill(r2d);
            }
            g2d.setColor(clrText);
            for (int i = 0; i < iLC; i++) {
                tl = ((SVGTextMetrics) itm).getLayout(i);
                if (bRightAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + dFW - dW - ins.getRight();
                } else if (bCenterAligned) {
                    dW = tl.getBounds().getWidth();
                    dXOffset = -ins.getLeft() + (dFW - dW) / 2;
                }
                tl.draw(g2d, (float) (dX + dXOffset + ins.getLeft()), (float) ((dY - dD) - dYHalfOffset + dH * (i + 1) + ins.getTop()));
            }
            renderOutline(ipr, la.getOutline(), r2d);
        }
        g2d.rotate(-dAngleInRadians, dX, dY);
    }
    itm.dispose();
}

Output:
 private final void showBottomValue(IPrimitiveRenderer ipr, Location lo, Label la, boolean bShadow) {
-    Graphics2D g2d = (Graphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
+    SVGGraphics2D g2d = (SVGGraphics2D) ((IDeviceRenderer) ipr).getGraphicsContext();
     double dX = lo.getX(), dY = lo.getY();


Input:
public Object getValueOfProperty(String propertyName, Object object) {
    String name = this.caseSensitive ? propertyName : propertyName.toLowerCase();
    Field field = this.fields.get(propertyName);
    try {
        return field.get(object);
    } catch (IllegalAccessException e) {
        throw new Sql2oException("String_Node_Str" + field.getName() + "String_Node_Str" + object.getClass().toString(), e);
    }
}

Output:
     String name = this.caseSensitive ? propertyName : propertyName.toLowerCase();
-    Field field = this.fields.get(propertyName);
+    Field field = this.fields.get(name);
     try {


Input:
public Hashtable<Long, UserVmData> listVmDetails(Hashtable<Long, UserVmData> userVmDataHash) {
    TransactionLegacy txn = TransactionLegacy.currentTxn();
    PreparedStatement pstmt = null;
    try {
        int curr_index = 0;
        List<UserVmData> userVmDataList = new ArrayList(userVmDataHash.values());
        if (userVmDataList.size() > VM_DETAILS_BATCH_SIZE) {
            pstmt = txn.prepareStatement(VM_DETAILS + getQueryBatchAppender(VM_DETAILS_BATCH_SIZE));
            while ((curr_index + VM_DETAILS_BATCH_SIZE) <= userVmDataList.size()) {
                for (int k = 1, j = curr_index; j < curr_index + VM_DETAILS_BATCH_SIZE; j++, k++) {
                    pstmt.setLong(k, userVmDataList.get(j).getId());
                }
                ResultSet rs = pstmt.executeQuery();
                while (rs.next()) {
                    long vm_id = rs.getLong("String_Node_Str");
                    UserVmData uvm = userVmDataHash.get(vm_id);
                    if (uvm == null) {
                        uvm = new UserVmData();
                        uvm.setId(vm_id);
                    }
                    setUserVmData(uvm, rs);
                }
                rs.close();
                curr_index += VM_DETAILS_BATCH_SIZE;
            }
            if (pstmt != null)
                pstmt.close();
        }
        if (curr_index < userVmDataList.size()) {
            int batch_size = (userVmDataList.size() - curr_index);
            pstmt = txn.prepareStatement(VM_DETAILS + getQueryBatchAppender(batch_size));
            for (int k = 1, j = curr_index; j < curr_index + batch_size; j++, k++) {
                pstmt.setLong(k, userVmDataList.get(j).getId());
            }
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                long vm_id = rs.getLong("String_Node_Str");
                UserVmData uvm = userVmDataHash.get(vm_id);
                if (uvm == null) {
                    uvm = new UserVmData();
                    uvm.setId(vm_id);
                }
                setUserVmData(uvm, rs);
            }
            rs.close();
        }
        if (pstmt != null)
            pstmt.close();
        return userVmDataHash;
    } catch (SQLException e) {
        throw new CloudRuntimeException("String_Node_Str" + VM_DETAILS, e);
    } catch (Throwable e) {
        throw new CloudRuntimeException("String_Node_Str" + VM_DETAILS, e);
    }
}

Output:
         if (userVmDataList.size() > VM_DETAILS_BATCH_SIZE) {
-            pstmt = txn.prepareStatement(VM_DETAILS + getQueryBatchAppender(VM_DETAILS_BATCH_SIZE));
-            while ((curr_index + VM_DETAILS_BATCH_SIZE) <= userVmDataList.size()) {
-                for (int k = 1, j = curr_index; j < curr_index + VM_DETAILS_BATCH_SIZE; j++, k++) {
-                    pstmt.setLong(k, userVmDataList.get(j).getId());
-                }
-                ResultSet rs = pstmt.executeQuery();
-                while (rs.next()) {
-                    long vm_id = rs.getLong("String_Node_Str");
-                    UserVmData uvm = userVmDataHash.get(vm_id);
-                    if (uvm == null) {
-                        uvm = new UserVmData();
-                        uvm.setId(vm_id);
+            try (PreparedStatement pstmt = txn.prepareStatement(VM_DETAILS + getQueryBatchAppender(VM_DETAILS_BATCH_SIZE))) {
+                while ((curr_index + VM_DETAILS_BATCH_SIZE) <= userVmDataList.size()) {
+                    for (int k = 1, j = curr_index; j < curr_index + VM_DETAILS_BATCH_SIZE; j++, k++) {
+                        pstmt.setLong(k, userVmDataList.get(j).getId());
+                    }
+                    try (ResultSet rs = pstmt.executeQuery()) {
+                        while (rs.next()) {
+                            long vm_id = rs.getLong("String_Node_Str");
+                            UserVmData uvm = userVmDataHash.get(vm_id);
+                            if (uvm == null) {
+                                uvm = new UserVmData();
+                                uvm.setId(vm_id);
+                            }
+                            setUserVmData(uvm, rs);
+                        }
+                    } catch (Exception e) {
+                        s_logger.error("String_Node_Str" + e.getMessage());
+                        throw new CloudRuntimeException("String_Node_Str" + e.getMessage(), e);
                     }


Input:
public void run() {
    Client c0 = ClientServiceImpl.instance.findByUserId(cc.getUserId());
    if (c0 != null) {
        ClientServiceImpl.instance.updateStatus(c0.getId(), 2);
    }
}

Output:
 public void run() {
-    Client c0 = ClientServiceImpl.instance.findByUserId(cc.getUserId());
+    Client c0 = ClientServiceImpl.instance.findByUserId(pbapnsEvent.getUserId());
     if (c0 != null) {


Input:
private void loadS3files(boolean is_scan) {
    List<AwsAccount> accounts = AccountDao.getAllAccounts(false);
    if (!accounts.isEmpty()) {
        int mode = EnhancedS3FileChooser.MODE_OPEN;
        if (is_scan) {
            mode = EnhancedS3FileChooser.MODE_SCAN;
        }
        application.newS3Files(EnhancedS3FileChooser.showDialog(CloudTrailViewer.frame, mode));
    } else {
        JOptionPane.showMessageDialog(CloudTrailViewer.frame, "String_Node_Str");
    }
}

Output:
         }
-        application.newS3Files(EnhancedS3FileChooser.showDialog(CloudTrailViewer.frame, mode));
+        LoadFileRequest request = EnhancedS3FileChooser.showDialog(CloudTrailViewer.frame, mode);
+        if (request != null) {
+            application.newS3Files(request);
+        }
     } else {


Input:
public void onCreate() {
    super.onCreate();
    SharedPreferences prefs = getSharedPreferences(Constants.PREFS_FILE_NAME, MODE_WORLD_READABLE);
    if (prefs.getBoolean("String_Node_Str", false)) {
        SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        Sensor proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
        String sensorKey = SensorUtil.generateUniqueSensorKey(proximitySensor);
        String mockValuesKey = SensorUtil.generateUniqueSensorMockValuesKey(proximitySensor);
        prefs.edit().putInt(sensorKey, Constants.SENSOR_STATUS_MOCK_VALUES).putString(mockValuesKey, "String_Node_Str").remove("String_Node_Str").apply();
    }
}

Output:
         String mockValuesKey = SensorUtil.generateUniqueSensorMockValuesKey(proximitySensor);
-        prefs.edit().putInt(sensorKey, Constants.SENSOR_STATUS_MOCK_VALUES).putString(mockValuesKey, "String_Node_Str").remove("String_Node_Str").apply();
+        prefs.edit().putInt(sensorKey, Constants.SENSOR_STATUS_MOCK_VALUES).putString(mockValuesKey, proximitySensor.getMaximumRange() + "String_Node_Str").remove("String_Node_Str").apply();
     }


Input:
int[] getOrderedFields() {
    if (orderedFieldsArray != null) {
        return orderedFieldsArray;
    }
    orderedFieldsArray = new int[orderedFields.size()];
    for (int i = 0; i < orderedFields.size(); i++) {
        orderedFieldsArray[i] = ((Integer) orderedFields.get(i)).intValue();
    }
    return orderedFieldsArray;
}

Output:
 int[] getOrderedFields() {
-    if (orderedFieldsArray != null) {
-        return orderedFieldsArray;
-    }
-    orderedFieldsArray = new int[orderedFields.size()];
-    for (int i = 0; i < orderedFields.size(); i++) {
-        orderedFieldsArray[i] = ((Integer) orderedFields.get(i)).intValue();
+    if (orderedFieldsArray == null) {
+        orderedFieldsArray = new int[fields.size()];
+        Iterator fieldItr = fields.iterator();
+        int i = 0;
+        while (fieldItr.hasNext()) {
+            orderedFieldsArray[i++] = ((Integer) fieldItr.next()).intValue();
+        }
     }


Input:
public Map<String, String> getProperties(Id.NamespacedId entityId) throws NotFoundException {
    ensureEntityExists(entityId);
    return businessMds.getProperties(entityId);
}

Output:
 public Map<String, String> getProperties(Id.NamespacedId entityId) throws NotFoundException {
-    ensureEntityExists(entityId);
+    entityValidator.ensureEntityExists(entityId);
     return businessMds.getProperties(entityId);


Input:
public void addValidationConfiguration(ScaffoldGeneratedResources event) {
    if (event.getProvider() instanceof MetawidgetScaffold) {
        final FileResource<?> configFile = getMetawidgetConfigurationFile();
        if (configFile.exists()) {
            final Node root = XMLParser.parse(configFile.getResourceInputStream());
            removeAllCommentNodes(root);
            boolean choice;
            final Node beanValidationInspector = root.getSingle("String_Node_Str");
            if (beanValidationInspector != null) {
                choice = prompt.promptBoolean("String_Node_Str");
            } else {
                choice = prompt.promptBoolean("String_Node_Str");
            }
            if (choice) {
                addValidationConfigurationTo(root);
                configFile.setContents(XMLParser.toXMLString(root));
            }
        }
    }
}

Output:
             final Node root = XMLParser.parse(configFile.getResourceInputStream());
-            removeAllCommentNodes(root);
+            final Node array = root.getOrCreate("String_Node_Str").attribute("String_Node_Str", "String_Node_Str").getOrCreate("String_Node_Str").getOrCreate("String_Node_Str").attribute("String_Node_Str", "String_Node_Str").attribute("String_Node_Str", "String_Node_Str").getOrCreate("String_Node_Str").getOrCreate("String_Node_Str");
             boolean choice;


Input:
public void run() {
    if (!org.talend.commons.utils.platform.PluginChecker.isOnlyTopLoaded()) {
        if (updatePalette && GlobalServiceRegister.getDefault().isServiceRegistered(ICoreService.class)) {
            ICoreService service = (ICoreService) GlobalServiceRegister.getDefault().getService(ICoreService.class);
            service.updatePalette();
        }
        if (!CoreRuntimePlugin.getInstance().isDataProfilePerspectiveSelected()) {
            RepositoryManager.refresh(ERepositoryObjectType.JOB_SCRIPT);
            IRepositoryView repositoryView = RepositoryManagerHelper.getRepositoryView();
            if (repositoryView != null) {
                repositoryView.refresh();
            }
        }
        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
        for (IEditorReference editors : page.getEditorReferences()) {
            if (GlobalServiceRegister.getDefault().isServiceRegistered(IDiagramModelService.class)) {
                IDiagramModelService service = (IDiagramModelService) GlobalServiceRegister.getDefault().getService(IDiagramModelService.class);
                service.refreshBusinessModel(editors);
            }
        }
        if (!deleteActionCache.isDocRefresh() && !CoreRuntimePlugin.getInstance().isDataProfilePerspectiveSelected()) {
            RepositoryManager.refreshCreatedNode(ERepositoryObjectType.DOCUMENTATION);
        }
    }
    deleteActionCache.revertParameters();
}

Output:
             if (repositoryView != null) {
-                repositoryView.refresh();
+                RepositoryManager.refresh(types);
             }


Input:
private boolean isZippedResponse() {
    boolean zipped = (null != this.getResponseHeader(CONTENT_ENCODING) && this.getResponseHeader(CONTENT_ENCODING).getValue().equals(CONTENT_ENCODING_GZIP));
    return zipped;
}

Output:
 private boolean isZippedResponse() {
-    boolean zipped = (null != this.getResponseHeader(CONTENT_ENCODING) && this.getResponseHeader(CONTENT_ENCODING).getValue().equals(CONTENT_ENCODING_GZIP));
-    return zipped;
+    boolean contentEncodingGzip = (null != this.getResponseHeader(CONTENT_ENCODING) && this.getResponseHeader(CONTENT_ENCODING).getValue().equals(CONTENT_ENCODING_GZIP));
+    Trace.trace(Activator.PLUGIN_ID, "String_Node_Str" + (contentEncodingGzip ? "String_Node_Str" : "String_Node_Str"));
+    boolean hasGzSuffix = targetHasGzSuffix(remoteFileName);
+    return contentEncodingGzip && !hasGzSuffix;
 }


Input:
public static void main(String[] args) {
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    File file = PropertiesUtil.findConfigFile("String_Node_Str");
    if (file != null) {
        System.out.println("String_Node_Str" + file.getAbsolutePath());
        DOMConfigurator.configureAndWatch(file.getAbsolutePath(), 10000);
    } else {
        System.out.println("String_Node_Str");
    }
    if (args.length < 1) {
        s_logger.error("String_Node_Str");
    } else {
        try {
            DatabaseConfig config = ComponentContext.inject(DatabaseConfig.class, args[0]);
            config.doVersionCheck();
            config.doConfig();
            System.exit(0);
        } catch (Exception ex) {
            System.out.print("String_Node_Str");
            ex.printStackTrace();
            s_logger.error("String_Node_Str", ex);
        }
    }
}

Output:
         try {
-            DatabaseConfig config = ComponentContext.inject(DatabaseConfig.class, args[0]);
+            DatabaseConfig config = ComponentContext.inject(DatabaseConfig.class);
             config.doVersionCheck();


Input:
public static ArrayList<String> getInformationFromStacks(ArrayList<ItemStack> upgrades, SteamToolSlot redSlot, ItemStack tool) {
    if (upgrades == null) {
        return null;
    }
    ArrayList<String> strings = new ArrayList<>();
    for (ItemStack stack : upgrades) {
        ISteamToolUpgrade upgrade = (ISteamToolUpgrade) stack.getItem();
        EnumChatFormatting format = upgrade.getToolSlot() == redSlot ? EnumChatFormatting.RED : EnumChatFormatting.DARK_GREEN;
        String info = upgrade.getInformation(stack, tool);
        String toAdd = info == null ? stack.getItem().getUnlocalizedName() + "String_Node_Str" : info;
        strings.add(format + "String_Node_Str" + StatCollector.translateToLocal(toAdd));
    }
    if (strings.isEmpty()) {
        return null;
    }
    return strings;
}

Output:
     if (upgrades == null) {
-        return null;
+        return new ArrayList<>();
     }


Input:
private void buildUI(Container container) {
    buildPropDescTable();
    curDiag = getNewDiag();
    MouseListener mouseListener = new MouseAdapter() {
        public void mouseClicked(MouseEvent e) {
            int i = jtp.indexAtLocation(e.getX(), e.getY());
            if (i == -1)
                return;
            ButtonTabComponent b = (ButtonTabComponent) driver.jtp.getTabComponentAt(i);
            Diagram diag = b.diag;
            if (diag == null) {
                curDiag = getNewDiag();
            }
            curDiag = diag;
            frame.repaint();
        }
    };
    jtp.addMouseListener(mouseListener);
    container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
    Box box1 = new Box(BoxLayout.Y_AXIS);
    container.add(box1);
    Box box4 = new Box(BoxLayout.X_AXIS);
    box1.add(box4);
    int sf = (int) Math.round(100.0 * scalingFactor);
    JSlider zoomControl = new JSlider(JSlider.VERTICAL, 60, 200, sf);
    zoomControl.setPreferredSize(new Dimension(40, 200));
    zoomControl.setMajorTickSpacing(20);
    zoomControl.setPaintTicks(true);
    zoomControl.setSnapToTicks(true);
    zoomControl.setPaintLabels(false);
    zoomControl.setPaintTrack(true);
    zoomControl.setVisible(true);
    zoomControl.addChangeListener(this);
    zoomControl.getInputMap().put(escapeKS, "String_Node_Str");
    zoomControl.getActionMap().put("String_Node_Str", escapeAction);
    Box box45 = new Box(BoxLayout.Y_AXIS);
    Box box46 = new Box(BoxLayout.X_AXIS);
    Box box5 = new Box(BoxLayout.X_AXIS);
    Box box61 = new Box(BoxLayout.X_AXIS);
    Box box62 = new Box(BoxLayout.X_AXIS);
    Box box6 = new Box(BoxLayout.Y_AXIS);
    box5.add(Box.createRigidArea(new Dimension(10, 0)));
    box6.add(Box.createRigidArea(new Dimension(0, 10)));
    scaleLab = new JLabel();
    box61.add(scaleLab);
    box61.add(Box.createRigidArea(new Dimension(5, 0)));
    box62.add(zoom);
    box62.add(Box.createRigidArea(new Dimension(5, 0)));
    box6.add(zoomControl);
    box6.add(Box.createRigidArea(new Dimension(0, 10)));
    scaleLab.setForeground(Color.BLUE);
    String scale = "String_Node_Str";
    scaleLab.setText(scale);
    box6.add(Box.createRigidArea(new Dimension(0, 10)));
    box6.add(box61);
    box6.add(Box.createRigidArea(new Dimension(0, 10)));
    box6.add(box62);
    box5.add(box6);
    box5.add(Box.createRigidArea(new Dimension(10, 0)));
    grid.setFont(fontg);
    grid.setSelected(true);
    grid.setActionCommand("String_Node_Str");
    grid.addActionListener(this);
    grid.setBackground(slateGray1);
    grid.setBorderPaintedFlat(false);
    box6.add(Box.createRigidArea(new Dimension(0, 10)));
    box45.add(box5);
    box45.add(Box.createRigidArea(new Dimension(0, 10)));
    box46.add(grid);
    box46.add(Box.createRigidArea(new Dimension(0, 10)));
    box45.add(box46);
    box4.add(box45);
    Point p = jtp.getLocation();
    jtp.setLocation(p.x + 100, p.y);
    box4.add(jtp);
    box4.add(Box.createRigidArea(new Dimension(50, 0)));
    curDiag.area.setAlignmentX(Component.LEFT_ALIGNMENT);
    diagDesc.setAlignmentX(Component.CENTER_ALIGNMENT);
    box1.add(diagDesc);
    Font ft = fontg.deriveFont(Font.BOLD);
    diagDesc.setFont(ft);
    diagDesc.setPreferredSize(new Dimension(0, gFontHeight * 2));
    diagDesc.setForeground(Color.BLUE);
    box1.add(Box.createRigidArea(new Dimension(0, 4)));
    Box box2 = new Box(BoxLayout.X_AXIS);
    box2.setBorder(BorderFactory.createLineBorder(Color.LIGHT_GRAY));
    box1.add(box2);
    box2.add(pan);
    box2.add(Box.createRigidArea(new Dimension(10, 0)));
    box2.add(Box.createHorizontalGlue());
    pan.setSelected(false);
    pan.setFont(fontg);
    pan.setActionCommand("String_Node_Str");
    pan.addActionListener(this);
    pan.setBackground(slateGray1);
    pan.setBorderPaintedFlat(false);
    ButtonGroup butGroup = new ButtonGroup();
    String[] buttonNames = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" };
    for (int j = 0; j < but.length; j++) {
        but[j] = new JRadioButton();
        but[j].addActionListener(this);
        butGroup.add(but[j]);
        box2.add(but[j]);
        but[j].setText(buttonNames[j]);
        but[j].setFocusable(true);
    }
    adjustFonts();
    but[0].setSelected(true);
    box2.add(Box.createHorizontalGlue());
    Component[] comps = box2.getComponents();
    for (int j = 0; j < comps.length; j++) {
        if (comps[j] instanceof JRadioButton) {
            JRadioButton jrb = (JRadioButton) comps[j];
            jrb.getInputMap().put(escapeKS, "String_Node_Str");
            jrb.getActionMap().put("String_Node_Str", escapeAction);
        }
    }
    BufferedImage image = loadImage("String_Node_Str");
    frame.setIconImage(image);
    leafIcon = new ImageIcon(image);
    image = loadImage("String_Node_Str");
    javaIcon = new ImageIcon(image);
    image = loadImage("String_Node_Str");
    jarIcon = new ImageIcon(image);
    image = loadImage("String_Node_Str");
    folderIcon = new ImageIcon(image);
    image = loadImage("String_Node_Str");
    classIcon = new ImageIcon(image);
    Toolkit tk = Toolkit.getDefaultToolkit();
    image = null;
    openPawCursor = null;
    image = loadImage("String_Node_Str");
    openPawCursor = tk.createCustomCursor(image, new Point(15, 15), "String_Node_Str");
    closedPawCursor = null;
    image = loadImage("String_Node_Str");
    closedPawCursor = tk.createCustomCursor(image, new Point(15, 15), "String_Node_Str");
    image = loadImage("String_Node_Str");
    drag_icon = tk.createCustomCursor(image, new Point(1, 1), "String_Node_Str");
}

Output:
         butGroup.add(but[j]);
-        box2.add(but[j]);
+        box21.add(but[j]);
         but[j].setText(buttonNames[j]);


Input:
public double[][] learn(double[] x, double[] y) {
    try {
        k = Integer.parseInt(kField.getText().trim());
        if (k < 1) {
            JOptionPane.showMessageDialog(this, "String_Node_Str" + k, "String_Node_Str", JOptionPane.ERROR_MESSAGE);
            return null;
        }
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(this, "String_Node_Str" + kField.getText(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        return null;
    }
    double[][] data = dataset[datasetIndex].toArray(new double[dataset[datasetIndex].size()][]);
    int[] label = dataset[datasetIndex].toArray(new int[dataset[datasetIndex].size()]);
    KNN<double[]> knn = KNN.learn(data, label, k);
    int[] pred = new int[label.length];
    for (int i = 0; i < label.length; i++) {
        pred[i] = knn.predict(data[i]);
    }
    double trainError = error(pred, label);
    System.out.format("String_Node_Str", 100 * trainError);
    double[][] z = new double[y.length][x.length];
    for (int i = 0; i < y.length; i++) {
        for (int j = 0; j < x.length; j++) {
            double[] p = { x[j], y[i] };
            z[i][j] = knn.predict(p);
        }
    }
    return z;
}

Output:
     }
-    double trainError = error(pred, label);
+    double trainError = error(label, pred);
     System.out.format("String_Node_Str", 100 * trainError);


Input:
public void testLoadFromAndSaveAfterDefineMultipleSchemas() throws Exception {
    List types = defineTypes();
    xsdHelper.define(getSchema(getUnrelatedSchemaName()));
    FileReader reader = new FileReader(getControlFileName());
    XMLDocument document = xmlHelper.load(reader, null, getOptions());
    verifyAfterLoad(document);
    String s = xmlHelper.save(document.getRootObject(), getControlRootURI(), getControlRootName());
    compareXML(getControlDataObjectFileName(), s);
}

Output:
 public void testLoadFromAndSaveAfterDefineMultipleSchemas() throws Exception {
-    List types = defineTypes();
+    defineTypes();
     xsdHelper.define(getSchema(getUnrelatedSchemaName()));


Input:
private void calculateRowHeight(SheetData[] rowData) {
    double rowHeight = 0;
    int rowIndex = getRowIndex(rowData);
    double lastRowHeight = rowIndex > 0 ? cache.getRowHeight(rowIndex - 1) : 0;
    for (int i = 0; i < rowData.length; i++) {
        SheetData data = rowData[i];
        if (data != null) {
            if (data.isBlank()) {
                BlankData blankData = (BlankData) data;
                if (blankData.getType() == Type.VERTICAL) {
                    data.setHeight(data.getHeight() - lastRowHeight);
                }
            }
            SheetData realData = getRealData(data);
            if (realData != null) {
                int realDataRowEnd = realData.getRowIndex() + realData.getRowSpan();
                if (realDataRowEnd == data.getRowIndex()) {
                    rowHeight = data.getHeight() > rowHeight ? data.getHeight() : rowHeight;
                }
            }
        }
    }
    cache.setRowHeight(rowIndex, rowHeight);
}

Output:
     double lastRowHeight = rowIndex > 0 ? cache.getRowHeight(rowIndex - 1) : 0;
-    for (int i = 0; i < rowData.length; i++) {
-        SheetData data = rowData[i];
-        if (data != null) {
-            if (data.isBlank()) {
-                BlankData blankData = (BlankData) data;
-                if (blankData.getType() == Type.VERTICAL) {
-                    data.setHeight(data.getHeight() - lastRowHeight);
+    boolean hasCurrentRowHeight = cache.hasRowHeight(rowIndex);
+    if (!hasCurrentRowHeight || isAuto) {
+        for (int i = 0; i < rowData.length; i++) {
+            SheetData data = rowData[i];
+            if (data != null) {
+                if (data.isBlank()) {
+                    BlankData blankData = (BlankData) data;
+                    if (blankData.getType() == Type.VERTICAL) {
+                        data.setHeight(data.getHeight() - lastRowHeight);
+                    }
                 }


Input:
private void initProxy() throws IllegalArgumentException {
    final String proxyUrl = config.getProxy();
    final String[] hostAndPort = proxyUrl.split("String_Node_Str");
    if (hostAndPort.length != 2) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    final String host = hostAndPort[0];
    int port;
    try {
        port = Integer.parseInt(hostAndPort[1]);
    } catch (final NumberFormatException e) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    final HttpHost proxy = new HttpHost(host, port);
    LOG.info("String_Node_Str", proxy.getHostName(), proxy.getPort());
    httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
}

Output:
     } catch (final NumberFormatException e) {
-        throw new IllegalArgumentException("String_Node_Str");
+        throw new IllegalArgumentException("String_Node_Str", e);
     }


Input:
private TrackValidationStatus isSignalBlockValid(WorldCoordinate other) {
    if (other == null)
        return new TrackValidationStatus(true, "String_Node_Str");
    SignalBlock otherSignalBlock = getSignalAt(other);
    if (otherSignalBlock == null)
        return new TrackValidationStatus(true, "String_Node_Str");
    WorldCoordinate myTrack = getTrackLocation();
    if (myTrack == null)
        return new TrackValidationStatus(false, "String_Node_Str");
    Status otherTrackStatus = otherSignalBlock.getTrackStatus();
    if (otherTrackStatus == Status.INVALID)
        return new TrackValidationStatus(false, "String_Node_Str");
    WorldCoordinate otherTrack = trackCache.get(other);
    if (otherTrackStatus == Status.UNKNOWN) {
        if (otherTrack == null)
            return new TrackValidationStatus(true, "String_Node_Str");
    } else {
        otherTrack = otherSignalBlock.getTrackLocation();
        if (otherTrack != null)
            trackCache.put(other, otherTrack);
    }
    if (otherTrack == null)
        return new TrackValidationStatus(true, "String_Node_Str");
    TrackScanner.ScanResult scan = TrackScanner.scanStraightTrackSection(tile.getWorldObj(), myTrack.x, myTrack.y, myTrack.z, otherTrack.x, otherTrack.y, otherTrack.z);
    trackScans.put(otherTrack, scan);
    if (scan.verdict == TrackScanner.ScanResult.Verdict.VALID)
        return new TrackValidationStatus(true, "String_Node_Str");
    if (scan.verdict == TrackScanner.ScanResult.Verdict.UNKNOWN)
        return new TrackValidationStatus(true, "String_Node_Str");
    return new TrackValidationStatus(false, "String_Node_Str" + scan.verdict.name());
}

Output:
         return new TrackValidationStatus(true, "String_Node_Str");
-    WorldCoordinate myTrack = getTrackLocation();
-    if (myTrack == null)
+    Status trackStatus = getTrackStatus();
+    if (trackStatus == Status.INVALID)
         return new TrackValidationStatus(false, "String_Node_Str");


Input:
public void addElements(final ColumnIndicator[] elements) {
    ColumnIndicator[] newsArray = new ColumnIndicator[this.columnIndicators.length + elements.length];
    System.arraycopy(this.columnIndicators, 0, newsArray, 0, this.columnIndicators.length);
    for (int i = 0; i < elements.length; i++) {
        newsArray[this.columnIndicators.length + i] = elements[i];
    }
    this.setElements(newsArray);
}

Output:
     }
-    this.setElements(newsArray);
+    this.columnIndicators = newsArray;
+    this.addItemElements(elements);
 }


Input:
public void addKit(Kit kit) {
    if (kitExists(kit)) {
        updateKit(kit);
        return;
    }
    KitDataAccess data = new KitDataAccess();
    data.groups = new ArrayList<String>(Arrays.asList(kit.getGroups()));
    data.items = kit.getItemsAsStringList();
    data.name = kit.getName();
    data.owners = new ArrayList<String>(Arrays.asList(kit.getOwner()));
    data.useDelay = kit.getDelay();
    data.id = 0;
    try {
        Database.get().insert(data);
    } catch (DatabaseWriteException e) {
        Canary.logStacktrace(e.getMessage(), e);
    }
}

Output:
     KitDataAccess data = new KitDataAccess();
-    data.groups = new ArrayList<String>(Arrays.asList(kit.getGroups()));
+    data.groups = kit.getGroups() != null ? new ArrayList<String>(Arrays.asList(kit.getGroups())) : new ArrayList<String>();
     data.items = kit.getItemsAsStringList();


Input:
void createInformationSection(final ScrolledForm form, Composite topComp) {
    Section section = createSection(form, topComp, "String_Node_Str", false, "String_Node_Str");
    Composite sectionClient = toolkit.createComposite(section);
    sectionClient.setLayout(new GridLayout(2, false));
    Label loginLabel = new Label(sectionClient, SWT.NONE);
    loginLabel.setText("String_Node_Str");
    loginText = new Text(sectionClient, SWT.BORDER);
    GridDataFactory.fillDefaults().grab(true, true).applyTo(loginText);
    Label passwordLabel = new Label(sectionClient, SWT.NONE);
    passwordLabel.setText("String_Node_Str");
    passwordText = new Text(sectionClient, SWT.BORDER);
    GridDataFactory.fillDefaults().grab(true, true).applyTo(passwordText);
    TdProviderConnection connection = DataProviderHelper.getTdProviderConnection(tdDataProvider).getObject();
    String loginValue = TaggedValueHelper.getValue(PluginConstant.USER_PROPERTY, connection);
    loginText.setText(loginValue == null ? PluginConstant.EMPTY_STRING : loginValue);
    String passwordValue = TaggedValueHelper.getValue(PluginConstant.PASSWORD_PROPERTY, connection);
    passwordText.setText(passwordValue == null ? PluginConstant.EMPTY_STRING : passwordValue);
    Label urlLabel = new Label(sectionClient, SWT.NONE);
    urlLabel.setText("String_Node_Str");
    urlText = new Text(sectionClient, SWT.BORDER);
    GridDataFactory.fillDefaults().grab(true, true).applyTo(urlText);
    TypedReturnCode<TdProviderConnection> trc = DataProviderHelper.getTdProviderConnection(tdDataProvider);
    String urlValue = (trc.isOk()) ? trc.getObject().getConnectionString() : PluginConstant.EMPTY_STRING;
    urlText.setText(urlValue == null ? PluginConstant.EMPTY_STRING : urlValue);
    urlText.setEnabled(false);
    ModifyListener listener = new ModifyListener() {
        public void modifyText(ModifyEvent e) {
            setDirty(true);
            fireTextChange();
        }
    };
    loginText.addModifyListener(listener);
    passwordText.addModifyListener(listener);
    section.setClient(sectionClient);
}

Output:
     passwordLabel.setText("String_Node_Str");
-    passwordText = new Text(sectionClient, SWT.BORDER);
+    passwordText = new Text(sectionClient, SWT.BORDER | SWT.PASSWORD);
     GridDataFactory.fillDefaults().grab(true, true).applyTo(passwordText);


Input:
public void onMaximized() {
    if (!youtubePlayer.isPlaying()) {
        youtubePlayer.play();
    }
}

Output:
 public void onMaximized() {
-    if (!youtubePlayer.isPlaying()) {
-        youtubePlayer.play();
-    }
+    playVideo();
 }


Input:
private static void showUsage() {
    System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
}

Output:
 private static void showUsage() {
-    System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+    System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
 }


Input:
public void transform(NodeType node) {
    if (node == null) {
        return;
    }
    ElementParameterType modes = ComponentUtilities.getNodeProperty(node, "String_Node_Str");
    if (modes == null) {
        ComponentUtilities.addNodeProperty(node, "String_Node_Str", "String_Node_Str");
    }
    ComponentUtilities.setNodeValue(node, "String_Node_Str", "String_Node_Str");
}

Output:
     }
-    ComponentUtilities.setNodeValue(node, "String_Node_Str", "String_Node_Str");
+    String mode = ComponentUtilities.getNodePropertyValue(node, "String_Node_Str");
+    if (mode == null || "String_Node_Str".equals(mode.trim())) {
+        ComponentUtilities.setNodeValue(node, "String_Node_Str", "String_Node_Str");
+    }
 }


Input:
private void raiseWindow(String windowTitle) {
    Shell topshell = UIHelper.getShellProvider().getShell();
    parent = new Shell(topshell, SWT.SHELL_TRIM);
    parent.setText(windowTitle);
    Composite shell = new Composite(parent, SWT.NONE);
    GridLayout gridLayout = new GridLayout(3, false);
    shell.setLayout(gridLayout);
    Button closeButton = new Button(shell, SWT.PUSH);
    closeButton.setText("String_Node_Str");
    closeButton.addSelectionListener(new MyButtonHandler(this));
    new Button(shell, SWT.PUSH).setText("String_Node_Str");
    new Button(shell, SWT.PUSH).setText("String_Node_Str");
    Button button4 = new Button(shell, SWT.PUSH);
    button4.setText("String_Node_Str");
    GridData gridData = new GridData();
    gridData.verticalAlignment = SWT.TOP;
    button4.setLayoutData(gridData);
    Composite comp = new Composite(shell, SWT.NONE);
    GridLayout gl = new GridLayout(1, false);
    gl.marginWidth = 0;
    gl.marginHeight = 0;
    comp.setLayout(gl);
    Label l1 = new Label(comp, SWT.NONE);
    l1.setText("String_Node_Str");
    Composite compInner = new Composite(comp, SWT.None);
    GridLayout gin = new GridLayout(2, false);
    gin.marginWidth = 0;
    gin.marginHeight = 0;
    compInner.setLayout(gin);
    gridData = new GridData();
    gridData.verticalAlignment = SWT.TOP;
    compInner.setLayoutData(gridData);
    Button button7 = new Button(compInner, SWT.PUSH);
    button7.setText("String_Node_Str");
    gridData = new GridData();
    gridData.verticalAlignment = SWT.TOP;
    button7.setLayoutData(gridData);
    Label l2 = new Label(compInner, SWT.NONE);
    l2.setText("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    gridData = new GridData();
    gridData.verticalAlignment = SWT.TOP;
    l2.setLayoutData(gridData);
    gridData = new GridData();
    gridData.verticalAlignment = SWT.TOP;
    comp.setLayoutData(gridData);
    Label l3 = new Label(shell, SWT.NONE);
    l3.setText("String_Node_Str");
    gridData = new GridData();
    gridData.verticalAlignment = SWT.FILL;
    l3.setLayoutData(gridData);
    shell.pack();
    Point shellSize = shell.getSize();
    ;
    parent.setSize(shellSize.x + 30, shellSize.y + 30);
    System.out.println("String_Node_Str" + parent.getLocation().toString());
    System.out.println("String_Node_Str" + parent.getSize().toString());
    System.out.println("String_Node_Str" + topshell.getLocation().toString());
    System.out.println("String_Node_Str" + topshell.getSize().toString());
    parent.update();
    if (this.location != null) {
        parent.setLocation(this.location);
    }
    parent.open();
    System.out.println("String_Node_Str");
}

Output:
     Shell topshell = UIHelper.getShellProvider().getShell();
-    parent = new Shell(topshell, SWT.SHELL_TRIM);
-    parent.setText(windowTitle);
-    Composite shell = new Composite(parent, SWT.NONE);
+    windowShell = new Shell(topshell, SWT.SHELL_TRIM);
+    windowShell.setText(windowTitle);
+    Composite shell = new Composite(windowShell, SWT.NONE);
     GridLayout gridLayout = new GridLayout(3, false);


Input:
public boolean isReady() throws PtalonRuntimeException {
    for (String portName : _unknownLeftSides.keySet()) {
        if (evaluateString(_unknownLeftSides.get(portName)) == null) {
            return false;
        }
    }
    for (String portName : _unknownExpressions.keySet()) {
        if (evaluateString(_unknownExpressions.get(portName)) == null) {
            return false;
        }
    }
    try {
        if (getType(_symbol).equals("String_Node_Str")) {
            PtalonParameter param = _actor.getPtalonParameter(_symbol);
            if (!param.hasValue()) {
                return false;
            }
        } else if (!(getType(_symbol).equals("String_Node_Str") || getType(_symbol).equals("String_Node_Str"))) {
            throw new PtalonRuntimeException("String_Node_Str" + _symbol);
        }
        for (String bool : _boolParams) {
            PtalonBoolParameter param = (PtalonBoolParameter) _actor.getAttribute(getMappedName(bool));
            if (!param.hasValue()) {
                return false;
            }
        }
        for (String integer : _intParams) {
            PtalonIntParameter param = (PtalonIntParameter) _actor.getAttribute(getMappedName(integer));
            if (!param.hasValue()) {
                return false;
            }
        }
        for (ActorTree child : _children) {
            if (!child.isReady()) {
                return false;
            }
        }
        return true;
    } catch (Exception e) {
        throw new PtalonRuntimeException("String_Node_Str");
    }
}

Output:
     try {
-        if (getType(_symbol).equals("String_Node_Str")) {
+        if (_getType(_symbol).equals("String_Node_Str")) {
             PtalonParameter param = _actor.getPtalonParameter(_symbol);


Input:
protected void populateViewContext(String path, PortletRequest portletRequest, PortletResponse portletResponse, Template template, TemplateHashModel staticModels) throws Exception {
    ThemeDisplay themeDisplay = (ThemeDisplay) portletRequest.getAttribute(WebKeys.THEME_DISPLAY);
    PortletPreferences portletPreferences = portletRequest.getPreferences();
    long assetEntryIdDefault = GetterUtil.getLong(portletPreferences.getValue("String_Node_Str", null));
    boolean contentDefaultValue = GetterUtil.getBoolean(portletPreferences.getValue("String_Node_Str", null));
    if (Validator.isNull(path) || path.equals(CampaignContentDisplayPath.VIEW)) {
        CampaignQueryRule queryRule = null;
        long[] userSegmentIds = (long[]) portletRequest.getAttribute(WebKeys.USER_SEGMENT_IDS);
        if (userSegmentIds != null) {
            long[] groupIds = ContentTargetingUtil.getAncestorsAndCurrentGroupIds(themeDisplay.getSiteGroupId());
            Campaign campaign = _campaignLocalService.fetchCurrentMaxPriorityCampaign(groupIds, userSegmentIds);
            if (campaign != null) {
                queryRule = CampaignQueryRuleUtil.match(campaign.getCampaignId(), portletPreferences, themeDisplay.getLocale());
                template.put("String_Node_Str", Campaign.class.getName());
                template.put("String_Node_Str", campaign.getCampaignId());
                template.put("String_Node_Str", campaign.getGroupId());
            }
        }
        boolean isMatchingRule = false;
        if ((queryRule != null) || (contentDefaultValue && (assetEntryIdDefault > 0))) {
            isMatchingRule = true;
            long assetEntryId = assetEntryIdDefault;
            if (queryRule != null) {
                assetEntryId = queryRule.getAssetEntryId();
            }
            AssetEntry assetEntry = AssetEntryLocalServiceUtil.fetchAssetEntry(assetEntryId);
            AssetRendererFactory assetRendererFactory = AssetRendererFactoryRegistryUtil.getAssetRendererFactoryByClassName(assetEntry.getClassName());
            AssetRenderer assetRenderer = assetRendererFactory.getAssetRenderer(assetEntry.getClassPK());
            portletRequest.setAttribute("String_Node_Str", new ArrayList());
            portletRequest.setAttribute("String_Node_Str", new Integer(0));
            portletRequest.setAttribute("String_Node_Str", assetEntry);
            portletRequest.setAttribute("String_Node_Str", assetRendererFactory);
            portletRequest.setAttribute("String_Node_Str", assetRenderer);
            portletRequest.setAttribute("String_Node_Str", assetEntry.getTitle(themeDisplay.getLocale()));
            portletRequest.setAttribute("String_Node_Str", new Boolean(false));
            portletRequest.setAttribute("String_Node_Str", new Boolean(false));
            template.put("String_Node_Str", assetEntry.getClassName());
            template.put("String_Node_Str", assetEntry.getClassPK());
        } else {
            portletRequest.setAttribute(WebKeys.PORTLET_CONFIGURATOR_VISIBILITY, Boolean.TRUE);
        }
        template.put("String_Node_Str", isMatchingRule);
        template.put("String_Node_Str", LiferayWindowState.POP_UP);
    } else if (path.equals(CampaignContentDisplayPath.EDIT_QUERY_RULE) || path.equals(CampaignContentDisplayPath.CONFIGURATION)) {
        template.put("String_Node_Str", getSelectableAssetRendererFactories(themeDisplay.getCompanyId()));
        String assetImageDefault = StringPool.BLANK;
        String assetTitleDefault = StringPool.BLANK;
        String assetTypeDefault = StringPool.BLANK;
        if (assetEntryIdDefault > 0) {
            AssetEntry assetEntry = AssetEntryLocalServiceUtil.fetchAssetEntry(assetEntryIdDefault);
            AssetRendererFactory assetRendererFactory = AssetRendererFactoryRegistryUtil.getAssetRendererFactoryByClassName(assetEntry.getClassName());
            AssetRenderer assetRenderer = assetRendererFactory.getAssetRenderer(assetEntry.getClassPK());
            assetImageDefault = assetRenderer.getThumbnailPath(portletRequest);
            assetTitleDefault = assetRenderer.getTitle(themeDisplay.getLocale());
            assetTypeDefault = assetRendererFactory.getTypeName(themeDisplay.getLocale(), true);
        }
        List<Campaign> campaigns = _campaignService.getCampaigns(themeDisplay.getScopeGroupId());
        template.put("String_Node_Str", campaigns);
        template.put("String_Node_Str", assetEntryIdDefault);
        template.put("String_Node_Str", assetImageDefault);
        template.put("String_Node_Str", assetTitleDefault);
        template.put("String_Node_Str", assetTypeDefault);
        template.put("String_Node_Str", contentDefaultValue);
        template.put("String_Node_Str", LiferayWindowState.EXCLUSIVE);
        template.put("String_Node_Str", portletPreferences);
        int[] queryRulesIndexes = GetterUtil.getIntegerValues(portletPreferences.getValues("String_Node_Str", null), new int[] { 0 });
        template.put("String_Node_Str", queryRulesIndexes);
        template.put("String_Node_Str", staticModels.get("String_Node_Str" + "String_Node_Str"));
        template.put("String_Node_Str", staticModels.get("String_Node_Str" + "String_Node_Str"));
    }
}

Output:
         template.put("String_Node_Str", portletPreferences);
-        int[] queryRulesIndexes = GetterUtil.getIntegerValues(portletPreferences.getValues("String_Node_Str", null), new int[] { 0 });
+        int[] queryRulesIndexes = GetterUtil.getIntegerValues(portletPreferences.getValues("String_Node_Str", null), new int[0]);
         template.put("String_Node_Str", queryRulesIndexes);


Input:
public PostGISDB get(String name, Config config, Map<String, String> runtimeParams) throws ConfigurationException {
    try {
        if (PostGISDB.instance != null) {
            Map<String, Object> params = Maps.newHashMap();
            ConfigObject cObject = config.root();
            for (String key : cObject.keySet()) {
                params.put(key, cObject.get(key).unwrapped());
            }
            PostGISDB.instance = new PostGISDB(params);
        }
        return PostGISDB.instance;
    } catch (DaoException e) {
        throw new ConfigurationException(e);
    }
}

Output:
     try {
-        if (PostGISDB.instance != null) {
+        if (PostGISDB.instance == null) {
             Map<String, Object> params = Maps.newHashMap();


Input:
public void writeFromObjectIntoRow(Object object, AbstractRecord row, AbstractSession session, WriteType writeType) throws DescriptorException {
    if (this.isReadOnly()) {
        return;
    }
    Object attributeValue = getAttributeValueFromObject(object);
    List<XMLEntry> nestedRows = new ArrayList<XMLEntry>();
    XMLRecord record = (XMLRecord) row;
    ContainerPolicy cp = getContainerPolicy();
    Object iterator = cp.iteratorFor(attributeValue);
    if (null != iterator) {
        while (cp.hasNext(iterator)) {
            Object value = cp.next(iterator, session);
            if (null != converter) {
                if (converter instanceof XMLConverter) {
                    value = ((XMLConverter) converter).convertObjectValueToDataValue(value, session, record.getMarshaller());
                } else {
                    value = converter.convertObjectValueToDataValue(value, session);
                }
            }
            NodeValue associatedNodeValue = null;
            XMLField associatedField = null;
            Object fieldValue = value;
            if (value instanceof XMLRoot) {
                XMLRoot rootValue = (XMLRoot) value;
                String localName = rootValue.getLocalName();
                String namespaceUri = rootValue.getNamespaceURI();
                fieldValue = rootValue.getObject();
                associatedField = getFieldForName(localName, namespaceUri);
                if (associatedField == null) {
                    associatedField = getClassToFieldMappings().get(fieldValue.getClass());
                }
            } else {
                associatedField = getClassToFieldMappings().get(value.getClass());
            }
            if (associatedField == null) {
                List<XMLField> sourceFields = classToSourceFieldsMappings.get(value.getClass());
                if (sourceFields != null && sourceFields.size() > 0) {
                    DatabaseMapping xmlMapping = (DatabaseMapping) this.choiceElementMappings.get(sourceFields.get(0));
                    for (XMLField next : sourceFields) {
                        fieldValue = ((XMLCollectionReferenceMapping) xmlMapping).buildFieldValue(value, next, session);
                        XMLEntry entry = new XMLEntry();
                        entry.setValue(fieldValue);
                        entry.setXMLField(next);
                        nestedRows.add(entry);
                    }
                }
            } else {
                DatabaseMapping xmlMapping = (DatabaseMapping) this.choiceElementMappings.get(associatedField);
                if (xmlMapping.isAbstractCompositeCollectionMapping()) {
                    fieldValue = ((XMLCompositeCollectionMapping) xmlMapping).buildCompositeRow(fieldValue, session, row, writeType);
                }
                XMLEntry entry = new XMLEntry();
                entry.setValue(fieldValue);
                entry.setXMLField(associatedField);
                nestedRows.add(entry);
            }
        }
    }
    ((DOMRecord) row).put(getFields(), nestedRows);
}

Output:
     XMLRecord record = (XMLRecord) row;
-    ContainerPolicy cp = getContainerPolicy();
-    Object iterator = cp.iteratorFor(attributeValue);
-    if (null != iterator) {
-        while (cp.hasNext(iterator)) {
-            Object value = cp.next(iterator, session);
-            if (null != converter) {
-                if (converter instanceof XMLConverter) {
-                    value = ((XMLConverter) converter).convertObjectValueToDataValue(value, session, record.getMarshaller());
+    if (null != attributeValue) {
+        ContainerPolicy cp = getContainerPolicy();
+        Object iterator = cp.iteratorFor(attributeValue);
+        if (null != iterator) {
+            while (cp.hasNext(iterator)) {
+                Object value = cp.next(iterator, session);
+                if (null != converter) {
+                    if (converter instanceof XMLConverter) {
+                        value = ((XMLConverter) converter).convertObjectValueToDataValue(value, session, record.getMarshaller());
+                    } else {
+                        value = converter.convertObjectValueToDataValue(value, session);
+                    }
+                }
+                NodeValue associatedNodeValue = null;
+                XMLField associatedField = null;
+                Object fieldValue = value;
+                if (value instanceof XMLRoot) {
+                    XMLRoot rootValue = (XMLRoot) value;
+                    String localName = rootValue.getLocalName();
+                    String namespaceUri = rootValue.getNamespaceURI();
+                    fieldValue = rootValue.getObject();
+                    associatedField = getFieldForName(localName, namespaceUri);
+                    if (associatedField == null) {
+                        associatedField = getClassToFieldMappings().get(fieldValue.getClass());
+                    }
                 } else {


Input:
public void propertyChanged(Object source, int propId) {
    if (getEditor(2).isDirty()) {
        getProcess().setProcessModified(true);
        getProcess().setNeedRegenerateCode(true);
    }
}

Output:
 public void propertyChanged(Object source, int propId) {
-    if (getEditor(2).isDirty()) {
+    if (source instanceof IEditorPart && ((IEditorPart) source).isDirty()) {
         getProcess().setProcessModified(true);


Input:
public File recordSplitPoints(JProgram jprogram, File workDir, int permutationId, TreeLogger logger) {
    logger = logger.branch(TreeLogger.INFO, "String_Node_Str");
    File splitPointsFile = new File(workDir, "String_Node_Str" + Integer.toString(permutationId) + "String_Node_Str");
    try {
        stream = new FileOutputStream(splitPointsFile, true);
        writer = new OutputStreamWriter(new GZIPOutputStream(stream), "String_Node_Str");
        splitPointsFile.getParentFile().mkdirs();
        pw = new PrintWriter(writer);
        htmlOut = new HtmlTextOutput(pw, false);
        String curLine = "String_Node_Str";
        htmlOut.printRaw(curLine);
        htmlOut.newline();
        curLine = "String_Node_Str";
        htmlOut.printRaw(curLine);
        htmlOut.newline();
        htmlOut.indentIn();
        htmlOut.indentIn();
        Map<Integer, String> splitPointMap = jprogram.getSplitPointMap();
        if (splitPointMap.size() > 0) {
            curLine = "String_Node_Str";
            htmlOut.printRaw(curLine);
            htmlOut.newline();
            htmlOut.indentIn();
            htmlOut.indentIn();
            for (Integer splitPointCount : splitPointMap.keySet()) {
                curLine = "String_Node_Str" + splitPointCount + "String_Node_Str" + splitPointMap.get(splitPointCount) + "String_Node_Str";
                htmlOut.printRaw(curLine);
                htmlOut.newline();
            }
            htmlOut.indentOut();
            htmlOut.indentOut();
            curLine = "String_Node_Str";
            htmlOut.printRaw(curLine);
            htmlOut.newline();
        }
        htmlOut.indentOut();
        htmlOut.indentOut();
        curLine = "String_Node_Str";
        htmlOut.printRaw(curLine);
        htmlOut.newline();
        Utility.close(writer);
        pw.close();
        logger.log(TreeLogger.INFO, "String_Node_Str");
    } catch (Throwable e) {
        logger.log(TreeLogger.ERROR, "String_Node_Str", e);
    }
    return splitPointsFile;
}

Output:
             htmlOut.indentIn();
-            for (Integer splitPointCount : splitPointMap.keySet()) {
-                curLine = "String_Node_Str" + splitPointCount + "String_Node_Str" + splitPointMap.get(splitPointCount) + "String_Node_Str";
+            for (Map.Entry<Integer, String> entry : splitPointMap.entrySet()) {
+                Integer splitPointCount = entry.getKey();
+                curLine = "String_Node_Str" + splitPointCount + "String_Node_Str" + entry.getValue() + "String_Node_Str";
                 htmlOut.printRaw(curLine);


Input:
private void createNormalStatements(IR ir, Map<CGNode, OrdinalSet<PointerKey>> ref) {
    SSAInstruction[] instructions = ir.getInstructions();
    for (int i = 0; i < instructions.length; i++) {
        SSAInstruction s = instructions[i];
        if (s instanceof SSAGetCaughtExceptionInstruction) {
            continue;
        }
        if (s != null) {
            delegate.addNode(new NormalStatement(node, i));
        }
        if (s instanceof SSAAbstractInvokeInstruction) {
            addParamPassingStatements(i, ref, ir);
        }
    }
}

Output:
         if (s != null) {
-            delegate.addNode(new NormalStatement(node, i));
-        }
-        if (s instanceof SSAAbstractInvokeInstruction) {
-            addParamPassingStatements(i, ref, ir);
+            final NormalStatement statement = new NormalStatement(node, i);
+            delegate.addNode(statement);
+            if (s instanceof SSAAbstractInvokeInstruction) {
+                callSite2Statement.put(((SSAAbstractInvokeInstruction) s).getCallSite(), statement);
+                addParamPassingStatements(i, ref, ir);
+            }
         }


Input:
public JoinElement getJoinElement() {
    if (joinElement == null) {
        joinElement = RulesFactory.eINSTANCE.createJoinElement();
        joinElement.setOperator(DEFAULT_OPERATOR);
    }
    return joinElement;
}

Output:
         joinElement = RulesFactory.eINSTANCE.createJoinElement();
-        joinElement.setOperator(DEFAULT_OPERATOR);
+        joinElement.setOperator(PluginConstant.DEFAULT_OPERATOR);
     }


Input:
public int getInnerHeight() {
    return mLayoutHeight - mTopPadding;
}

Output:
 public int getInnerHeight() {
-    return mLayoutHeight - mTopPadding;
+    return Math.max(mLayoutHeight - mTopPadding, mLayoutMinHeight);
 }


Input:
private void showCommentForNote(Note note) {
    mEnabledActions = note.getEnabledActions();
    Map<String, JSONObject> actions = note.getActions();
    if (actions.size() > 0) {
        String firstKey = actions.keySet().iterator().next();
        JSONObject jsonAction = actions.get(firstKey);
        JSONObject jsonParams = jsonAction.optJSONObject("String_Node_Str");
        if (jsonParams != null) {
            mRemoteBlogId = jsonParams.optInt("String_Node_Str");
            int commentId = jsonParams.optInt("String_Node_Str");
            int localBlogId = WordPress.wpDB.getLocalTableBlogIdForRemoteBlogId(mRemoteBlogId);
            Comment comment = CommentTable.getComment(localBlogId, commentId);
            if (comment != null) {
                setComment(localBlogId, comment);
            } else {
                requestComment(localBlogId, mRemoteBlogId, commentId);
            }
        }
    } else {
        if (hasActivity())
            ToastUtils.showToast(getActivity(), R.string.reader_toast_err_get_comment, ToastUtils.Duration.LONG);
    }
}

Output:
     mEnabledActions = note.getEnabledActions();
-    Map<String, JSONObject> actions = note.getActions();
-    if (actions.size() > 0) {
-        String firstKey = actions.keySet().iterator().next();
-        JSONObject jsonAction = actions.get(firstKey);
-        JSONObject jsonParams = jsonAction.optJSONObject("String_Node_Str");
-        if (jsonParams != null) {
-            mRemoteBlogId = jsonParams.optInt("String_Node_Str");
-            int commentId = jsonParams.optInt("String_Node_Str");
-            int localBlogId = WordPress.wpDB.getLocalTableBlogIdForRemoteBlogId(mRemoteBlogId);
-            Comment comment = CommentTable.getComment(localBlogId, commentId);
-            if (comment != null) {
-                setComment(localBlogId, comment);
-            } else {
-                requestComment(localBlogId, mRemoteBlogId, commentId);
-            }
-        }
+    mRemoteBlogId = note.getBlogId();
+    long commentId = note.getCommentId();
+    int localBlogId = WordPress.wpDB.getLocalTableBlogIdForRemoteBlogId(mRemoteBlogId);
+    Comment comment = CommentTable.getComment(localBlogId, commentId);
+    if (comment != null) {
+        setComment(localBlogId, comment);
     } else {


Input:
public void doImport(TreeObject[] objs, IProgressMonitor monitor) {
    monitor.beginTask("String_Node_Str", IProgressMonitor.UNKNOWN);
    XtentisPort port = null;
    Reader reader = null;
    try {
        port = Util.getPort((TreeObject) sel.getFirstElement());
    } catch (XtentisException e3) {
        e3.printStackTrace();
    }
    Arrays.sort(objs, new Comparator<Object>() {
        public int compare(Object o1, Object o2) {
            return ((TreeObject) o1).getType() - ((TreeObject) o2).getType();
        }
    });
    for (TreeObject item : objs) {
        String[] subItems;
        switch(item.getType()) {
            case TreeObject.DATA_CLUSTER:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSDataCluster model = new WSDataCluster();
                        model = (WSDataCluster) Unmarshaller.unmarshal(WSDataCluster.class, reader);
                        port.putDataCluster(new WSPutDataCluster(model));
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                    importClusterContents(item, port);
                }
                break;
            case TreeObject.DATA_CLUSTER_CONTENTS:
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSItem wsItem = new WSItem();
                        wsItem = (WSItem) Unmarshaller.unmarshal(WSItem.class, reader);
                        if (wsItem != null) {
                            port.putItem(new WSPutItem(wsItem.getWsDataClusterPK(), wsItem.getContent(), new WSDataModelPK(wsItem.getDataModelName()), true));
                        }
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                break;
            case TreeObject.DATA_MODEL:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSDataModel model = new WSDataModel();
                        model = (WSDataModel) Unmarshaller.unmarshal(WSDataModel.class, reader);
                        port.putDataModel(new WSPutDataModel(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.MENU:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSMenu memu = new WSMenu();
                        memu = (WSMenu) Unmarshaller.unmarshal(WSMenu.class, reader);
                        port.putMenu(new WSPutMenu(memu));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.ROLE:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSRole role = new WSRole();
                        role = (WSRole) Unmarshaller.unmarshal(WSRole.class, reader);
                        port.putRole(new WSPutRole(role));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.ROUTING_RULE:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSRoutingRule routingRule = new WSRoutingRule();
                        routingRule = (WSRoutingRule) Unmarshaller.unmarshal(WSRoutingRule.class, reader);
                        if (routingRule.getWsRoutingRuleExpressions() != null) {
                            for (WSRoutingRuleExpression rule : routingRule.getWsRoutingRuleExpressions()) {
                                if (rule.getWsOperator() == null)
                                    rule.setWsOperator(WSRoutingRuleOperator.CONTAINS);
                            }
                        }
                        port.putRoutingRule(new WSPutRoutingRule(routingRule));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.STORED_PROCEDURE:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSStoredProcedure model = new WSStoredProcedure();
                        model = (WSStoredProcedure) Unmarshaller.unmarshal(WSStoredProcedure.class, reader);
                        port.putStoredProcedure(new WSPutStoredProcedure(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.SYNCHRONIZATIONPLAN:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSSynchronizationPlan model = new WSSynchronizationPlan();
                        model = (WSSynchronizationPlan) Unmarshaller.unmarshal(WSSynchronizationPlan.class, reader);
                        port.putSynchronizationPlan(new WSPutSynchronizationPlan(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.TRANSFORMER:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSTransformer model = new WSTransformer();
                        model = (WSTransformer) Unmarshaller.unmarshal(WSTransformer.class, reader);
                        port.putTransformer(new WSPutTransformer(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.UNIVERSE:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSUniverse model = new WSUniverse();
                        model = (WSUniverse) Unmarshaller.unmarshal(WSUniverse.class, reader);
                        port.putUniverse(new WSPutUniverse(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
            case TreeObject.VIEW:
                monitor.subTask("String_Node_Str");
                subItems = item.getItems();
                for (String subItem : subItems) {
                    try {
                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
                        WSView model = new WSView();
                        model = (WSView) Unmarshaller.unmarshal(WSView.class, reader);
                        if (model.getWhereConditions() != null) {
                            for (WSWhereCondition ws : model.getWhereConditions()) {
                                if (ws.getOperator() == null) {
                                    ws.setOperator(WSWhereOperator.CONTAINS);
                                }
                                if (ws.getStringPredicate() == null) {
                                    ws.setStringPredicate(WSStringPredicate.NONE);
                                }
                            }
                        }
                        port.putView(new WSPutView(model));
                    } catch (Exception e2) {
                        e2.printStackTrace();
                    }
                }
                monitor.worked(1);
                break;
        }
    }
    monitor.done();
}

Output:
             case TreeObject.ROLE:
-                monitor.subTask("String_Node_Str");
-                subItems = item.getItems();
-                for (String subItem : subItems) {
-                    try {
-                        reader = new FileReader(importFolder + "String_Node_Str" + subItem);
-                        WSRole role = new WSRole();
-                        role = (WSRole) Unmarshaller.unmarshal(WSRole.class, reader);
-                        port.putRole(new WSPutRole(role));
-                    } catch (Exception e2) {
-                        e2.printStackTrace();
+                if (Util.IsEnterPrise()) {
+                    monitor.subTask("String_Node_Str");
+                    subItems = item.getItems();
+                    for (String subItem : subItems) {
+                        try {
+                            reader = new FileReader(importFolder + "String_Node_Str" + subItem);
+                            WSRole role = new WSRole();
+                            role = (WSRole) Unmarshaller.unmarshal(WSRole.class, reader);
+                            port.putRole(new WSPutRole(role));
+                        } catch (Exception e2) {
+                            e2.printStackTrace();
+                        }
                     }


Input:
private static CalculatedMember[] extractMeasure(ICubeQueryDefinition queryDefn, Map measureMapping) throws DataException {
    List measureList = queryDefn.getMeasures();
    if (measureList == null)
        return new CalculatedMember[0];
    List measureAggrOns = populateMeasureAggrOns(queryDefn);
    List unreferencedMeasures = getUnreferencedMeasures(queryDefn, measureList, measureMapping, measureAggrOns);
    CalculatedMember[] calculatedMembers1 = new CalculatedMember[unreferencedMeasures.size()];
    int index = 0;
    Iterator measureIter = unreferencedMeasures.iterator();
    while (measureIter.hasNext()) {
        MeasureDefinition measureDefn = (MeasureDefinition) measureIter.next();
        String innerName = OlapExpressionUtil.createMeasureCalculateMemeberName(measureDefn.getName());
        measureMapping.put(measureDefn.getName(), innerName);
        calculatedMembers1[index] = new CalculatedMember(new CubeAggrDefnOnMeasure(innerName, measureDefn.getName(), measureAggrOns, adaptAggrFunction(measureDefn), null, null), 0);
        index++;
    }
    return calculatedMembers1;
}

Output:
         measureMapping.put(measureDefn.getName(), innerName);
-        calculatedMembers1[index] = new CalculatedMember(new CubeAggrDefnOnMeasure(innerName, measureDefn.getName(), measureAggrOns, adaptAggrFunction(measureDefn), null, null), 0);
+        calculatedMembers1[index] = new CalculatedMember(new CubeAggrDefnOnMeasure(innerName, measureDefn.getName(), measureAggrOns, adaptAggrFunction(measureDefn), null, null, null), 0);
         index++;


Input:
public List enabledTransitions(List transitionList) throws IllegalActionException {
    LinkedList enabledTransitions = new LinkedList();
    LinkedList defaultTransitions = new LinkedList();
    Iterator transitionRelations = transitionList.iterator();
    boolean foundUnknown = false;
    while (transitionRelations.hasNext() && !_stopRequested) {
        Transition transition = (Transition) transitionRelations.next();
        if (transition.isDefault()) {
            if (transition.isEnabled()) {
                defaultTransitions.add(transition);
            }
        } else {
            foundUnknown = foundUnknown || !_referencedInputPortsByGuardKnown(transition);
            try {
                if (transition.isEnabled()) {
                    enabledTransitions.add(transition);
                }
            } catch (RuntimeException ex) {
                if (!foundUnknown) {
                    throw ex;
                }
            } catch (IllegalActionException ex) {
                if (!foundUnknown) {
                    throw ex;
                }
            }
        }
    }
    if (enabledTransitions.size() > 0) {
        return enabledTransitions;
    } else {
        if (!foundUnknown) {
            if (defaultTransitions.size() == 0 && _currentState.getRefinement() == null) {
                List<IOPort> outputs = outputPortList();
                for (IOPort port : outputs) {
                    for (int channel = 0; channel < port.getWidth(); channel++) {
                        if (!port.isKnown(channel)) {
                            port.sendClear(channel);
                        }
                    }
                }
            }
            return defaultTransitions;
        }
    }
    return new LinkedList();
}

Output:
     Iterator transitionRelations = transitionList.iterator();
-    boolean foundUnknown = false;
+    _foundUnknown = false;
     while (transitionRelations.hasNext() && !_stopRequested) {


Input:
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler) {
    final ListCalc listCalc = compiler.compileList(call.getArg(0));
    final Calc calc = call.getArgCount() > 1 ? compiler.compileScalar(call.getArg(1), true) : new ValueCalc(call);
    return new AbstractCalc(call) {
        public Object evaluate(Evaluator evaluator) {
            List memberList = evaluateCurrentList(listCalc, evaluator);
            return median(evaluator.push(), memberList, calc);
        }
        public Calc[] getCalcs() {
            return new Calc[] { listCalc, calc };
        }
        public boolean dependsOn(Dimension dimension) {
            return anyDependsButFirst(getCalcs(), dimension);
        }
    };
}

Output:
             List memberList = evaluateCurrentList(listCalc, evaluator);
-            return median(evaluator.push(), memberList, calc);
-        }
-        public Calc[] getCalcs() {
-            return new Calc[] { listCalc, calc };
+    return (Double) median(evaluator.push(), memberList, calc);
         }


Input:
public void loadPluginsFromJar(File file) throws PluginException {
    if (loadedLocations.contains(file.getAbsolutePath())) {
        return;
    }
    LOGGER.debug("String_Node_Str" + file.getAbsolutePath());
    if (!file.isFile()) {
        throw new PluginException("String_Node_Str" + file.getAbsolutePath());
    }
    try {
        FileJarClassLoader jarClassLoader = new FileJarClassLoader(getClass().getClassLoader(), file, new File(tempDir, file.getName()));
        InputStream pluginStream = jarClassLoader.getResourceAsStream("String_Node_Str");
        if (pluginStream == null) {
            throw new PluginException("String_Node_Str");
        }
        PluginDescriptor pluginDescriptor = getPluginDescriptor(pluginStream);
        if (pluginDescriptor == null) {
            throw new PluginException("String_Node_Str");
        }
        LOGGER.debug(pluginDescriptor.toString());
        loadedLocations.add(file.getAbsolutePath());
        loadPlugins(jarClassLoader, file.getAbsolutePath(), file.getAbsolutePath(), pluginDescriptor, PluginSourceType.JAR_FILE);
    } catch (JAXBException e) {
        throw new PluginException(e);
    } catch (FileNotFoundException e) {
        throw new PluginException(e);
    } catch (IOException e) {
        throw new PluginException(e);
    }
}

Output:
     try {
-        FileJarClassLoader jarClassLoader = new FileJarClassLoader(getClass().getClassLoader(), file, new File(tempDir, file.getName()));
+        FileJarClassLoader jarClassLoader = new FileJarClassLoader(getClass().getClassLoader(), file, tempDir);
         InputStream pluginStream = jarClassLoader.getResourceAsStream("String_Node_Str");