Input:
public void write(PacketPlayOutChunkData packet) {
    packet.set("String_Node_Str", location);
    int bitmask;
    int count;
    bitmask = (1 << sections.length) - 1;
    count = sections.length;
    int size = 0;
    int sectionSize = ChunkSection.LENGTH * 5 / 2;
    if (world.getDimension() == Dimension.OVERWORLD) {
        sectionSize += ChunkSection.LENGTH / 2;
    }
    size += count * sectionSize + 256;
    byte[] data = new byte[size];
    int pos = 0;
    for (ChunkSection section : sections) {
        for (byte b : section.getTypes()) {
            data[pos++] = (byte) (b & 0xff);
            data[pos++] = (byte) (b >> 8);
        }
    }
    for (ChunkSection section : sections) {
        System.arraycopy(section.blockLight, 0, data, pos, section.blockLight.length);
        pos += section.blockLight.length;
    }
    for (ChunkSection section : sections) {
        System.arraycopy(section.skyLight, 0, data, pos, section.skyLight.length);
        pos += section.skyLight.length;
    }
    for (int i = 0; i < 256; i += 1) {
        data[pos++] = 0;
    }
    if (pos != size) {
        throw new IllegalStateException("String_Node_Str" + pos + "String_Node_Str" + size + "String_Node_Str");
    }
    packet.set("String_Node_Str", data);
    packet.set("String_Node_Str", true);
    packet.set("String_Node_Str", bitmask);
}

Output:
     packet.set("String_Node_Str", true);
-    packet.set("String_Node_Str", bitmask);
+    packet.set("String_Node_Str", (short) bitmask);
 }


Input:
protected void drawHighlights() {
    if (mHighlightEnabled && valuesToHighlight()) {
        for (int i = 0; i < mIndicesToHightlight.length; i++) {
            int index = mIndicesToHightlight[i];
            if (index < mYVals.size()) {
                float[] pts = new float[] { index, mYChartMax, index, mYChartMin, 0, mYVals.get(index).getVal(), mDeltaX, mYVals.get(index).getVal() };
                transformPointArray(pts);
                mDrawCanvas.drawLines(pts, mHighlightPaint);
            }
        }
    }
}

Output:
             int index = mIndicesToHightlight[i];
-            if (index < mYVals.size()) {
+            if (index < mYVals.size() && index >= 0) {
                 float[] pts = new float[] { index, mYChartMax, index, mYChartMin, 0, mYVals.get(index).getVal(), mDeltaX, mYVals.get(index).getVal() };


Input:
public void handleStatus(SVNStatus status) throws SVNException {
    SVNStatusType s = status.getContentsStatus();
    if (s == SVNStatusType.STATUS_UNVERSIONED || s == SVNStatusType.STATUS_IGNORED || s == SVNStatusType.STATUS_MODIFIED || s == SVNStatusType.STATUS_NONE) {
        listener.getLogger().println("String_Node_Str" + status.getFile());
        try {
            File f = status.getFile();
            if (f.isDirectory())
                FileUtils.deleteDirectory(f);
            else
                f.delete();
        } catch (IOException e) {
            throw new SVNException(SVNErrorMessage.UNKNOWN_ERROR_MESSAGE, e);
        }
    }
}

Output:
                 FileUtils.deleteDirectory(f);
-            else
-                f.delete();
+            else if (!f.delete())
+                throw new IOException("String_Node_Str" + f.getAbsolutePath());
         } catch (IOException e) {


Input:
private boolean namespaceMatches(CacheKey key) {
    return key.getNamespace().equals(namespace);
}

Output:
 private boolean namespaceMatches(CacheKey key) {
-    return key.getNamespace().equals(namespace);
+    return key.getNamespace().equals(resolveNamespace());
 }


Input:
private boolean isDeclaredAsPublishingEvent(QName qname) {
    List<QName> events = internalPortletWindow.getPortletEntity().getPortletDefinition().getPublishingEvents();
    return events != null && events.contains(qname);
}

Output:
     List<QName> events = internalPortletWindow.getPortletEntity().getPortletDefinition().getPublishingEvents();
-    return events != null && events.contains(qname);
+    List<QName> tempEvents = new ArrayList<QName>();
+    if (events == null)
+        return false;
+    for (QName name : events) {
+        if (name.getNamespaceURI() != null && !(name.getNamespaceURI().equals("String_Node_Str")))
+            tempEvents.add(name);
+        else
+            tempEvents.add(new QName(getDefaultEventNamespace(), name.getLocalPart()));
+    }
+    return tempEvents.contains(qname);
 }


Input:
public void testNamedQueryHint() {
    Map<String, String> hints = new HashMap<String, String>();
    hints.put(QueryHints.REFRESH, "String_Node_Str");
    List<StaticUser> users = (List<StaticUser>) restNamedQuery("String_Node_Str", "String_Node_Str", null, null);
    assertTrue("String_Node_Str", users.size() == 3);
    StaticUser user1 = users.get(0);
    String oldName = user1.getName();
    user1.setName("String_Node_Str");
    dbUpdate(user1);
    users = (List<StaticUser>) restNamedQuery("String_Node_Str", "String_Node_Str", null, hints);
    for (StaticUser user : users) {
        if (user.getId() == user1.getId()) {
            assertTrue("String_Node_Str", user.getName().equals(user1.getName()));
        }
    }
    user1 = dbRead(user1.getId(), StaticUser.class);
    user1.setName(oldName);
    dbUpdate(user1);
    hints = new HashMap<String, String>();
    hints.put(QueryHints.REFRESH, "String_Node_Str");
    users = (List<StaticUser>) restNamedQuery("String_Node_Str", "String_Node_Str", null, hints);
}

Output:
     hints.put(QueryHints.REFRESH, "String_Node_Str");
-    List<StaticUser> users = (List<StaticUser>) restNamedQuery("String_Node_Str", "String_Node_Str", null, null);
+    List<StaticUser> users = (List<StaticUser>) restNamedQuery("String_Node_Str", "String_Node_Str", null, hints);
     assertTrue("String_Node_Str", users.size() == 3);


Input:
protected boolean doCommand(IMessageHandler handler, boolean repeat) {
    try {
        CountingMessageHandler counter = new CountingMessageHandler(handler);
        if (counter.hasErrors()) {
            return false;
        }
        AjBuildConfig config = genBuildConfig(savedArgs, counter);
        if (!config.shouldProceed()) {
            return true;
        }
        if (!config.hasSources()) {
            MessageUtil.error(counter, "String_Node_Str");
        }
        if (counter.hasErrors()) {
            String usage = BuildArgParser.getUsage();
            MessageUtil.abort(handler, usage);
            return false;
        }
        return ((repeat ? buildManager.incrementalBuild(config, handler) : buildManager.batchBuild(config, handler)) && !counter.hasErrors());
    } catch (AbortException ae) {
        if (ae.isSilent()) {
            throw ae;
        } else {
            MessageUtil.abort(handler, ABORT_MESSAGE, ae);
        }
    } catch (MissingSourceFileException t) {
        MessageUtil.error(handler, t.getMessage());
    } catch (Throwable t) {
        MessageUtil.abort(handler, ABORT_MESSAGE, t);
    }
    return false;
}

Output:
         }
-        return ((repeat ? buildManager.incrementalBuild(config, handler) : buildManager.batchBuild(config, handler)) && !counter.hasErrors());
+        boolean result = ((repeat ? buildManager.incrementalBuild(config, handler) : buildManager.batchBuild(config, handler)) && !counter.hasErrors());
+        Dump.dumpOnExit();
+        return result;
     } catch (AbortException ae) {


Input:
public void childAdded(final StructuralEvent e) {
    SwingUtilities.invokeLater(new Runnable() {

        public void run() {
            addChild(e.getIndex(), e.getChild());
        }
    });
}

Output:
 public void childAdded(final StructuralEvent e) {
-    SwingUtilities.invokeLater(new Runnable() {
+    executor.execute(new Runnable() {


Input:
public boolean timeout(OrderRequest order) {
    java.util.Date currentDate = new Date();
    return (currentDate.compareTo(order.getMaxTime()) < 0);
}

Output:
     java.util.Date currentDate = new Date();
-    return (currentDate.compareTo(order.getMaxTime()) < 0);
+    java.util.Date date = new Date();
+    date = parseToDate(order.getDay(), order.getMonth(), order.getHour());
+    return (currentDate.compareTo(date) < 0);
 }


Input:
public void open(File file, ManagedDownloader md) throws IOException {
    this.managedDownloader = md;
    File parentFile = FileUtils.getParentFile(file);
    FileUtils.setWriteable(parentFile);
    FileUtils.setWriteable(file);
    this.fos = new RandomAccessFile(file, "String_Node_Str");
}

Output:
     File parentFile = FileUtils.getParentFile(file);
-    FileUtils.setWriteable(parentFile);
+    if (parentFile != null)
+        FileUtils.setWriteable(parentFile);
     FileUtils.setWriteable(file);


Input:
public static Task<String> formatString(final String spec, final Object... args) {
    List<Object> taskArgs = Lists.newArrayList();
    for (Object arg : args) if (arg instanceof Task)
        taskArgs.add(arg);
    return transformMultiple(new Function<List<Object>, String>() {
        public String apply(List<Object> input) {
            Iterator<Object> tri = input.iterator();
            Object[] vv = new Object[args.length];
            int i = 0;
            for (Object arg : args) {
                if (arg instanceof Task)
                    vv[i] = tri.next();
                else
                    vv[i] = arg;
                i++;
            }
            return String.format(spec, vv);
        }
    }, (Task[]) taskArgs.toArray(new Task[taskArgs.size()]));
}

Output:
         }
-    }, (Task[]) taskArgs.toArray(new Task[taskArgs.size()]));
+    }, taskArgs);
 }


Input:
public void mouseExited(MouseEvent e, final TransferData data) {
    hidePopup();
    startHideTimeout();
    this.state = false;
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.TARGET);
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.PAIRED);
    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.SOURCE);
}

Output:
 public void mouseExited(MouseEvent e, final TransferData data) {
-    hidePopup();
-    startHideTimeout();
-    this.state = false;
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.TARGET);
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.PAIRED);
-    ArrowBuilder.removeArrowsByType(ArrowBuilder.Type.SOURCE);
+    hideAll();
 }


Input:
private void saveProjectData(String dirName) {
    if (dirName.charAt(dirName.length() - 1) != File.separatorChar) {
        dirName += File.separator;
    }
    File tempDirFile = new File(dirName);
    tempDirFile.mkdir();
    AUseCase useCase = (AUseCase) GeneralManager.get().getUseCase(EDataDomain.GENETIC_DATA);
    LoadDataParameters parameters = useCase.getLoadDataParameters();
    byte[] data = SetUtils.loadSetFile(parameters);
    String setFileName = dirName + SET_DATA_FILE_NAME;
    File setFile = new File(setFileName);
    SetUtils.saveFile(data, setFile);
    SerializationManager serializationManager = GeneralManager.get().getSerializationManager();
    JAXBContext projectContext = serializationManager.getProjectContext();
    try {
        Marshaller marshaller = projectContext.createMarshaller();
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT_CONTEXT);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.CONTENT_EMBEDDED_HM);
        saveVirtualArray(marshaller, dirName, useCase, EVAType.STORAGE);
        TreePorter treePorter = new TreePorter();
        Tree<ClusterNode> geneTree = useCase.getSet().getClusteredTreeGenes();
        if (geneTree != null) {
            treePorter.exportTree(dirName + GENE_TREE_FILE_NAME, geneTree);
        }
        treePorter = new TreePorter();
        Tree<ClusterNode> expTree = useCase.getSet().getClusteredTreeExps();
        if (expTree != null) {
            treePorter.exportTree(dirName + EXP_TREE_FILE_NAME, expTree);
        }
        File useCaseFile = new File(dirName + USECASE_FILE_NAME);
        marshaller.marshal(useCase, useCaseFile);
    } catch (JAXBException ex) {
        throw new RuntimeException("String_Node_Str", ex);
    } catch (IOException ex) {
        throw new RuntimeException("String_Node_Str", ex);
    }
}

Output:
     LoadDataParameters parameters = useCase.getLoadDataParameters();
-    byte[] data = SetUtils.loadSetFile(parameters);
-    String setFileName = dirName + SET_DATA_FILE_NAME;
-    File setFile = new File(setFileName);
-    SetUtils.saveFile(data, setFile);
+    FileOperations.writeInputStreamToFile(dirName + SET_DATA_FILE_NAME, GeneralManager.get().getResourceLoader().getInputSource(parameters.getFileName()).getByteStream());
     SerializationManager serializationManager = GeneralManager.get().getSerializationManager();


Input:
public boolean marshalSingleValue(XPathFragment xPathFragment, MarshalRecord marshalRecord, Object object, Object value, AbstractSession session, NamespaceResolver namespaceResolver, MarshalContext marshalContext) {
    if (xmlCompositeDirectCollectionMapping.hasValueConverter()) {
        if (xmlCompositeDirectCollectionMapping.getValueConverter() instanceof XMLConverter) {
            value = ((XMLConverter) xmlCompositeDirectCollectionMapping.getValueConverter()).convertObjectValueToDataValue(value, session, marshalRecord.getMarshaller());
        } else {
            value = xmlCompositeDirectCollectionMapping.getValueConverter().convertObjectValueToDataValue(value, session);
        }
    }
    XMLField xmlField = (XMLField) xmlCompositeDirectCollectionMapping.getField();
    if (null != value) {
        QName schemaType = getSchemaType(xmlField, value, session);
        boolean isElementOpen = false;
        if (XMLConstants.QNAME_QNAME.equals(schemaType)) {
            QName fieldValue = (QName) value;
            if (fieldValue.getNamespaceURI() == null || fieldValue.getNamespaceURI().equals("String_Node_Str") && marshalRecord.getNamespaceResolver().getDefaultNamespaceURI() != null) {
                if (namespaceResolver.getDefaultNamespaceURI().equals(xPathFragment.getNamespaceURI()) && xPathFragment.getPrefix() == null) {
                    String prefix = namespaceResolver.generatePrefix();
                    String xPath = prefix + "String_Node_Str" + xPathFragment.getShortName();
                    XPathFragment newFragment = new XPathFragment(xPath);
                    newFragment.setNamespaceURI(namespaceResolver.getDefaultNamespaceURI());
                    newFragment.setNextFragment(xPathFragment.getNextFragment());
                    marshalRecord.openStartElement(newFragment, namespaceResolver);
                    isElementOpen = true;
                    marshalRecord.namespaceDeclaration(prefix, namespaceResolver.getDefaultNamespaceURI());
                    marshalRecord.predicateAttribute(xPathFragment, namespaceResolver);
                    xPathFragment = newFragment;
                }
            }
        }
        if (!isElementOpen) {
            marshalRecord.openStartElement(xPathFragment, namespaceResolver);
        }
        XPathFragment nextFragment = xPathFragment.getNextFragment();
        if (nextFragment != null && nextFragment.isAttribute()) {
            marshalRecord.predicateAttribute(xPathFragment, namespaceResolver);
            marshalRecord.attribute(nextFragment, namespaceResolver, value, schemaType);
            marshalRecord.closeStartElement();
        } else {
            if (xmlField.isTypedTextField()) {
                updateNamespaces(schemaType, marshalRecord, xmlField);
            }
            marshalRecord.closeStartElement();
            marshalRecord.predicateAttribute(xPathFragment, namespaceResolver);
            marshalRecord.characters(schemaType, value, null, xmlCompositeDirectCollectionMapping.isCDATA());
        }
        marshalRecord.endElement(xPathFragment, namespaceResolver);
        return true;
    } else {
        if (xmlCompositeDirectCollectionMapping.getNullPolicy().getMarshalNullRepresentation() != XMLNullRepresentationType.ABSENT_NODE) {
            marshalRecord.openStartElement(xPathFragment, namespaceResolver);
            XPathFragment nextFragment = xPathFragment.getNextFragment();
            xmlCompositeDirectCollectionMapping.getNullPolicy().directMarshal(nextFragment, marshalRecord, object, session, namespaceResolver);
            marshalRecord.endElement(xPathFragment, namespaceResolver);
            return true;
        }
    }
    return false;
}

Output:
                     String prefix = namespaceResolver.generatePrefix();
-                    String xPath = prefix + "String_Node_Str" + xPathFragment.getShortName();
+                    String xPath = prefix + XMLConstants.COLON + xPathFragment.getShortName();
                     XPathFragment newFragment = new XPathFragment(xPath);


Input:
protected void okPressed() {
    if (statusCombo == null) {
        return;
    }
    boolean modified = false;
    String newStatus = null;
    if (getModifiedVersionItems().size() > 0)
        newStatus = statusHelper.getStatusLabel(statusCombo.getText());
    for (RepositoryObject object : getModifiedVersionItems()) {
        if (!isFixedstatus()) {
            newStatus = object.getStatusCode();
        }
        if (object != null && object.getProperty() != null) {
            if (!newStatus.equals(object.getProperty().getOldStatusCode())) {
                isApplied = false;
                modified = true;
                break;
            }
        }
    }
    if (modified) {
        boolean confirm = false;
        if (isFixedstatus()) {
            confirm = MessageDialog.openConfirm(getShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str", newStatus));
            if (confirm) {
                for (RepositoryObject object : getModifiedVersionItems()) {
                    if (techinalButton.getSelection()) {
                        ERepositoryObjectType type = object.getRepositoryNode().getContentType();
                        if (!type.equals(ERepositoryObjectType.DOCUMENTATION) && !type.equals(ERepositoryObjectType.BUSINESS_PROCESS)) {
                            object.setStatusCode(newStatus);
                        }
                    } else {
                        ERepositoryObjectType type = object.getRepositoryNode().getContentType();
                        if (type.equals(ERepositoryObjectType.DOCUMENTATION) || type.equals(ERepositoryObjectType.BUSINESS_PROCESS)) {
                            object.setStatusCode(newStatus);
                        }
                    }
                }
            }
        } else {
            StatusConfirmSettingDialog chanedDialog = new StatusConfirmSettingDialog(getShell(), getModifiedVersionItems(), statusHelper);
            confirm = (chanedDialog.open() == Window.OK);
        }
        if (confirm) {
            updateItemsVersion();
        }
    } else {
        if (!getModifiedVersionItems().isEmpty() && !isApplied) {
            MessageDialog.openWarning(getShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
        }
    }
}

Output:
     if (getModifiedVersionItems().size() > 0)
-        newStatus = statusHelper.getStatusLabel(statusCombo.getText());
+        newStatus = statusHelper.getStatusCode(statusCombo.getText());
     for (RepositoryObject object : getModifiedVersionItems()) {


Input:
public void removeRoleFromPrincipal(HttpRequest httpRequest, HttpResponder httpResponder, String principalType, String principalName, String roleName) throws Exception {
    ensureSecurityEnabled();
    authorizerInstantiatorService.get().removeRoleFromPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
    httpResponder.sendStatus(HttpResponseStatus.OK);
    createLogEntry(httpRequest, null, HttpResponseStatus.OK);
}

Output:
     ensureSecurityEnabled();
-    authorizerInstantiatorService.get().removeRoleFromPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
+    authorizerInstantiator.get().removeRoleFromPrincipal(new Role(roleName), new Principal(principalName, Principal.PrincipalType.valueOf(principalType.toUpperCase())));
     httpResponder.sendStatus(HttpResponseStatus.OK);


Input:
public void igualaImagem(BufferedImage buffer) {
    buffer = new BufferedImage((int) w, (int) h, BufferedImage.TYPE_INT_ARGB);
    buffer.getGraphics().drawImage(buffer, 0, 0, null);
    w = buffer.getWidth();
    h = buffer.getHeight();
    resetImage();
}

Output:
 public void igualaImagem(BufferedImage buffer) {
-    buffer = new BufferedImage((int) w, (int) h, BufferedImage.TYPE_INT_ARGB);
-    buffer.getGraphics().drawImage(buffer, 0, 0, null);
+    this.buffer = new BufferedImage((int) w, (int) h, BufferedImage.TYPE_INT_ARGB);
+    this.buffer.getGraphics().drawImage(buffer, 0, 0, null);
     w = buffer.getWidth();


Input:
public ActionResult<ItemStack> onItemRightClick(ItemStack itemStack, World world, EntityPlayer player, EnumHand hand) {
    if (world.isRemote || !(player instanceof EntityPlayerMP)) {
        return super.onItemRightClick(itemStack, world, player, hand);
    }
    RayTraceResult trace = player.rayTrace(4.5d, 0.0f);
    if (trace == null || trace.getBlockPos() == null) {
        return super.onItemRightClick(itemStack, world, player, hand);
    }
    TileEntity te = world.getTileEntity(trace.getBlockPos());
    if (te != null && te.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, trace.sideHit)) {
        IFluidHandler fluidHandler = world.getTileEntity(trace.getBlockPos()).getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, trace.sideHit);
        if (fluidHandler.fill(new FluidStack(Fluidss.miniaturizationFluid, 125), false) == 125) {
            fluidHandler.fill(new FluidStack(Fluidss.miniaturizationFluid, 125), true);
            itemStack.stackSize--;
            return new ActionResult(EnumActionResult.SUCCESS, itemStack);
        }
    }
    return super.onItemRightClick(itemStack, world, player, hand);
}

Output:
     }
-    RayTraceResult trace = player.rayTrace(4.5d, 0.0f);
+    Vec3d eyeVec = new Vec3d(player.posX, player.posY + (double) player.getEyeHeight(), player.posZ);
+    Vec3d lookVec = player.getLook(0.0f);
+    Vec3d maxVec = eyeVec.addVector(lookVec.xCoord * 4.5d, lookVec.yCoord * 4.5d, lookVec.zCoord * 4.5d);
+    RayTraceResult trace = world.rayTraceBlocks(eyeVec, maxVec, false, false, true);
     if (trace == null || trace.getBlockPos() == null) {


Input:
public void nextMove() {
    synchronized (this) {
        BoardHistoryNode oldHead = history.getHead();
        if (history.next() != null) {
            observerCollection.headMoved(oldHead, history.getHead());
            if (history.getData().getLastMove() == null) {
                leelazExecutor.execute(() -> {
                    Lizzie.leelaz.playMove(history.getLastMoveColor(), "String_Node_Str");
                    Lizzie.leelaz.ponder();
                });
            } else {
                leelazExecutor.execute(() -> {
                    Lizzie.leelaz.playMove(history.getLastMoveColor(), convertCoordinatesToName(history.getLastMove()[0], history.getLastMove()[1]));
                    Lizzie.leelaz.ponder();
                });
            }
        }
    }
}

Output:
                 leelazExecutor.execute(() -> {
-                    Lizzie.leelaz.playMove(history.getLastMoveColor(), "String_Node_Str");
+                    Lizzie.leelaz.playMove(colorToPlay, "String_Node_Str");
                     Lizzie.leelaz.ponder();


Input:
public final char nextChar() {
    if (length == -1) {
        throwEOFException();
    }
    char ch = buffer[i - 1];
    if (i >= length) {
        updateBuffer();
    }
    i++;
    if (lineSeparator1 == ch && (lineSeparator2 == '\0' || length != -1 && lineSeparator2 == buffer[i - 1])) {
        lineCount++;
        if (lineSeparator2 != '\0') {
            ch = normalizedLineSeparator;
            if (i >= length) {
                if (length != -1) {
                    updateBuffer();
                } else {
                    throwEOFException();
                }
            }
            if (i < length) {
                i++;
            }
        } else {
            return normalizedLineSeparator;
        }
    }
    return ch;
}

Output:
         lineCount++;
-        if (lineSeparator2 != '\0') {
-            ch = normalizedLineSeparator;
-            if (i >= length) {
-                if (length != -1) {
-                    updateBuffer();
-                } else {
-                    throwEOFException();
+        if (normalizeLineEndings) {
+            if (lineSeparator2 != '\0') {
+                ch = normalizedLineSeparator;
+                if (i >= length) {
+                    if (length != -1) {
+                        updateBuffer();
+                    } else {
+                        throwEOFException();
+                    }
                 }


Input:
public void generateBlogViews() throws Exception {
    log.debug("String_Node_Str");
    long threeMonthsAgo = DateTime.now().minusMonths(3).getMillis();
    blogViewWriteRepository.clear(threeMonthsAgo);
    List<Blog> blogs = blogReadRepository.findAfterTime(threeMonthsAgo);
    long now = DateTime.now().getMillis();
    List<BlogView> blogViews = Lists.newArrayList();
    for (Blog blog : blogs) {
        Long blogId = blog.getId();
        Long blogTime = blog.getTime();
        int preView = blog.getView();
        String link = blog.getLink();
        int total = DbaUtil.isCsdn(link) ? csdnFetcher.fetchView(link) : iteyeFetcher.fetchView(link);
        if (total == -1)
            continue;
        int increment = blogViewReadRepository.findByBlogId(blogId).isEmpty() ? total : (total - preView);
        blogViews.add(new BlogView(blogId, total, increment, blogTime, now));
    }
    log.debug(format("String_Node_Str", blogViews));
    blogViewWriteRepository.save(blogViews);
    log.debug("String_Node_Str");
}

Output:
             continue;
-        int increment = blogViewReadRepository.findByBlogId(blogId).isEmpty() ? total : (total - preView);
+        List<BlogView> existBlogViews = blogViewReadRepository.findByBlogId(blogId);
+        int increment = existBlogViews.isEmpty() ? total : total - existBlogViews.get(existBlogViews.size() - 1).getTotal();
+        log.debug(format("String_Node_Str", blogId, total, increment));
         blogViews.add(new BlogView(blogId, total, increment, blogTime, now));


Input:
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
    tvX.setText("String_Node_Str" + (mSeekBarX.getProgress() + 1));
    tvY.setText("String_Node_Str" + (mSeekBarY.getProgress()));
    ArrayList<String> xVals = new ArrayList<String>();
    for (int i = 0; i < mSeekBarX.getProgress() + 1; i++) {
        xVals.add(mMonths[i % 12]);
    }
    ArrayList<Entry> yVals1 = new ArrayList<Entry>();
    for (int i = 0; i < mSeekBarX.getProgress() + 1; i++) {
        float mult = (mSeekBarY.getProgress() + 1);
        float val = (float) (Math.random() * mult) + 3;
        yVals1.add(new Entry(val, i));
    }
    BarDataSet set1 = new BarDataSet(yVals1, "String_Node_Str");
    set1.setBarSpacePercent(35f);
    ArrayList<BarDataSet> dataSets = new ArrayList<BarDataSet>();
    dataSets.add(set1);
    BarData data = new BarData(xVals, dataSets);
    mChart.setData(data);
    mChart.invalidate();
}

Output:
         float mult = (mSeekBarY.getProgress() + 1);
-        float val = (float) (Math.random() * mult) + 3;
+        float val = (float) (Math.random() * mult) - 50;
         yVals1.add(new Entry(val, i));


Input:
private String _getModelReferences(String p_strModelName) throws DBExecutionException {
    String strReference = "String_Node_Str";
    try {
        if (_xmlContainer == null) {
            throw new DBExecutionException("String_Node_Str" + "String_Node_Str");
        }
        if (_xmlManager == null) {
            throw new DBExecutionException("String_Node_Str" + "String_Node_Str");
        }
        XmlQueryContext xmlContext = _xmlManager.createQueryContext();
        if (xmlContext == null) {
            throw new DBExecutionException("String_Node_Str" + "String_Node_Str");
        }
        String strQuery = "String_Node_Str" + _xmlContainer.getName() + "String_Node_Str" + p_strModelName + "String_Node_Str";
        XmlQueryExpression queryExpression = _xmlManager.prepare(strQuery, xmlContext);
        if (queryExpression == null) {
            throw new DBExecutionException("String_Node_Str" + "String_Node_Str");
        }
        XmlResults results = queryExpression.execute(xmlContext);
        if (results != null && results.size() > 0) {
            XmlValue result = results.next();
            strReference = result.asString();
        }
        return strReference;
    } catch (XmlException e) {
        throw new DBExecutionException("String_Node_Str" + e.getMessage(), e);
    }
}

Output:
         }
-        String strQuery = "String_Node_Str" + _xmlContainer.getName() + "String_Node_Str" + p_strModelName + "String_Node_Str";
+        String strQuery = "String_Node_Str" + _xmlContainer.getName() + "String_Node_Str" + "String_Node_Str" + p_strModelName + "String_Node_Str";
         XmlQueryExpression queryExpression = _xmlManager.prepare(strQuery, xmlContext);


Input:
private void updatePresentationDisplays(int changedDisplayId) {
    final Display[] displays = getAllPresentationDisplays();
    final int count = mRoutes.size();
    for (int i = 0; i < count; i++) {
        final RouteInfo info = mRoutes.get(i);
        Display display = choosePresentationDisplayForRoute(info, displays);
        if (display != info.mPresentationDisplay || (display != null && display.getDisplayId() == changedDisplayId)) {
            info.mPresentationDisplay = display;
            dispatchRoutePresentationDisplayChanged(info);
        }
    }
}

Output:
     for (int i = 0; i < count; i++) {
-        final RouteInfo info = mRoutes.get(i);
-        Display display = choosePresentationDisplayForRoute(info, displays);
-        if (display != info.mPresentationDisplay || (display != null && display.getDisplayId() == changedDisplayId)) {
-            info.mPresentationDisplay = display;
-            dispatchRoutePresentationDisplayChanged(info);
+        final RouteInfo route = mRoutes.get(i);
+        if (route.updatePresentationDisplay() || (route.mPresentationDisplay != null && route.mPresentationDisplay.getDisplayId() == changedDisplayId)) {
+            dispatchRoutePresentationDisplayChanged(route);
         }


Input:
public void resetAllModes() {
    mContext.enforcePermission(android.Manifest.permission.UPDATE_APP_OPS_STATS, Binder.getCallingPid(), Binder.getCallingUid(), null);
    HashMap<Callback, ArrayList<Pair<String, Integer>>> callbacks = null;
    synchronized (this) {
        boolean changed = false;
        for (int i = mUidOps.size() - 1; i >= 0; i--) {
            HashMap<String, Ops> packages = mUidOps.valueAt(i);
            Iterator<Map.Entry<String, Ops>> it = packages.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<String, Ops> ent = it.next();
                String packageName = ent.getKey();
                Ops pkgOps = ent.getValue();
                for (int j = pkgOps.size() - 1; j >= 0; j--) {
                    Op curOp = pkgOps.valueAt(j);
                    if (curOp.mode != AppOpsManager.opToDefaultMode(curOp.op)) {
                        curOp.mode = AppOpsManager.opToDefaultMode(curOp.op);
                        changed = true;
                        callbacks = addCallbacks(callbacks, packageName, curOp.op, mOpModeWatchers.get(curOp.op));
                        callbacks = addCallbacks(callbacks, packageName, curOp.op, mPackageModeWatchers.get(packageName));
                        if (curOp.time == 0 && curOp.rejectTime == 0) {
                            pkgOps.removeAt(j);
                        }
                    }
                }
                if (pkgOps.size() == 0) {
                    it.remove();
                }
            }
            if (packages.size() == 0) {
                mUidOps.removeAt(i);
            }
        }
        if (changed) {
            scheduleWriteNowLocked();
        }
    }
    if (callbacks != null) {
        for (Map.Entry<Callback, ArrayList<Pair<String, Integer>>> ent : callbacks.entrySet()) {
            Callback cb = ent.getKey();
            ArrayList<Pair<String, Integer>> reports = ent.getValue();
            for (int i = 0; i < reports.size(); i++) {
                Pair<String, Integer> rep = reports.get(i);
                try {
                    cb.mCallback.opChanged(rep.second, rep.first);
                } catch (RemoteException e) {
                }
            }
        }
    }
}

Output:
                     Op curOp = pkgOps.valueAt(j);
-                    if (curOp.mode != AppOpsManager.opToDefaultMode(curOp.op)) {
+                    if (AppOpsManager.opAllowsReset(curOp.op) && curOp.mode != AppOpsManager.opToDefaultMode(curOp.op)) {
                         curOp.mode = AppOpsManager.opToDefaultMode(curOp.op);


Input:
public static final void copyDirectoryNonCVS(File from, File to) throws IOFailure {
    if (from.isFile()) {
        try {
            FileUtils.copyFile(from, to);
        } catch (Exception e) {
            throw new IOFailure("String_Node_Str" + from.getAbsolutePath() + "String_Node_Str" + to.getAbsolutePath());
        }
    } else {
        if (from.getName().equals("String_Node_Str")) {
            return;
        }
        if (from.getName().equals("String_Node_Str")) {
            return;
        }
        if (!from.exists()) {
            throw new IOFailure("String_Node_Str" + from);
        }
        if (!from.isDirectory()) {
            throw new IOFailure("String_Node_Str" + from);
        }
        to.mkdir();
        if (!to.exists()) {
            throw new IOFailure("String_Node_Str" + to);
        }
        File[] subfiles = from.listFiles();
        for (int i = 0; i < subfiles.length; i++) {
            copyDirectoryNonCVS(subfiles[i], new File(to, subfiles[i].getName()));
        }
    }
}

Output:
         } catch (Exception e) {
-            throw new IOFailure("String_Node_Str" + from.getAbsolutePath() + "String_Node_Str" + to.getAbsolutePath());
+            throw new IOFailure("String_Node_Str" + from.getAbsolutePath() + "String_Node_Str" + to.getAbsolutePath(), e);
         }


Input:
private LogOperation scanOneRecord() {
    skipHeader();
    byte operation = mappedByteBuffer.get(nextIndex + 1);
    LogOperation logOperation;
    skipKey();
    if (operation == U_OPERATION) {
        long prevKey = getNextLongForUpdate();
        if (nextIndex + primaryKeyDigitNum + 2 < mappedByteBuffer.limit() && mappedByteBuffer.get(nextIndex + primaryKeyDigitNum + 1) == '|' && (mappedByteBuffer.get(nextIndex + primaryKeyDigitNum + 2) == 's' || mappedByteBuffer.get(nextIndex + primaryKeyDigitNum + 2) == 'f' || mappedByteBuffer.get(nextIndex + primaryKeyDigitNum + 2) == 'l')) {
            nextIndex += primaryKeyDigitNum + 1;
            logOperation = new UpdateOperation(prevKey);
            int localIndex = skipFieldName();
            skipField(localIndex);
            getNextBytesIntoTmp();
            ((UpdateOperation) logOperation).addData(localIndex, tmpBuffer);
        } else {
            long curKey = getNextLong();
            logOperation = new UpdateKeyOperation(prevKey, curKey);
        }
    } else if (operation == I_OPERATION) {
        skipNull();
        logOperation = new InsertOperation(getNextLong());
        int localIndex = 0;
        while (mappedByteBuffer.get(nextIndex + 1) != LINE_SPLITTER) {
            skipFieldForInsert(localIndex);
            skipNull();
            getNextBytesIntoTmp();
            ((InsertOperation) logOperation).addData(localIndex, tmpBuffer);
            localIndex++;
        }
    } else {
        logOperation = new DeleteOperation(getNextLong());
        skipNull();
        while (mappedByteBuffer.get(nextIndex + 1) != LINE_SPLITTER) {
            int localIndex = skipFieldName();
            skipField(localIndex);
            skipNull();
        }
    }
    nextIndex += 2;
    return logOperation;
}

Output:
     byte operation = mappedByteBuffer.get(nextIndex + 1);
-    LogOperation logOperation;
+    LogOperation logOperation = null;
+    boolean flag = false;
     skipKey();


Input:
public ContactJabberImpl findContactById(String id) {
    Iterator contactGroups = rootGroup.subgroups();
    ContactJabberImpl result = null;
    while (contactGroups.hasNext()) {
        ContactGroupJabberImpl contactGroup = (ContactGroupJabberImpl) contactGroups.next();
        result = contactGroup.findContact(id);
        if (result != null)
            return result;
    }
    Iterator rootContacts = rootGroup.contacts();
    while (rootContacts.hasNext()) {
        ContactJabberImpl item = (ContactJabberImpl) rootContacts.next();
        if (item.getAddress().equals(id))
            return item;
    }
    return null;
}

Output:
         ContactJabberImpl item = (ContactJabberImpl) rootContacts.next();
-        if (item.getAddress().equals(id))
+        if (item.getAddress().equalsIgnoreCase(id))
             return item;


Input:
private void onClientRequest(ClientRequest request, ClientProxy client) throws InterruptedException {
    RequestId reqId = request.getRequestId();
    Reply lastReply = lastReplies.get(reqId.getClientId());
    boolean newRequest = lastReply == null || reqId.getSeqNumber() > lastReply.getRequestId().getSeqNumber();
    if (newRequest) {
        logger.debug(processDescriptor.logMark_OldBenchmark, "String_Node_Str", request);
        if (USE_FLOW_CONTROL)
            if (!pendingClientProxies.containsKey(reqId))
                pendingRequestsSem.acquire();
        if (client != null)
            pendingClientProxies.put(reqId, client);
        else if (USE_FLOW_CONTROL)
            pendingClientProxies.put(reqId, NULL_CLIENT_PROXY);
        if (paxos.isLeader()) {
            paxos.enqueueRequest(request);
        } else {
            cBatcher.enqueueRequest(request);
        }
    } else {
        if (client == null)
            return;
        if (lastReply.getRequestId().equals(reqId)) {
            client.send(new ClientReply(Result.OK, lastReply.toByteArray()));
        } else {
            String errorMsg = "String_Node_Str" + request.getRequestId() + "String_Node_Str" + lastReply.getRequestId();
            logger.error(errorMsg);
            client.send(new ClientReply(Result.NACK, errorMsg.getBytes()));
        }
    }
}

Output:
             pendingClientProxies.put(reqId, NULL_CLIENT_PROXY);
-        if (paxos.isLeader()) {
+        if (!processDescriptor.indirectConsensus && paxos.isLeader()) {
             paxos.enqueueRequest(request);


Input:
void customizeUIWithResults() {
    mResultContainer.removeAllViews();
    if (isDataEmpty(0) || !(mDatamodels[0] instanceof InsightsPopularModel)) {
        showErrorUI(null);
        return;
    }
    InsightsPopularModel data = (InsightsPopularModel) mDatamodels[0];
    LinearLayout ll = (LinearLayout) getActivity().getLayoutInflater().inflate(R.layout.stats_insights_most_popular_item, (ViewGroup) mResultContainer.getRootView(), false);
    int dayOfTheWeek = data.getHighestDayOfWeek();
    Calendar c = Calendar.getInstance();
    c.setFirstDayOfWeek(Calendar.MONDAY);
    c.setTimeInMillis(System.currentTimeMillis());
    switch(dayOfTheWeek) {
        case 0:
            c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
            break;
        case 1:
            c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
            break;
        case 2:
            c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
            break;
        case 3:
            c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
            break;
        case 4:
            c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            break;
        case 5:
            c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
            break;
        case 6:
            c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
            break;
    }
    DateFormat formatter = new SimpleDateFormat("String_Node_Str");
    final TextView mostPopularDayTextView = (TextView) ll.findViewById(R.id.stats_most_popular_day);
    mostPopularDayTextView.setText(formatter.format(c.getTime()));
    final TextView mostPopularDayPercentTextView = (TextView) ll.findViewById(R.id.stats_most_popular_day_percent);
    mostPopularDayPercentTextView.setText(String.format(getString(R.string.stats_insights_most_popular_percent_weekly_views), data.getHighestDayPercent().intValue()));
    TextView mostPopularHourTextView = (TextView) ll.findViewById(R.id.stats_most_popular_hour);
    DateFormat timeFormat = android.text.format.DateFormat.getTimeFormat(getActivity());
    c.set(Calendar.HOUR_OF_DAY, data.getHighestHour());
    c.set(Calendar.MINUTE, 0);
    mostPopularHourTextView.setText(timeFormat.format(c.getTime()));
    final TextView mostPopularHourPercentTextView = (TextView) ll.findViewById(R.id.stats_most_popular_hour_percent);
    mostPopularHourPercentTextView.setText(String.format(getString(R.string.stats_insights_most_popular_percent_daily_views), data.getHighestHourPercent().intValue()));
    mResultContainer.addView(ll);
}

Output:
     final TextView mostPopularDayPercentTextView = (TextView) ll.findViewById(R.id.stats_most_popular_day_percent);
-    mostPopularDayPercentTextView.setText(String.format(getString(R.string.stats_insights_most_popular_percent_weekly_views), data.getHighestDayPercent().intValue()));
+    mostPopularDayPercentTextView.setText(String.format(getString(R.string.stats_insights_most_popular_percent_weekly_views), roundToInteger(data.getHighestDayPercent())));
     TextView mostPopularHourTextView = (TextView) ll.findViewById(R.id.stats_most_popular_hour);


Input:
protected Control createDialogArea(Composite parent) {
    Composite container1 = (Composite) super.createDialogArea(parent);
    GridLayout gridLayout = (GridLayout) container1.getLayout();
    container1.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
    gridLayout.numColumns = 1;
    Label lblNewLabel_selserver = new Label(container1, SWT.NONE);
    lblNewLabel_selserver.setText(Messages.DeployAllDialog_label_selectserver);
    combo = new Combo(container1, SWT.DROP_DOWN | SWT.READ_ONLY);
    GridData data = new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 2);
    data.widthHint = 400;
    combo.setLayoutData(data);
    final List<MDMServerDef> serverDefs = new ArrayList<MDMServerDef>();
    List<IRepositoryViewObject> viewObjects = ServerDefService.getAllServerDefViewObjects();
    List<String> itemsLabel = new ArrayList<String>();
    for (IRepositoryViewObject object : viewObjects) {
        if (object instanceof IRepositoryObject) {
            MDMServerDefItem mdmItem = getMDMItem((IRepositoryViewObject) object);
            if (mdmItem != null) {
                MDMServerDef serverDef = mdmItem.getServerDef();
                String label = serverDef.getName() + "String_Node_Str" + serverDef.getHost() + "String_Node_Str";
                itemsLabel.add(label);
                serverDefs.add(serverDef);
            }
        }
    }
    int size = itemsLabel.size();
    combo.setItems((String[]) itemsLabel.toArray(new String[size]));
    combo.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            theServerDef = serverDefs.get(combo.getSelectionIndex());
        }
    });
    if (comboServerName != null && comboServerName.trim().length() > 0) {
        for (int index = 0; index < serverDefs.size(); index++) {
            if (serverDefs.get(index).getName().equals(comboServerName)) {
                combo.select(index);
                theServerDef = serverDefs.get(index);
            }
        }
    } else {
        if (serverDefs.size() > 0) {
            combo.select(0);
            theServerDef = serverDefs.get(0);
        }
    }
    Composite container = new Composite(container1, SWT.BORDER);
    container.setLayout(new GridLayout(2, false));
    container.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
    Label lblNewLabel = new Label(container, SWT.NONE);
    lblNewLabel.setText(Messages.DeployAllDialog_label);
    new Label(container, SWT.NONE);
    IRepositoryViewObject[] theInput = (IRepositoryViewObject[]) input;
    theInput = getNewInput();
    restoreDeleteObjectsTreeView(theInput);
    treeViewer = new RepositoryViewObjectCheckedWidget(container, theInput, changedViewObjs);
    treeViewer.addCheckStateListener(new ICheckStateListener() {
        public void checkStateChanged(CheckStateChangedEvent event) {
        }
    });
    treeViewer.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 2));
    Button selAllButton = new Button(container, SWT.NONE);
    selAllButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            treeViewer.selectAll(true);
        }
    });
    selAllButton.setText(Messages.DeployAllDialog_selectAll);
    Button deselAllBun = new Button(container, SWT.NONE);
    deselAllBun.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 1));
    deselAllBun.setText(Messages.DeployAllDialog_deselectAll);
    deselAllBun.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            treeViewer.selectAll(false);
        }
    });
    return container;
}

Output:
     new Label(container, SWT.NONE);
-    IRepositoryViewObject[] theInput = (IRepositoryViewObject[]) input;
-    theInput = getNewInput();
-    restoreDeleteObjectsTreeView(theInput);
-    treeViewer = new RepositoryViewObjectCheckedWidget(container, theInput, changedViewObjs);
+    restoreDeleteObjectsTreeView((IRepositoryViewObject[]) input);
+    treeViewer = new RepositoryViewObjectCheckedWidget(container, input, changedViewObjs);
     treeViewer.addCheckStateListener(new ICheckStateListener() {


Input:
public static Primitive getGravity(String value) {
    return sGravityMap.get(value);
}

Output:
 public static Primitive getGravity(String value) {
-    return sGravityMap.get(value);
+    return new Primitive(parseGravity(value));
 }


Input:
private void appendBuffer(final ByteBuffer buffer, final AppendCallback cb) {
    if (this.unflushThreshold <= 0) {
        this.bufferQueue.offer(new WriteRequest(buffer, cb));
    } else {
        final int remainning = buffer.remaining();
        this.writeLock.lock();
        try {
            final Segment cur = this.segments.last();
            final long offset = cur.start + cur.fileMessageSet.append(buffer);
            this.mayBeFlush(1);
            this.mayBeRoll();
            if (cb != null) {
                cb.appendComplete(new Location(offset, remainning));
            }
        } catch (final IOException e) {
            log.error("String_Node_Str", e);
            if (cb != null) {
                cb.appendComplete(Location.InvalidLocaltion);
            }
        } finally {
            this.writeLock.unlock();
        }
    }
}

Output:
 private void appendBuffer(final ByteBuffer buffer, final AppendCallback cb) {
-    if (this.unflushThreshold <= 0) {
-        this.bufferQueue.offer(new WriteRequest(buffer, cb));
-    } else {
-        final int remainning = buffer.remaining();
-        this.writeLock.lock();
-        try {
-            final Segment cur = this.segments.last();
-            final long offset = cur.start + cur.fileMessageSet.append(buffer);
+    final int remainning = buffer.remaining();
+    this.writeLock.lock();
+    try {
+        final Segment cur = this.segments.last();
+        final long offset = cur.start + cur.fileMessageSet.append(buffer);
+        if (this.useGroupCommit()) {
+            long lastFlushPos = cur.fileMessageSet.highWaterMark();
+            Location location = new Location(offset, remainning);
+            WriteRequest writeRequest = new WriteRequest(cb, location);
+            writeRequest.location = location;
+            this.toFlush.offer(writeRequest);
+            if (!this.writeLock.hasQueuedThreads() || cur.fileMessageSet.getSizeInBytes() > lastFlushPos + this.MAX_BATCH_SIZE) {
+                this.flush0();
+                this.notifyCallbacks();
+                this.toFlush.clear();
+                this.mayBeRoll();
+            }
+        } else {
             this.mayBeFlush(1);


Input:
protected double homoscedasticTTest(double m1, double m2, double v1, double v2, double n1, double n2) throws MathException {
    double t = Math.abs(homoscedasticT(m1, m2, v1, v2, n1, n2));
    double degreesOfFreedom = (double) (n1 + n2 - 2);
    distribution.setDegreesOfFreedom(degreesOfFreedom);
    return 1.0 - distribution.cumulativeProbability(-t, t);
}

Output:
     distribution.setDegreesOfFreedom(degreesOfFreedom);
-    return 1.0 - distribution.cumulativeProbability(-t, t);
+    return 2.0 * distribution.cumulativeProbability(-t);
 }


Input:
private State resolve() {
    final State state = StateObjectFactory.defaultFactory.createState(true);
    for (BundleDescription bundleDescription : getAllBundleDescriptions(this._configuration.isPreferProjects())) {
        final BundleDescription copy = StateObjectFactory.defaultFactory.createBundleDescription(bundleDescription);
        copy.setUserObject(bundleDescription.getUserObject());
        if (!state.addBundle(copy)) {
            throw new RuntimeException("String_Node_Str" + bundleDescription + "String_Node_Str");
        }
        if (A4ELogging.isTraceingEnabled()) {
            A4ELogging.trace("String_Node_Str", getBundleInfo(bundleDescription));
        }
    }
    final Properties platformProperties = this._configuration.getConfigurationProperties();
    if (A4ELogging.isDebuggingEnabled()) {
        A4ELogging.debug(Utilities.toString("String_Node_Str", platformProperties));
    }
    state.setPlatformProperties(platformProperties);
    state.resolve();
    final BundleDescription[] bundleDescriptions = state.getBundles();
    if (A4ELogging.isDebuggingEnabled()) {
        for (int i = 0; i < bundleDescriptions.length; i++) {
            final BundleDescription description = bundleDescriptions[i];
            final ResolverError[] errors = state.getResolverErrors(description);
            if (!description.isResolved() || ((errors != null) && (errors.length != 0))) {
                if ((errors != null) && (errors.length == 1) && (errors[0].getType() == ResolverError.SINGLETON_SELECTION)) {
                    A4ELogging.debug("String_Node_Str", getBundleInfo(description));
                } else {
                    A4ELogging.debug("String_Node_Str", getBundleInfo(description));
                    for (int j = 0; j < errors.length; j++) {
                        final ResolverError error = errors[j];
                        A4ELogging.debug("String_Node_Str", error);
                    }
                }
            }
        }
    }
    return state;
}

Output:
     if (A4ELogging.isDebuggingEnabled()) {
-        for (int i = 0; i < bundleDescriptions.length; i++) {
-            final BundleDescription description = bundleDescriptions[i];
-            final ResolverError[] errors = state.getResolverErrors(description);
-            if (!description.isResolved() || ((errors != null) && (errors.length != 0))) {
-                if ((errors != null) && (errors.length == 1) && (errors[0].getType() == ResolverError.SINGLETON_SELECTION)) {
-                    A4ELogging.debug("String_Node_Str", getBundleInfo(description));
-                } else {
-                    A4ELogging.debug("String_Node_Str", getBundleInfo(description));
-                    for (int j = 0; j < errors.length; j++) {
-                        final ResolverError error = errors[j];
-                        A4ELogging.debug("String_Node_Str", error);
-                    }
-                }
-            }
+        for (BundleDescription description : bundleDescriptions) {
+            A4ELogging.debug(dumpResolverErrors(description));
         }


Input:
public static void bindNewsView(NetUtils net, RecyclerView.ViewHolder newsViewHolder, Cursor cursor) {
    NewsViewHolder holder = (NewsViewHolder) newsViewHolder;
    String imgUrl = cursor.getString(4);
    if (imgUrl == null || imgUrl.isEmpty() || imgUrl.equals("String_Node_Str")) {
        holder.img.setVisibility(View.GONE);
    } else {
        holder.img.setVisibility(View.VISIBLE);
        net.loadAndSetImage(imgUrl, holder.img);
    }
    String title = cursor.getString(2);
    if (cursor.getInt(1) == 2) {
        title = COMPILE.matcher(title).replaceAll("String_Node_Str");
    }
    holder.title.setText(title);
    String date = cursor.getString(5);
    Date d = Utils.getISODateTime(date);
    DateFormat sdf = DateFormat.getDateInstance();
    holder.srcDate.setText(sdf.format(d));
    holder.srcTitle.setText(cursor.getString(8));
    String icon = cursor.getString(7);
    if (icon.isEmpty() || "String_Node_Str".equals(icon)) {
        holder.srcIcon.setImageResource(R.drawable.ic_comment);
    } else {
        net.loadAndSetImage(icon, holder.srcIcon);
    }
}

Output:
     String date = cursor.getString(5);
-    Date d = Utils.getISODateTime(date);
+    Date d = Utils.getDateTime(date);
     DateFormat sdf = DateFormat.getDateInstance();


Input:
public static void newTimeIntervall(String timeStr) {
    try {
        int i = DBConnection.statement.executeUpdate("String_Node_Str" + timeStr + "String_Node_Str");
        System.out.println("String_Node_Str" + i + "String_Node_Str");
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        int i = DBConnection.statement.executeUpdate("String_Node_Str" + timeStr + "String_Node_Str");
+        int i = DBConnection.statement.executeUpdate("String_Node_Str" + timeIntervallData.get(0) + "String_Node_Str" + timeIntervallData.get(1) + "String_Node_Str" + timeIntervallData.get(2) + "String_Node_Str");
         System.out.println("String_Node_Str" + i + "String_Node_Str");


Input:
private Map<byte[], byte[]> filteredLatestColumns(ResultSet result, ReadPointer readPointer, int limit) throws SQLException {
    if (limit <= 0)
        limit = Integer.MAX_VALUE;
    Map<byte[], byte[]> map = new TreeMap<byte[], byte[]>(Bytes.BYTES_COMPARATOR);
    if (result == null)
        return map;
    byte[] curCol = new byte[0];
    byte[] lastCol = new byte[0];
    long lastDelete = -1;
    long undeleted = -1;
    while (result.next()) {
        long curVersion = result.getLong(2);
        if (!readPointer.isVisible(curVersion))
            continue;
        byte[] column = result.getBytes(1);
        if (Bytes.equals(lastCol, column)) {
            continue;
        }
        if (!Bytes.equals(curCol, column)) {
            curCol = column;
            lastDelete = -1;
            undeleted = -1;
        }
        Type type = Type.from(result.getInt(3));
        if (type.isUndeleteAll()) {
            undeleted = curVersion;
            continue;
        }
        if (type.isDeleteAll()) {
            if (undeleted == curVersion)
                continue;
            else {
                lastCol = column;
                continue;
            }
        }
        if (type.isDelete()) {
            lastDelete = curVersion;
            continue;
        }
        if (curVersion == lastDelete)
            continue;
        lastCol = column;
        map.put(column, result.getBytes(5));
        if (map.size() >= limit)
            break;
    }
    return map;
}

Output:
 private Map<byte[], byte[]> filteredLatestColumns(ResultSet result, ReadPointer readPointer, int limit) throws SQLException {
-    if (limit <= 0)
+    if (limit <= 0) {
         limit = Integer.MAX_VALUE;


Input:
void enforceDbRepresentationTransformLogic(HttpServerExchange exchange, RequestContext context) throws InvalidMetadataException, ScriptException {
    List<RepresentationTransformer> dbRts = RepresentationTransformer.getFromJson(context.getDbProps());
    RequestContext.TYPE requestType = context.getType();
    for (RepresentationTransformer rt : dbRts) {
        Transformer t = (Transformer) NamedSingletonsFactory.getInstance().get("String_Node_Str", rt.getName());
        if (t == null) {
            throw new IllegalArgumentException("String_Node_Str" + rt.getName() + "String_Node_Str");
        }
        if (rt.getPhase() == RepresentationTransformer.PHASE.REQUEST) {
            if (rt.getScope() == RepresentationTransformer.SCOPE.THIS && requestType == RequestContext.TYPE.DB) {
                t.tranform(exchange, context, context.getContent(), rt.getArgs());
            } else if (rt.getScope() == RepresentationTransformer.SCOPE.CHILDREN && requestType == RequestContext.TYPE.COLLECTION) {
                t.tranform(exchange, context, context.getContent(), rt.getArgs());
            }
        }
    }
}

Output:
                 t.tranform(exchange, context, context.getContent(), rt.getArgs());
-            } else if (rt.getScope() == RepresentationTransformer.SCOPE.CHILDREN && requestType == RequestContext.TYPE.COLLECTION) {
+            } else {
                 t.tranform(exchange, context, context.getContent(), rt.getArgs());


Input:
private void internalCreateAttachments(String parentItemId, Iterable<Attachment> attachments) throws Exception {
    ServiceResponseCollection<CreateAttachmentResponse> responses = this.owner.getService().createAttachments(parentItemId, attachments);
    Enumeration<CreateAttachmentResponse> enumerator = responses.getEnumerator();
    while (enumerator.hasMoreElements()) {
        CreateAttachmentResponse response = enumerator.nextElement();
        if (response.getResult() != ServiceResult.Error) {
            this.removeFromChangeLog(response.getAttachment());
        }
    }
    if (responses.getOverallResult() == ServiceResult.Error) {
        throw new CreateAttachmentException(responses, Strings.AttachmentCreationFailed);
    }
}

Output:
     if (responses.getOverallResult() == ServiceResult.Error) {
-        throw new CreateAttachmentException(responses, Strings.AttachmentCreationFailed);
+        throw new CreateAttachmentException(responses, "String_Node_Str");
     }


Input:
public static void main(String[] args) {
    Vect bob = new Vect(1.0, 1.0, 1.0);
    Vect e1 = new Vect(3.0, 0.0, 0.0);
    Vect e2 = new Vect(0.0, 3.0, 0.0);
    Vect e3 = new Vect(0.0, 0.0, 3.0);
    List<Vect> basis = new ArrayList<Vect>();
    basis.add(e1);
    basis.add(e2);
    basis.add(e3);
    Vect shift = new Vect(-2.0, -1.0, -2.0);
    bob = bob.plusWRT(shift, basis);
    System.out.println(bob);
    List<Double> components = bob.getComponentsWRTBasis(basis);
    System.out.println(components.get(0) + "String_Node_Str" + components.get(1) + "String_Node_Str" + components.get(2));
    System.out.println(e1.cross(e2));
    System.out.println(Vect.pointsAreCollinear(e1, e2, e3, 0.0001));
}

Output:
 public static void main(String[] args) {
-    Vect bob = new Vect(1.0, 1.0, 1.0);
-    Vect e1 = new Vect(3.0, 0.0, 0.0);
-    Vect e2 = new Vect(0.0, 3.0, 0.0);
-    Vect e3 = new Vect(0.0, 0.0, 3.0);
-    List<Vect> basis = new ArrayList<Vect>();
-    basis.add(e1);
-    basis.add(e2);
-    basis.add(e3);
-    Vect shift = new Vect(-2.0, -1.0, -2.0);
-    bob = bob.plusWRT(shift, basis);
-    System.out.println(bob);
-    List<Double> components = bob.getComponentsWRTBasis(basis);
-    System.out.println(components.get(0) + "String_Node_Str" + components.get(1) + "String_Node_Str" + components.get(2));
-    System.out.println(e1.cross(e2));
-    System.out.println(Vect.pointsAreCollinear(e1, e2, e3, 0.0001));
+    Cell oldCell = VaspOut.getPOSCAR("String_Node_Str");
+    Cell substrate = VaspOut.getPOSCAR("String_Node_Str");
+    List<Vect> newBasis = new ArrayList<Vect>();
+    newBasis.add(substrate.getLatticeVectors().get(0));
+    newBasis.add(substrate.getLatticeVectors().get(1));
+    newBasis.add(oldCell.getLatticeVectors().get(2));
+    List<Site> newSites = new ArrayList<Site>();
+    for (Site site : oldCell.getSites()) {
+        Vect v = site.getCoords().changeBasis(newBasis);
+        newSites.add(new Site(site.getElement(), v));
+    }
+    Cell newCell = new Cell(newBasis, newSites, oldCell.getLabel());
+    VaspIn.writePoscar(newCell, "String_Node_Str", true);
+    VaspIn.writePoscar(oldCell, "String_Node_Str", true);
 }


Input:
public void onResponse(Call<OAuth2Tokens> call, Response<OAuth2Tokens> response) {
    token = response.body();
    if (token != null)
        listener.onSuccess();
    else
        listener.onFailed();
}

Output:
 public void onResponse(Call<OAuth2Tokens> call, Response<OAuth2Tokens> response) {
-    token = response.body();
-    if (token != null)
+    mToken = response.body();
+    if (mToken != null)
         listener.onSuccess();


Input:
private void scanWorkflow() throws EoulsanException {
    final Context context = this.context;
    final Set<DataFile> checkedDatafile = new HashSet<DataFile>();
    final Map<DataFormat, Checker> checkers = new HashMap<DataFormat, Checker>();
    final DataFormatRegistry dfRegistry = DataFormatRegistry.getInstance();
    dfRegistry.register(DataFormats.READS_FASTQ);
    dfRegistry.register(DataFormats.READS_TFQ);
    dfRegistry.register(DataFormats.GENOME_FASTA);
    dfRegistry.register(DataFormats.ANNOTATION_GFF);
    boolean firstSample = true;
    for (Sample s : this.design.getSamples()) {
        final Set<DataFormat> cart = new HashSet<DataFormat>();
        final Set<DataFormat> cartUsed = new HashSet<DataFormat>();
        final Set<DataFormat> cartReUsed = new HashSet<DataFormat>();
        final Set<DataFormat> cartGenerated = new HashSet<DataFormat>();
        final Set<DataFormat> cartNotGenerated = new HashSet<DataFormat>();
        final Set<DataFormat> cartOnlyGenerated = new HashSet<DataFormat>();
        cart.add(getReadsDataFormat(s));
        cart.add(getGenomeDataFormat(s));
        cart.add(getAnnotationDataFormat(s));
        for (Step step : this.steps) {
            if (firstSample)
                checkStepInOutFormat(step);
            final Map<DataType, Set<DataFormat>> map = getDataFormatByDataType(step.getInputFormats());
            if (map != null && map.size() > 0)
                for (Map.Entry<DataType, Set<DataFormat>> e : map.entrySet()) {
                    int found = 0;
                    boolean canBeGenerated = false;
                    for (DataFormat df : e.getValue()) {
                        if (df.isGenerator())
                            canBeGenerated = true;
                        if (cart.contains(df)) {
                            cartUsed.add(df);
                            if (df.isChecker())
                                checkers.put(df, df.getChecker());
                            if (cartGenerated.contains(df))
                                cartReUsed.add(df);
                            found++;
                        }
                    }
                    if (found == 0) {
                        if (canBeGenerated) {
                            cartUsed.add(e.getValue().iterator().next());
                        } else
                            throw new EoulsanException("String_Node_Str" + s.getId() + "String_Node_Str" + step.getName() + "String_Node_Str");
                    }
                    if (found > 1)
                        throw new EoulsanException("String_Node_Str" + s.getId() + "String_Node_Str" + step.getName() + "String_Node_Str");
                }
            if (step.getOutputFormats() != null)
                for (DataFormat df : step.getOutputFormats()) {
                    cartGenerated.add(df);
                    cart.add(df);
                }
        }
        cartNotGenerated.addAll(cartUsed);
        cartNotGenerated.removeAll(cartGenerated);
        for (DataFormat df : cartNotGenerated) {
            final DataFile file = context.getDataFile(df, s);
            if (!checkedDatafile.contains(file)) {
                if (!context.getDataFile(df, s).exists()) {
                    if (df.isGenerator()) {
                        this.steps.add(0, df.getGenerator());
                        scanWorkflow();
                        return;
                    }
                    throw new EoulsanException("String_Node_Str" + s.getId() + "String_Node_Str" + df.getFormatName() + "String_Node_Str");
                }
                checkedDatafile.add(file);
            }
        }
        for (DataFormat df : cartGenerated) {
            final DataFile file = context.getDataFile(df, s);
            if (!checkedDatafile.contains(file)) {
                if (context.getDataFile(df, s).exists())
                    throw new EoulsanException("String_Node_Str" + s.getId() + "String_Node_Str" + df.getFormatName() + "String_Node_Str");
                checkedDatafile.add(file);
            }
        }
        cartOnlyGenerated.addAll(cartGenerated);
        cartOnlyGenerated.removeAll(cartReUsed);
        globalInputDataFormats.put(s, Collections.unmodifiableSet(cartNotGenerated));
        globalOutputDataFormats.put(s, Collections.unmodifiableSet(cartOnlyGenerated));
        if (firstSample)
            firstSample = false;
    }
    runChecker(checkers);
}

Output:
     final Context context = this.context;
-    final Set<DataFile> checkedDatafile = new HashSet<DataFile>();
-    final Map<DataFormat, Checker> checkers = new HashMap<DataFormat, Checker>();
+    final Set<DataFile> checkedDatafile = newHashSet();
+    final Map<DataFormat, Checker> checkers = newHashMap();
     final DataFormatRegistry dfRegistry = DataFormatRegistry.getInstance();


Input:
public void itemClick(ItemClickEvent event) {
    if (event.isDoubleClick()) {
        Object object = event.getPropertyId();
        if (!object.toString().equals("String_Node_Str")) {
            Object prop = event.getPropertyId();
            String header = logTable.getColumnHeader(prop);
            Property<?> p = event.getItem().getItemProperty(prop);
            String data = String.valueOf(p.getValue());
            new ReadOnlyTextAreaDialog(header, data, false).showAtSize(.5);
        }
    }
}

Output:
             Property<?> p = event.getItem().getItemProperty(prop);
-            String data = String.valueOf(p.getValue());
-            new ReadOnlyTextAreaDialog(header, data, false).showAtSize(.5);
+            if (p != null) {
+                String data = String.valueOf(p.getValue());
+                new ReadOnlyTextAreaDialog(header, data, false).showAtSize(.5);
+            }
         }


Input:
public void setStaticLayouts() {
    Row baseRow = new Row("String_Node_Str");
    baseRow.setFrameColor(0, 0, 1, 0);
    setBaseElementLayout(baseRow);
    leftRelationIndicatorRenderer.updateRelations();
    rightRelationIndicatorRenderer.updateRelations();
    ElementLayout leftRelationIndicatorLayout = new ElementLayout("String_Node_Str");
    leftRelationIndicatorLayout.setPixelGLConverter(pixelGLConverter);
    leftRelationIndicatorLayout.setPixelSizeX(RELATION_INDICATOR_WIDTH_PIXELS);
    leftRelationIndicatorLayout.setRenderer(leftRelationIndicatorRenderer);
    baseRow.append(leftRelationIndicatorLayout);
    Column baseColumn = new Column("String_Node_Str");
    baseColumn.setFrameColor(0, 1, 0, 0);
    ElementLayout fuelBarLayout = new ElementLayout("String_Node_Str");
    fuelBarLayout.setFrameColor(0, 1, 0, 0);
    baseRow.setRenderer(new BorderedAreaRenderer());
    if (showHandles) {
        baseRow.addForeGroundRenderer(new HandleRenderer(brick, pixelGLConverter, HANDLE_SIZE_PIXELS, brick.getTextureManager(), HandleRenderer.ALL_RESIZE_HANDLES & HandleRenderer.MOVE_VERTICALLY_HANDLE));
    }
    fuelBarLayout.setPixelGLConverter(pixelGLConverter);
    fuelBarLayout.setPixelSizeY(SPACING_PIXELS);
    fuelBarLayout.setRenderer(new FuelBarRenderer(brick));
    ElementLayout spacingLayoutX = new ElementLayout("String_Node_Str");
    spacingLayoutX.setPixelGLConverter(pixelGLConverter);
    spacingLayoutX.setPixelSizeX(SPACING_PIXELS);
    spacingLayoutX.setRatioSizeY(0);
    baseRow.append(spacingLayoutX);
    baseRow.append(baseColumn);
    baseRow.append(spacingLayoutX);
    ElementLayout viewLayout = new ElementLayout("String_Node_Str");
    viewLayout.setFrameColor(1, 0, 0, 1);
    viewLayout.addBackgroundRenderer(new BackGroundRenderer(brick));
    viewLayout.setRenderer(viewRenderer);
    Row toolBar = createBrickToolBar(TOOLBAR_HEIGHT_PIXELS);
    ElementLayout spacingLayoutY = new ElementLayout("String_Node_Str");
    spacingLayoutY.setPixelGLConverter(pixelGLConverter);
    spacingLayoutY.setPixelSizeY(SPACING_PIXELS);
    spacingLayoutY.setPixelSizeX(0);
    baseColumn.append(spacingLayoutY);
    baseColumn.append(fuelBarLayout);
    baseColumn.append(spacingLayoutY);
    baseColumn.append(viewLayout);
    baseColumn.append(spacingLayoutY);
    baseColumn.append(toolBar);
    baseColumn.append(spacingLayoutY);
    ElementLayout rightRelationIndicatorLayout = new ElementLayout("String_Node_Str");
    rightRelationIndicatorLayout.setPixelGLConverter(pixelGLConverter);
    rightRelationIndicatorLayout.setPixelSizeX(RELATION_INDICATOR_WIDTH_PIXELS);
    rightRelationIndicatorLayout.setRenderer(rightRelationIndicatorRenderer);
    baseRow.append(rightRelationIndicatorLayout);
}

Output:
     if (showHandles) {
-        baseRow.addForeGroundRenderer(new HandleRenderer(brick, pixelGLConverter, HANDLE_SIZE_PIXELS, brick.getTextureManager(), HandleRenderer.ALL_RESIZE_HANDLES & HandleRenderer.MOVE_VERTICALLY_HANDLE));
+        baseRow.addForeGroundRenderer(new HandleRenderer(brick, pixelGLConverter, HANDLE_SIZE_PIXELS, brick.getTextureManager(), HandleRenderer.ALL_RESIZE_HANDLES | HandleRenderer.MOVE_VERTICALLY_HANDLE));
     }


Input:
public ComponentName startService(Intent service) {
    warnIfCallingFromSystemProcess();
    return startServiceAsUser(service, mUser);
}

Output:
     warnIfCallingFromSystemProcess();
-    return startServiceAsUser(service, mUser);
+    return startServiceCommon(service, mUser);
 }


Input:
public Object fromSuperColumnThriftRow(Class clazz, EntityMetadata m, ThriftRow tr, List<String> relationNames, boolean isWrapReq) throws Exception {
    Object entity = clazz.newInstance();
    Map<String, Set<String>> foreignKeysMap = new HashMap<String, Set<String>>();
    PropertyAccessorHelper.setId(entity, m, tr.getId());
    Map<String, Field> columnNameToFieldMap = new HashMap<String, Field>();
    Map<String, Field> superColumnNameToFieldMap = new HashMap<String, Field>();
    MetadataUtils.populateColumnAndSuperColumnMaps(m, columnNameToFieldMap, superColumnNameToFieldMap);
    Collection embeddedCollection = null;
    Field embeddedCollectionField = null;
    Map<String, Object> relations = new HashMap<String, Object>();
    for (SuperColumn sc : tr.getSuperColumns()) {
        String scName = PropertyAccessorFactory.STRING.fromBytes(sc.getName());
        String scNamePrefix = null;
        if (scName.indexOf(Constants.EMBEDDED_COLUMN_NAME_DELIMITER) != -1) {
            scNamePrefix = MetadataUtils.getEmbeddedCollectionPrefix(scName);
            embeddedCollectionField = superColumnNameToFieldMap.get(scNamePrefix);
            if (embeddedCollection == null) {
                embeddedCollection = MetadataUtils.getEmbeddedCollectionInstance(embeddedCollectionField);
            }
            Object embeddedObject = MetadataUtils.getEmbeddedGenericObjectInstance(embeddedCollectionField);
            for (Column column : sc.getColumns()) {
                String name = PropertyAccessorFactory.STRING.fromBytes(column.getName());
                byte[] value = column.getValue();
                if (value == null) {
                    continue;
                }
                Field columnField = columnNameToFieldMap.get(name);
                if (columnField != null) {
                    PropertyAccessorHelper.set(embeddedObject, columnField, value);
                } else if (relationNames != null && !relationNames.isEmpty() && relationNames.contains(name)) {
                    String valueAsStr = PropertyAccessorFactory.STRING.fromBytes(value);
                    relations.put(name, valueAsStr);
                }
            }
            embeddedCollection.add(embeddedObject);
            ElementCollectionCacheManager.getInstance().addElementCollectionCacheMapping(tr.getId(), embeddedObject, scName);
        } else {
            Field superColumnField = superColumnNameToFieldMap.get(scName);
            Object superColumnObj = null;
            if (superColumnField != null || (relationNames != null && !relationNames.isEmpty() && relationNames.contains(scName))) {
                Class superColumnClass = superColumnField != null ? superColumnField.getType() : null;
                superColumnObj = superColumnClass != null ? superColumnClass.newInstance() : null;
                for (Column column : sc.getColumns()) {
                    String name = PropertyAccessorFactory.STRING.fromBytes(column.getName());
                    byte[] value = column.getValue();
                    Field columnField = columnNameToFieldMap.get(name);
                    if (columnField != null) {
                        try {
                            PropertyAccessorHelper.set(superColumnObj, columnField, value);
                        } catch (PropertyAccessException e) {
                            log.debug(e.getMessage() + "String_Node_Str");
                            superColumnObj = Bytes.toUTF8(value);
                        }
                    } else {
                        String valueAsStr = PropertyAccessorFactory.STRING.fromBytes(value);
                        relations.put(name, valueAsStr);
                    }
                }
            }
            if (superColumnField != null) {
                PropertyAccessorHelper.set(entity, superColumnField, superColumnObj);
            }
        }
    }
    if (embeddedCollection != null && !embeddedCollection.isEmpty()) {
        PropertyAccessorHelper.set(entity, embeddedCollectionField, embeddedCollection);
    }
    return isWrapReq ? new EnhanceEntity(entity, tr.getId(), relations) : entity;
}

Output:
 public Object fromSuperColumnThriftRow(Class clazz, EntityMetadata m, ThriftRow tr, List<String> relationNames, boolean isWrapReq) throws Exception {
-    Object entity = clazz.newInstance();
+    Object entity = null;
     Map<String, Set<String>> foreignKeysMap = new HashMap<String, Set<String>>();


Input:
public void setUp() {
    filtingHandler = new FilterHandler(true, true, true, true, true, 10, 10);
    passingHandler = new FilterHandler(false, false, false, false, false, 0, 0);
}

Output:
 public void setUp() {
-    filtingHandler = new FilterHandler(true, true, true, true, true, 10, 10);
-    passingHandler = new FilterHandler(false, false, false, false, false, 0, 0);
+    passingHandler = new FilterHandler();
+    filtingHandler = new FilterHandler();
+    filtingHandler.setFilterInvalid(true);
+    filtingHandler.setFilterZero(true);
+    filtingHandler.setFilterDuplicate(true);
+    filtingHandler.setFilterFuture(true);
+    filtingHandler.setFilterApproximate(true);
+    filtingHandler.setFilterStatic(true);
+    filtingHandler.setFilterDistance(10);
+    filtingHandler.setFilterLimit(10);
 }


Input:
final T get(final String code) throws BackingStoreException {
    T object;
    boolean success;
    synchronized (objects) {
        object = objects.get(code);
        success = (object != null || !objects.containsKey(code));
    }
    if (!success) {
        try {
            object = createObject(code);
            success = true;
        } catch (FactoryException exception) {
            if (!isRecoverableFailure(exception)) {
                throw new BackingStoreException(exception);
            }
            final LogRecord record = Messages.getResources(null).getLogRecord(Level.WARNING, Messages.Keys.CanNotInstantiateForIdentifier_3, type, code, getCause(exception));
            record.setLoggerName(Loggers.CRS_FACTORY);
            Logging.log(IdentifiedObjectSet.class, "String_Node_Str", record);
        }
        synchronized (objects) {
            if (success) {
                if (objects.containsKey(code)) {
                    final T c = objects.putIfAbsent(code, object);
                    if (c != null) {
                        object = c;
                    } else {
                        codes = null;
                    }
                }
            } else if (objects.remove(code, null)) {
                codes = null;
            }
        }
    }
    return object;
}

Output:
             }
-            final LogRecord record = Messages.getResources(null).getLogRecord(Level.WARNING, Messages.Keys.CanNotInstantiateForIdentifier_3, type, code, getCause(exception));
+            final LogRecord record = Messages.getResources(getLocale()).getLogRecord(Level.WARNING, Messages.Keys.CanNotInstantiateForIdentifier_3, type, code, getCause(exception));
             record.setLoggerName(Loggers.CRS_FACTORY);


Input:
private void compactQueryLengths(final int[] queryLengths) {
    if (queryLengths == null) {
        return;
    }
    final IntSet uniqueLengths = new IntOpenHashSet();
    for (final int length : queryLengths) {
        if (length != 0) {
            uniqueLengths.add(length);
        }
    }
    if (uniqueLengths.size() == 1) {
        constantQueryLength = uniqueLengths.iterator().nextInt();
        isConstantQueryLength = true;
        this.queryLengths = null;
    } else {
        if (actualNumberOfQueries != Integer.MIN_VALUE) {
            int smallerLength = maxQueryIndex - minQueryIndex + 1;
            if (smallerLength != getNumQueries()) {
                int[] smaller = new int[smallerLength];
                System.arraycopy(queryLengths, minQueryIndex, smaller, 0, smallerLength);
                this.queryLengths = smaller;
            }
        } else {
            this.queryLengths = queryLengths;
        }
    }
}

Output:
     } else {
-        if (actualNumberOfQueries != Integer.MIN_VALUE) {
-            int smallerLength = maxQueryIndex - minQueryIndex + 1;
-            if (smallerLength != getNumQueries()) {
-                int[] smaller = new int[smallerLength];
-                System.arraycopy(queryLengths, minQueryIndex, smaller, 0, smallerLength);
-                this.queryLengths = smaller;
+        if (queryLengths != null) {
+            if (actualNumberOfQueries != Integer.MIN_VALUE) {
+                final int smallerLength = maxQueryIndex - minQueryIndex + 1;
+                if (smallerLength != getNumQueries()) {
+                    final int[] smaller = new int[smallerLength];
+                    System.arraycopy(queryLengths, minQueryIndex, smaller, 0, smallerLength);
+                    this.queryLengths = smaller;
+                }
             }


Input:
public void visitInvokeNode(ControlFlowGraph.InvokeNode n) {
    if (n.getVirtualNode() != null) {
        Set<MethodInfo> actuallyReachable = n.getVirtualNode().getImplementedMethods(ctx.getCallString());
        if (!actuallyReachable.contains(n.getImplementedMethod()))
            return;
    }
    cost.addLocalCost(processor.getExecutionTime(ctx.getExecutionContext(n), n.getInstructionHandle()));
    if (n.isVirtual()) {
        throw new AssertionError("String_Node_Str" + n.getReferenced() + "String_Node_Str");
    }
    cost.addCost(RecursiveWcetAnalysis.this.recursiveWCET.recursiveCost(RecursiveWcetAnalysis.this, n, ctx));
}

Output:
     if (n.getVirtualNode() != null) {
-        Set<MethodInfo> actuallyReachable = n.getVirtualNode().getImplementedMethods(ctx.getCallString());
+        Set<MethodInfo> actuallyReachable = n.getVirtualNode().getImplementedMethods(ctx.getCallString(), project.getCallGraph());
         if (!actuallyReachable.contains(n.getImplementedMethod()))


Input:
public IResultMetaData getBindingMetaData() throws DataException {
    if (bindingMetaData == null) {
        ExprMetaInfo[] metaInfo = getRDLoad(subQueryName, queryResultID).loadExprMetaInfo();
        bindingMetaData = new BindingMetaData(metaInfo);
    }
    return bindingMetaData;
}

Output:
         ExprMetaInfo[] metaInfo = getRDLoad(subQueryName, queryResultID).loadExprMetaInfo();
-        bindingMetaData = new BindingMetaData(metaInfo);
+        if (ExprMetaUtil.isBasedOnRD(metaInfo)) {
+            ExprMetaInfo[] infos = new ExprMetaInfo[metaInfo.length - 1];
+            for (int i = 0, k = 0; i < infos.length; i++, k++) {
+                if (isInternalMetaInfo(metaInfo[k]))
+                    i--;
+                else
+                    infos[i] = metaInfo[k];
+            }
+            bindingMetaData = new BindingMetaData(infos);
+        } else {
+            bindingMetaData = new BindingMetaData(metaInfo);
+        }
     }


Input:
public static void main(String[] args) throws Exception {
    Config.overwrite("String_Node_Str", "String_Node_Str");
    Config.overwrite("String_Node_Str", "String_Node_Str");
    Config.overwrite("String_Node_Str", "String_Node_Str");
    Config.overwrite("String_Node_Str", "String_Node_Str");
    Config.overwrite("String_Node_Str", "String_Node_Str" + false);
    Network nw1 = new ReadableFile("String_Node_Str", "String_Node_Str", "String_Node_Str", null, null);
    Network nw2 = new ReadableFolder("String_Node_Str", "String_Node_Str", "String_Node_Str", null, null);
    Network nw3 = new ReadableList("String_Node_Str", "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str" }, null, null);
    Series s1 = Series.generate(nw1, 1);
    Series s2 = Series.generate(nw2, 10);
    Series s3 = Series.generate(nw3, 17);
    Plot.multiAvg(s1, "String_Node_Str");
    Network er = new ErdosRenyi(100, 10, false, null, null);
    GraphWriter.write(er.generate(), "String_Node_Str");
}

Output:
     Network nw1 = new ReadableFile("String_Node_Str", "String_Node_Str", "String_Node_Str", null, null);
-    Network nw2 = new ReadableFolder("String_Node_Str", "String_Node_Str", "String_Node_Str", null, null);
+    Network nw2 = new ReadableFolder("String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", null, null);
     Network nw3 = new ReadableList("String_Node_Str", "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str" }, null, null);


Input:
boolean popScreensUntil(String targetEntryName) {
    boolean clearAll = (targetEntryName == null);
    FragmentManager manager = this.activity.getSupportFragmentManager();
    int entryCount = manager.getBackStackEntryCount();
    boolean found = false;
    while (entryCount > 0) {
        FragmentManager.BackStackEntry entry = manager.getBackStackEntryAt(entryCount - 1);
        if (!clearAll && TextUtils.equals(targetEntryName, getEntryTag(entry))) {
            found = true;
            break;
        }
        manager.popBackStack();
        entryCount--;
    }
    manager.executePendingTransactions();
    return found;
}

Output:
         FragmentManager.BackStackEntry entry = manager.getBackStackEntryAt(entryCount - 1);
-        if (!clearAll && TextUtils.equals(targetEntryName, getEntryTag(entry))) {
+        if (!clearAll && TextUtils.equals(targetEntryName, getEntryTag(entry)) && type == getEntryType(entry)) {
             found = true;


Input:
private boolean updateChildStatus(String appId, String id, Map<String, Group> groups, Map<String, ClusterDataHolder> clusterData, ParentComponent parent) {
    boolean groupActive = false;
    ClusterStatus clusterStatus;
    GroupStatus groupStatus;
    boolean childFound = false;
    boolean clusterFound = false;
    for (ClusterDataHolder clusterDataHolder : clusterData.values()) {
        if (clusterDataHolder.getClusterId().equals(id)) {
            clusterFound = true;
        }
    }
    log.info("String_Node_Str" + clusterFound);
    if (clusterFound || groups.containsKey(id)) {
        childFound = true;
        clusterStatus = getClusterStatus(clusterData);
        groupStatus = getGroupStatus(groups);
        if (groups.isEmpty() && clusterStatus == ClusterStatus.Active || clusterData.isEmpty() && groupStatus == GroupStatus.Active || groupStatus == GroupStatus.Active && clusterStatus == ClusterStatus.Active) {
            if (parent instanceof Application) {
                log.info("String_Node_Str" + appId);
                StatusEventPublisher.sendApplicationActivatedEvent(appId);
            } else if (parent instanceof Group) {
                log.info("String_Node_Str" + parent.getUniqueIdentifier());
                StatusEventPublisher.sendGroupActivatedEvent(appId, parent.getUniqueIdentifier());
            }
        } else if (groups.isEmpty() && clusterStatus == ClusterStatus.Inactive || clusterData.isEmpty() && groupStatus == GroupStatus.Inactive || groupStatus == GroupStatus.Inactive && clusterStatus == ClusterStatus.Inactive) {
            if (parent instanceof Application) {
                log.warn("String_Node_Str" + appId);
            } else if (parent instanceof Group) {
                log.info("String_Node_Str" + parent.getUniqueIdentifier());
                StatusEventPublisher.sendGroupInActivateEvent(appId, parent.getUniqueIdentifier());
            }
        } else if (groups.isEmpty() && clusterStatus == ClusterStatus.Terminated || clusterData.isEmpty() && groupStatus == GroupStatus.Terminated || groupStatus == GroupStatus.Terminated && clusterStatus == ClusterStatus.Terminated) {
            if (parent instanceof Application) {
                try {
                    TopologyManager.acquireReadLockForApplication(appId);
                    Application application = TopologyManager.getTopology().getApplication(appId);
                    if (application.getStatus().equals(ApplicationStatus.Terminating)) {
                        log.info("String_Node_Str" + appId);
                        StatusEventPublisher.sendApplicationTerminatedEvent(appId, parent.getClusterDataRecursively());
                    } else {
                        log.info("String_Node_Str" + appId + "String_Node_Str" + application.getStatus().toString() + "String_Node_Str");
                    }
                } finally {
                    TopologyManager.releaseReadLockForApplication(appId);
                }
            } else if (parent instanceof Group) {
                log.info("String_Node_Str" + parent.getUniqueIdentifier());
                StatusEventPublisher.sendGroupTerminatedEvent(appId, parent.getUniqueIdentifier());
            }
        } else if (groups.isEmpty() && clusterStatus == ClusterStatus.Terminating || clusterData.isEmpty() && groupStatus == GroupStatus.Terminating || groupStatus == GroupStatus.Terminating && clusterStatus == ClusterStatus.Terminating) {
            if (parent instanceof Application) {
                log.warn("String_Node_Str" + appId);
            } else if (parent instanceof Group) {
                log.info("String_Node_Str" + parent.getUniqueIdentifier());
                StatusEventPublisher.sendGroupTerminatingEvent(appId, parent.getUniqueIdentifier());
            }
        } else {
            log.warn("String_Node_Str" + appId);
        }
        return childFound;
    } else {
        log.warn("String_Node_Str" + id + "String_Node_Str" + "String_Node_Str" + parent.getUniqueIdentifier());
    }
    return childFound;
}

Output:
 private boolean updateChildStatus(String appId, String id, Map<String, Group> groups, Map<String, ClusterDataHolder> clusterData, ParentComponent parent) {
-    boolean groupActive = false;
+    boolean groupsActive = false;
+    boolean groupsTerminated = false;
+    boolean groupsInActive = false;
+    boolean groupsTerminating = false;
     ClusterStatus clusterStatus;


Input:
public boolean contains(Object key) {
    return cacheFiles.containsKey(key);
}

Output:
 public boolean contains(Object key) {
-    return cacheFiles.containsKey(key);
+    if (storageType == STORAGE_FILES) {
+        return cacheFiles.containsKey(key);
+    } else if (storageType == STORAGE_MEMORY) {
+        return cacheMemory.containsKey(key);
+    }
+    return false;
 }


Input:
public void drawValues(Canvas c) {
    if (mChart.getScatterData().getYValCount() < mChart.getMaxVisibleCount() * mViewPortHandler.getScaleX()) {
        List<ScatterDataSet> dataSets = mChart.getScatterData().getDataSets();
        for (int i = 0; i < mChart.getScatterData().getDataSetCount(); i++) {
            ScatterDataSet dataSet = dataSets.get(i);
            if (!dataSet.isDrawValuesEnabled())
                continue;
            applyValueTextStyle(dataSet);
            List<Entry> entries = dataSet.getYVals();
            float[] positions = mChart.getTransformer(dataSet.getAxisDependency()).generateTransformedValuesScatter(entries, mAnimator.getPhaseY());
            float shapeSize = dataSet.getScatterShapeSize();
            for (int j = 0; j < positions.length * mAnimator.getPhaseX(); j += 2) {
                if (!mViewPortHandler.isInBoundsRight(positions[j]))
                    break;
                if ((!mViewPortHandler.isInBoundsLeft(positions[j]) || !mViewPortHandler.isInBoundsY(positions[j + 1])))
                    continue;
                float val = entries.get(j / 2).getVal();
                c.drawText(dataSet.getValueFormatter().getFormattedValue(val), positions[j], positions[j + 1] - shapeSize, mValuePaint);
            }
        }
    }
}

Output:
             ScatterDataSet dataSet = dataSets.get(i);
-            if (!dataSet.isDrawValuesEnabled())
+            if (!dataSet.isDrawValuesEnabled() || dataSet.getEntryCount() == 0)
                 continue;


Input:
public Object xmlToObject(DOMRecord xmlRow, Class referenceClass) throws XMLMarshalException {
    String xmlEncoding = "String_Node_Str";
    String xmlVersion = "String_Node_Str";
    try {
        Method getEncoding = PrivilegedAccessHelper.getMethod(xmlRow.getDocument().getClass(), "String_Node_Str", new Class[] {}, true);
        Method getVersion = PrivilegedAccessHelper.getMethod(xmlRow.getDocument().getClass(), "String_Node_Str", new Class[] {}, true);
        xmlEncoding = (String) PrivilegedAccessHelper.invokeMethod(getEncoding, xmlRow.getDocument(), new Object[] {});
        xmlVersion = (String) PrivilegedAccessHelper.invokeMethod(getVersion, xmlRow.getDocument(), new Object[] {});
    } catch (Exception ex) {
    }
    if (XMLConversionManager.getDefaultJavaTypes().get(referenceClass) != null) {
        Object nodeVal;
        try {
            Text rootTxt = (Text) xmlRow.getDOM().getFirstChild();
            nodeVal = rootTxt.getNodeValue();
        } catch (Exception ex) {
            nodeVal = null;
        }
        Object obj = XMLConversionManager.getDefaultXMLManager().convertObject(nodeVal, referenceClass);
        XMLRoot xmlRoot = new XMLRoot();
        xmlRoot.setObject(obj);
        String lName = xmlRow.getDOM().getLocalName();
        if (lName == null) {
            lName = xmlRow.getDOM().getNodeName();
        }
        xmlRoot.setLocalName(lName);
        xmlRoot.setNamespaceURI(xmlRow.getDOM().getNamespaceURI());
        xmlRoot.setEncoding(xmlEncoding);
        xmlRoot.setVersion(xmlVersion);
        return xmlRoot;
    }
    XMLContext xmlContext = xmlUnmarshaller.getXMLContext();
    AbstractSession readSession = xmlContext.getReadSession(referenceClass);
    ReadObjectQuery query = new ReadObjectQuery();
    query.setReferenceClass(referenceClass);
    query.setSession(readSession);
    XMLDescriptor descriptor = (XMLDescriptor) readSession.getDescriptor(referenceClass);
    if (descriptor == null) {
        throw XMLMarshalException.descriptorNotFoundInProject(referenceClass.getName());
    }
    xmlRow.setUnmarshaller(xmlUnmarshaller);
    xmlRow.setDocPresPolicy(xmlContext.getDocumentPreservationPolicy(readSession));
    XMLObjectBuilder objectBuilder = (XMLObjectBuilder) descriptor.getObjectBuilder();
    Object object = objectBuilder.buildObject(query, xmlRow, null);
    xmlUnmarshaller.resolveReferences(readSession);
    String elementNamespaceUri = xmlRow.getDOM().getNamespaceURI();
    String elementLocalName = xmlRow.getDOM().getLocalName();
    if (elementLocalName == null) {
        elementLocalName = xmlRow.getDOM().getNodeName();
    }
    String elementPrefix = xmlRow.getDOM().getPrefix();
    return descriptor.wrapObjectInXMLRoot(object, elementNamespaceUri, elementLocalName, elementPrefix, xmlEncoding, xmlVersion, this.isResultAlwaysXMLRoot);
}

Output:
         }
-        Object obj = XMLConversionManager.getDefaultXMLManager().convertObject(nodeVal, referenceClass);
+        Object obj = ((XMLConversionManager) xmlContext.getSession(0).getDatasourcePlatform().getConversionManager()).convertObject(nodeVal, referenceClass);
         XMLRoot xmlRoot = new XMLRoot();


Input:
private void addData(Data data) {
    getCurrentContainer().setEmpty(false);
    int col = axis.getColumnIndexByCoordinate(data.getRule().getStartCoordinate());
    int span = axis.getColumnIndexByCoordinate(data.getRule().getEndCoordinate()) - col;
    addDatatoCache(col, data);
    for (int i = col + 1; i < col + span; i++) {
        addDatatoCache(i, Data.WASTE);
    }
}

Output:
 private void addData(Data data) {
-    getCurrentContainer().setEmpty(false);
+    XlsContainer container = getCurrentContainer();
+    container.setEmpty(false);
     int col = axis.getColumnIndexByCoordinate(data.getRule().getStartCoordinate());


Input:
public Boolean call() throws Exception {
    File addonSlotDir = getAddonBaseDir(addon);
    File descriptor = getAddonDescriptor(addon);
    try {
        if (resources != null && !resources.isEmpty()) {
            for (File resource : resources) {
                if (resource.isDirectory()) {
                    String child = addon.getName() + resource.getParentFile().getParentFile().getName();
                    child = OperatingSystemUtils.getSafeFilename(child);
                    Files.copyDirectory(resource, new File(addonSlotDir, child));
                } else {
                    Files.copyFileToDirectory(resource, addonSlotDir);
                }
            }
        }
        Node addonXml = getXmlRoot(descriptor);
        Node dependenciesNode = addonXml.getOrCreate("String_Node_Str");
        for (AddonDependencyEntry dependency : dependencies) {
            Node dep = dependenciesNode.createChild("String_Node_Str");
            dep.attribute(ATTR_NAME, dependency.getId().getName());
            dep.attribute(ATTR_VERSION, dependency.getId().getVersion());
            dep.attribute(ATTR_EXPORT, dependency.isExported());
            dep.attribute(ATTR_OPTIONAL, dependency.isOptional());
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(descriptor);
            Streams.write(XMLParser.toXMLInputStream(addonXml), fos);
        } finally {
            Streams.closeQuietly(fos);
        }
        return true;
    } catch (IOException io) {
        io.printStackTrace();
        return false;
    }
}

Output:
         Node addonXml = getXmlRoot(descriptor);
-        Node dependenciesNode = addonXml.getOrCreate("String_Node_Str");
+        Node dependenciesNode = addonXml.getOrCreate(DEPENDENCIES_TAG_NAME);
         for (AddonDependencyEntry dependency : dependencies) {


Input:
public void addCoordinate(int value) {
    Integer index = new Integer(value);
    if (!naxis.contains(index)) {
        naxis.add(index);
        Collections.sort(naxis);
    }
}

Output:
 public void addCoordinate(int value) {
-    Integer index = new Integer(value);
-    if (!naxis.contains(index)) {
-        naxis.add(index);
+    if (addCoordinateWithoutSort(value)) {
         Collections.sort(naxis);


Input:
public static String getStringManaCost(List<String> manaCost) {
    StringBuilder sb = new StringBuilder();
    for (String s : manaCost) {
        sb.append(s);
    }
    return sb.toString().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").trim();
}

Output:
     }
-    return sb.toString().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").trim();
+    return sb.toString().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").trim();
 }