Input:
public void primaryViewCellChanged(ViewCell oldViewCell, ViewCell newViewCell) {
    logger.fine("String_Node_Str" + this + "String_Node_Str" + oldViewCell + "String_Node_Str" + newViewCell);
    if (curViewCell != null) {
        curViewCell.removeTransformChangeListener(this);
    }
    curViewCell = newViewCell;
    curViewCell.addTransformChangeListener(this);
}

Output:
     curViewCell = newViewCell;
-    curViewCell.addTransformChangeListener(this);
+    if (curViewCell != null)
+        curViewCell.addTransformChangeListener(this);
 }


Input:
public void onChoice(int choice) {
    if (choice == 0) {
        mCurrentActivity = activity;
        startActivityForResult(mImagePicker, SELECT_PICTURE);
    } else {
        new InputDialog("String_Node_Str", "String_Node_Str", "String_Node_Str", true, false, MITM.this, new InputDialogListener() {
            public void onInputEntered(String input) {
                String image = input.trim();
                if (image.isEmpty() == false) {
                    image = image.startsWith("String_Node_Str") ? image : "String_Node_Str" + image;
                    activity.setVisibility(View.VISIBLE);
                    final String resource = image;
                    mSpoofSession = new SpoofSession();
                    mSpoofSession.start(new OnSessionReadyListener() {
                        public void onSessionReady() {
                            System.getProxy().setFilter(new Proxy.ProxyFilter() {
                                public String onDataReceived(String headers, String data) {
                                    data = data.replaceAll("String_Node_Str", "String_Node_Str" + resource + "String_Node_Str");
                                    data = data.replaceAll("String_Node_Str", "String_Node_Str" + resource + "String_Node_Str");
                                    return data;
                                }
                            });
                        }
                    });
                    Toast.makeText(MITM.this, "String_Node_Str", Toast.LENGTH_LONG).show();
                } else
                    new ErrorDialog("String_Node_Str", "String_Node_Str", MITM.this).show();
            }
        }).show();
    }
}

Output:
     if (choice == 0) {
-        mCurrentActivity = activity;
-        startActivityForResult(mImagePicker, SELECT_PICTURE);
+        try {
+            mCurrentActivity = activity;
+            startActivityForResult(mImagePicker, SELECT_PICTURE);
+        } catch (ActivityNotFoundException e) {
+            new ErrorDialog("String_Node_Str", "String_Node_Str", MITM.this).show();
+        }
     } else {


Input:
private void checkConflict(ItemRecord record) {
    Property property = record.getProperty();
    if (property != null) {
        try {
            List<IRepositoryViewObject> allObjects = DqRepositoryViewService.getAllRepositoryResourceObjects(true);
            for (IRepositoryViewObject object : allObjects) {
                if (record.getProperty() != null && record.getProperty().getId().equals(object.getProperty().getId())) {
                    record.setConflictObject(object);
                    record.addError("String_Node_Str" + record.getName() + "String_Node_Str");
                    break;
                }
            }
        } catch (Exception e) {
            record.addError("String_Node_Str" + record.getName() + "String_Node_Str");
        }
    }
}

Output:
             for (IRepositoryViewObject object : allObjects) {
-                if (record.getProperty() != null && record.getProperty().getId().equals(object.getProperty().getId())) {
+                if (isConflict(property, object.getProperty())) {
                     record.setConflictObject(object);


Input:
public Profile findProfile(int profileId) throws IOException {
    int index = getProfileOffsetSearch().binarySearch(profileId);
    return index < 0 ? null : profiles.get(profileOffsets.get(index).getOffset());
}

Output:
 public Profile findProfile(int profileId) throws IOException {
-    int index = getProfileOffsetSearch().binarySearch(profileId);
+    int index = getProfileOffsetSearch().binarySearch(profileId).getIndex();
     return index < 0 ? null : profiles.get(profileOffsets.get(index).getOffset());


Input:
public void loadTexture(PTexture.Parameters params) {
    if (texture == null) {
        texture = new PTexture(parent, width, height, params);
        texUpdated = false;
    }
    if (pixels != null) {
        pixelsToTexture();
    }
}

Output:
     }
-    if (pixels != null) {
+    if (pixels == null) {
+        loadPixels();
+    } else {
         pixelsToTexture();


Input:
public static void main(String[] args) throws Exception {
    String inFile = null;
    int kmerSize = DEFAULT_KMER_SIZE;
    double threshold = DEFAULT_THRESHOLD;
    int numWords = DEFAULT_NUM_WORDS;
    int numThreads = Runtime.getRuntime().availableProcessors() * 2;
    for (int i = 0; i < args.length; i++) {
        if (args[i].trim().equalsIgnoreCase("String_Node_Str")) {
            kmerSize = Integer.parseInt(args[++i]);
        } else if (args[i].trim().equalsIgnoreCase("String_Node_Str")) {
            inFile = args[++i];
        } else if (args[i].trim().equalsIgnoreCase("String_Node_Str")) {
            numWords = Integer.parseInt(args[++i]);
        } else if (args[i].trim().equalsIgnoreCase("String_Node_Str")) {
            threshold = Double.parseDouble(args[++i]);
        }
    }
    System.err.println("String_Node_Str" + inFile);
    System.err.println("String_Node_Str" + kmerSize);
    System.err.println("String_Node_Str" + threshold);
    System.err.println("String_Node_Str" + numWords);
    LogManager.getLogManager().reset();
    double kmerError = MinHashSearch.probabilityKmerMatches(DEFAULT_DATA_ERROR, kmerSize);
    System.out.println("String_Node_Str" + kmerError);
    long startTime = System.nanoTime();
    FastaData data = new FastaData(inFile);
    MinHashSearch hashSearch = new MinHashSearch(data.clone(), kmerSize, numWords, DEFAULT_NUM_MIN_MATCHES, DEFAULT_SUB_SEQUENCE_SIZE, numThreads, DEFAULT_LARGE_MEMORY, true, null);
    System.err.println("String_Node_Str" + data.getNumberProcessed() + "String_Node_Str");
    System.err.println("String_Node_Str" + (System.nanoTime() - startTime) * 1.0e-9);
    System.out.println("String_Node_Str" + data.getNumberProcessed() + "String_Node_Str");
    startTime = System.nanoTime();
    ArrayList<MatchResult> results = hashSearch.findMatches(DEFAULT_THRESHOLD);
    System.err.println("String_Node_Str" + (System.nanoTime() - startTime) * 1.0e-9);
    ArrayList<MatchResult> mixedResults = new ArrayList<MatchResult>();
    Collections.sort(results);
    mixedResults.addAll(results.subList(0, Math.min(results.size(), 100)));
    mixedResults.addAll(results.subList(Math.max(0, results.size() - 50), results.size()));
    System.out.println("String_Node_Str" + results.size() + "String_Node_Str");
    Matrix matrix = MatrixLoader.load("String_Node_Str");
    int count = 0;
    double mean = 0;
    for (MatchResult match : mixedResults) {
        Sequence s1 = data.getSequence(match.getFromId());
        Sequence s2 = data.getSequence(match.getToId());
        double score = computeAlignment(s1, s2, matrix);
        System.out.format("String_Node_Str", match, match.getScore(), score);
        mean += match.getScore();
        count++;
        if (count > 200)
            break;
    }
    mean = mean / count;
    System.out.println("String_Node_Str" + mean);
}

Output:
     FastaData data = new FastaData(inFile);
-    MinHashSearch hashSearch = new MinHashSearch(data.clone(), kmerSize, numWords, DEFAULT_NUM_MIN_MATCHES, DEFAULT_SUB_SEQUENCE_SIZE, numThreads, DEFAULT_LARGE_MEMORY, true, null);
+    MinHashSearch hashSearch = new MinHashSearch(data.clone(), kmerSize, numWords, DEFAULT_NUM_MIN_MATCHES, DEFAULT_SUB_SEQUENCE_SIZE, numThreads, DEFAULT_LARGE_MEMORY, true, null, 800);
     System.err.println("String_Node_Str" + data.getNumberProcessed() + "String_Node_Str");


Input:
private float getBigramProbability(WordSequence wordSequence) {
    String firstWord = wordSequence.getWord(0);
    if (numberBigrams == 0 || firstWord == null) {
        return getUnigramProbability(wordSequence.getNewest());
    }
    if (!hasUnigram(wordSequence.getWord(1))) {
        throw new Error("String_Node_Str" + wordSequence.getWord(1));
    }
    int firstWordID = getWordID(firstWord);
    int numberBigramFollowers = unigrams[firstWordID + 1].getFirstBigramEntry() - unigrams[firstWordID].getFirstBigramEntry();
    int secondWordID = getWordID(wordSequence.getWord(1));
    BigramProbability bigram = null;
    if (numberBigramFollowers > 0) {
        BigramFollowers bigramFollowers = loadBigramFollowers(firstWordID);
        bigram = bigramFollowers.findBigram(secondWordID);
    }
    if (bigram != null) {
        return bigramProbTable[bigram.getProbabilityID()];
    } else {
        return (unigrams[firstWordID].getLogBackoff() + unigrams[secondWordID].getLogProbability());
    }
}

Output:
 private float getBigramProbability(WordSequence wordSequence) {
-    String firstWord = wordSequence.getWord(0);
+    String firstWord = wordSequence.getWord(0).toLowerCase();
+    String secondWord = wordSequence.getWord(1).toLowerCase();
+    System.out.println("String_Node_Str" + firstWord + "String_Node_Str" + secondWord);
     if (numberBigrams == 0 || firstWord == null) {


Input:
public SerializableImage getImage() {
    if (cachedImage != null) {
        return cachedImage;
    }
    try {
        int errorLength = hasErrorHeader(imageData) ? 4 : 0;
        ByteArrayInputStream bis = new ByteArrayInputStream(imageData.getArray(), imageData.getPos() + errorLength, imageData.getLength() - errorLength);
        BufferedImage image = ImageHelper.read(bis);
        if (image == null) {
            Logger.getLogger(DefineBitsJPEG3Tag.class.getName()).log(Level.SEVERE, "String_Node_Str");
            return null;
        }
        SerializableImage img = new SerializableImage(image);
        if (bitmapAlphaData.getLength() == 0) {
            if (Configuration.cacheImages.get()) {
                cachedImage = img;
            }
            return img;
        }
        byte[] alphaData = SWFInputStream.uncompressByteArray(bitmapAlphaData.getRangeData());
        int[] pixels = ((DataBufferInt) img.getRaster().getDataBuffer()).getData();
        for (int i = 0; i < pixels.length; i++) {
            int a = alphaData[i] & 0xff;
            pixels[i] = multiplyAlpha((pixels[i] & 0xffffff) | (a << 24));
        }
        if (Configuration.cacheImages.get()) {
            cachedImage = img;
        }
        return img;
    } catch (IOException ex) {
        Logger.getLogger(DefineBitsJPEG3Tag.class.getName()).log(Level.SEVERE, "String_Node_Str", ex);
    }
    return null;
}

Output:
         }
-        byte[] alphaData = SWFInputStream.uncompressByteArray(bitmapAlphaData.getRangeData());
+        byte[] alphaData = getImageAlpha();
         int[] pixels = ((DataBufferInt) img.getRaster().getDataBuffer()).getData();


Input:
private Parameter[] getParametersForTypes(String[] signatures) {
    int n = signatures.length;
    Parameter[] parameters = new Parameter[n];
    for (int i = 0; i < n; i += 1) {
        parameters[i] = new Parameter(ClassHelper.makeWithoutCaching(Signature.toString(signatures[i])), null);
    }
    return parameters;
}

Output:
     for (int i = 0; i < n; i += 1) {
-        parameters[i] = new Parameter(ClassHelper.makeWithoutCaching(Signature.toString(signatures[i])), null);
+        parameters[i] = new Parameter(javaTypeToGroovyClass(signatures[i]), null);
     }


Input:
public Var createLocalValueVariable(Type type, Var var) throws UserException {
    String varName;
    VarProvenance prov;
    if (var != null) {
        prov = VarProvenance.valueOf(var, getSourceLoc());
        varName = var.name();
    } else {
        prov = VarProvenance.exprTmp(getSourceLoc());
        varName = null;
    }
    Alloc storage;
    if (Types.isPrimValue(type)) {
        storage = Alloc.LOCAL;
    } else {
        storage = Alloc.ALIAS;
    }
    String name = chooseVariableName(Var.LOCAL_VALUE_VAR_PREFIX, varName, "String_Node_Str");
    return declareVariable(type, name, storage, DefType.LOCAL_COMPILER, prov, null);
}

Output:
     Alloc storage;
-    if (Types.isPrimValue(type)) {
+    if (Types.isPrimValue(type) || Types.isContainerLocal(type)) {
         storage = Alloc.LOCAL;


Input:
private void loadTest() throws IOException {
    AnnoSentenceReaderPrm prm = getDefaultReaderPrm();
    prm.name = "String_Node_Str";
    prm.maxNumSentences = testMaxNumSentences;
    prm.maxSentenceLength = testMaxSentenceLength;
    AnnoSentenceReader reader = new AnnoSentenceReader(prm);
    reader.loadSents(test, testType);
    testGoldSents = reader.getData();
    testGoldSents = testGoldSents.getWithAtsRemoved(getRemoveAts());
    if (testGoldOut != null) {
        AnnoSentenceWriterPrm wPrm = new AnnoSentenceWriterPrm();
        wPrm.name = "String_Node_Str";
        AnnoSentenceWriter writer = new AnnoSentenceWriter(wPrm);
        writer.write(testGoldOut, getTestTypeOut(), testGoldSents);
    }
    testInputSents = testGoldSents.getWithAtsRemoved(getGoldOnlyAts());
}

Output:
     testGoldSents = testGoldSents.getWithAtsRemoved(getRemoveAts());
-    if (testGoldOut != null) {
+    if (testGoldSents != null && testGoldOut != null) {
         AnnoSentenceWriterPrm wPrm = new AnnoSentenceWriterPrm();


Input:
public void onResponse(JSONObject jsonObject) {
    if (jsonObject != null && callback != null) {
        JSONObject errors = jsonObject.optJSONObject("String_Node_Str");
        int errorredUsernameCount = 0;
        if (errors != null) {
            for (String username : usernames) {
                JSONObject userError = errors.optJSONObject(username);
                if (userError == null) {
                    continue;
                }
                errorredUsernameCount++;
                switch(userError.optString("String_Node_Str")) {
                    case "String_Node_Str":
                        switch(userError.optString("String_Node_Str")) {
                            case "String_Node_Str":
                                callback.onUsernameValidation(username, ValidationResult.USER_NOT_FOUND);
                                continue;
                            case "String_Node_Str":
                                callback.onUsernameValidation(username, ValidationResult.INVALID_EMAIL);
                                continue;
                        }
                        break;
                    case "String_Node_Str":
                        callback.onUsernameValidation(username, ValidationResult.ALREADY_MEMBER);
                        continue;
                    case "String_Node_Str":
                        callback.onUsernameValidation(username, ValidationResult.ALREADY_FOLLOWING);
                        continue;
                    case "String_Node_Str":
                        callback.onUsernameValidation(username, ValidationResult.BLOCKED_INVITES);
                        continue;
                }
                callback.onError();
                callback.onValidationFinished();
                return;
            }
        }
        JSONArray succeededUsernames = jsonObject.optJSONArray("String_Node_Str");
        if (succeededUsernames == null) {
            callback.onError();
            callback.onValidationFinished();
            return;
        }
        int succeededUsernameCount = 0;
        for (int i = 0; i < succeededUsernames.length(); i++) {
            String username = succeededUsernames.optString(i);
            if (usernames.contains(username)) {
                succeededUsernameCount++;
                callback.onUsernameValidation(username, ValidationResult.USER_FOUND);
            }
        }
        if (errorredUsernameCount + succeededUsernameCount != usernames.size()) {
            callback.onError();
            callback.onValidationFinished();
        }
        callback.onValidationFinished();
    }
}

Output:
                             case "String_Node_Str":
-                                callback.onUsernameValidation(username, ValidationResult.USER_NOT_FOUND);
+                                callback.onUsernameValidation(username, ValidationResult.INVALID_EMAIL);
                                 continue;


Input:
public double getDistance() {
    return wrappedNNS.getDistance();
}

Output:
 public double getDistance() {
-    return wrappedNNS.getDistance();
+    return wrappedINNS.getDistance();
 }


Input:
public boolean checkHiveConnection(IMetadataConnection metadataConn) {
    try {
        HiveConnectionManager.getInstance().checkConnection(metadataConn);
        isValide = true;
        messageException = Messages.getString("String_Node_Str");
    } catch (ClassNotFoundException e) {
        isValide = false;
        messageException = ExceptionUtils.getFullStackTrace(e);
        CommonExceptionHandler.process(e);
    } catch (InstantiationException e) {
        isValide = false;
        messageException = ExceptionUtils.getFullStackTrace(e);
        CommonExceptionHandler.process(e);
    } catch (IllegalAccessException e) {
        isValide = false;
        messageException = ExceptionUtils.getFullStackTrace(e);
        CommonExceptionHandler.process(e);
    } catch (SQLException e) {
        isValide = false;
        messageException = ExceptionUtils.getFullStackTrace(e);
        CommonExceptionHandler.process(e);
    }
    return isValide;
}

Output:
         messageException = Messages.getString("String_Node_Str");
-    } catch (ClassNotFoundException e) {
-        isValide = false;
-        messageException = ExceptionUtils.getFullStackTrace(e);
-        CommonExceptionHandler.process(e);
-    } catch (InstantiationException e) {
-        isValide = false;
-        messageException = ExceptionUtils.getFullStackTrace(e);
-        CommonExceptionHandler.process(e);
-    } catch (IllegalAccessException e) {
-        isValide = false;
-        messageException = ExceptionUtils.getFullStackTrace(e);
-        CommonExceptionHandler.process(e);
-    } catch (SQLException e) {
+    } catch (Exception e) {
         isValide = false;


Input:
public static List<Document> fetchDocuments(IndexReader reader, ResetableDocumentStoredFieldVisitor fieldSelector, Selector selector, int maxHeap, String context, Term primeDocTerm, Filter filter, AtomicBoolean moreToFetch, AtomicInteger totalRecords, BlurHighlighter highlighter) throws IOException {
    if (highlighter == null) {
        highlighter = new BlurHighlighter();
    }
    if (reader instanceof BaseCompositeReader) {
        BaseCompositeReader<IndexReader> indexReader = (BaseCompositeReader<IndexReader>) reader;
        List<? extends IndexReader> sequentialSubReaders = BaseCompositeReaderUtil.getSequentialSubReaders(indexReader);
        String locationId = selector.getLocationId();
        int indexOf = locationId.indexOf('/');
        if (indexOf < 0) {
            throw new IOException("String_Node_Str" + locationId + "String_Node_Str");
        }
        int notAdjustedPrimeDocId = Integer.parseInt(locationId.substring(indexOf + 1));
        int readerIndex = BaseCompositeReaderUtil.readerIndex(indexReader, notAdjustedPrimeDocId);
        int readerBase = BaseCompositeReaderUtil.readerBase(indexReader, readerIndex);
        int primeDocId = notAdjustedPrimeDocId - readerBase;
        IndexReader orgReader = sequentialSubReaders.get(readerIndex);
        SegmentReader sReader = AtomicReaderUtil.getSegmentReader(orgReader);
        if (sReader != null) {
            SegmentReader segmentReader = (SegmentReader) sReader;
            Bits liveDocs = segmentReader.getLiveDocs();
            OpenBitSet bitSet = PrimeDocCache.getPrimeDocBitSet(primeDocTerm, segmentReader);
            int nextPrimeDoc = bitSet.nextSetBit(primeDocId + 1);
            int numberOfDocsInRow;
            if (nextPrimeDoc == -1) {
                numberOfDocsInRow = segmentReader.maxDoc() - primeDocId;
            } else {
                numberOfDocsInRow = nextPrimeDoc - primeDocId;
            }
            OpenBitSet docsInRowSpanToFetch = getDocsToFetch(segmentReader, selector, primeDocId, numberOfDocsInRow, liveDocs, filter, totalRecords);
            int start = selector.getStartRecord();
            int maxDocsToFetch = selector.getMaxRecordsToFetch();
            int startingPosition = getStartingPosition(docsInRowSpanToFetch, start);
            List<Document> docs = new ArrayList<Document>();
            if (startingPosition < 0) {
                return docs;
            }
            int totalHeap = 0;
            Tracer trace2 = Trace.trace("String_Node_Str");
            int cursor = 0;
            try {
                for (cursor = startingPosition; cursor < numberOfDocsInRow; cursor++) {
                    if (maxDocsToFetch <= 0) {
                        return docs;
                    }
                    if (totalHeap >= maxHeap) {
                        LOG.warn("String_Node_Str", totalHeap, maxHeap, context, selector);
                        return docs;
                    }
                    if (docsInRowSpanToFetch.fastGet(cursor)) {
                        maxDocsToFetch--;
                        int docID = primeDocId + cursor;
                        segmentReader.document(docID, fieldSelector);
                        Document document = fieldSelector.getDocument();
                        if (highlighter.shouldHighlight()) {
                            docs.add(highlighter.highlight(docID, document, segmentReader));
                        } else {
                            docs.add(document);
                        }
                        totalHeap += fieldSelector.getSize();
                        fieldSelector.reset();
                    }
                }
            } finally {
                if (docsInRowSpanToFetch.nextSetBit(cursor) != -1) {
                    moreToFetch.set(true);
                }
                trace2.done();
            }
            return orderDocsBasedOnFamilyOrder(docs, selector);
        } else {
            throw new IOException("String_Node_Str" + orgReader + "String_Node_Str");
        }
    }
    throw new IOException("String_Node_Str" + reader + "String_Node_Str");
}

Output:
         IndexReader orgReader = sequentialSubReaders.get(readerIndex);
-        SegmentReader sReader = AtomicReaderUtil.getSegmentReader(orgReader);
-        if (sReader != null) {
-            SegmentReader segmentReader = (SegmentReader) sReader;
-            Bits liveDocs = segmentReader.getLiveDocs();
-            OpenBitSet bitSet = PrimeDocCache.getPrimeDocBitSet(primeDocTerm, segmentReader);
+        if (orgReader != null && orgReader instanceof AtomicReader) {
+            AtomicReader atomicReader = (AtomicReader) orgReader;
+            Bits liveDocs = atomicReader.getLiveDocs();
+            OpenBitSet bitSet = PrimeDocCache.getPrimeDocBitSet(primeDocTerm, atomicReader);
             int nextPrimeDoc = bitSet.nextSetBit(primeDocId + 1);


Input:
public boolean process(String idOfComponent, String appId, String instanceId) {
    boolean statusChanged;
    statusChanged = doProcess(idOfComponent, appId, instanceId);
    if (statusChanged) {
        return statusChanged;
    }
    if (nextProcessor != null) {
        return nextProcessor.process(idOfComponent, appId, instanceId);
    } else {
        log.warn(String.format("String_Node_Str", idOfComponent, instanceId));
    }
    return false;
}

Output:
     if (statusChanged) {
-        return statusChanged;
+        return true;
     }


Input:
public void testGetInputsToCompareToOutput() {
    DirectoryTraverser traverser = new DirectoryTraverser() {
        public void traverse(DirectoryTraversal traversal) {
            String rootPath = traversal.getRoot().getPath();
            if ("String_Node_Str".equals(rootPath)) {
                traversal.visit(null, "String_Node_Str");
                traversal.visit(null, "String_Node_Str");
                traversal.visit(null, "String_Node_Str");
            } else {
                throw new RuntimeException("String_Node_Str" + rootPath);
            }
        }
    };
    BuildTarget buildTarget = BuildTargetFactory.newInstance("String_Node_Str", "String_Node_Str");
    BuildRuleParams buildRuleParams = new BuildRuleParams(buildTarget, ImmutableSortedSet.<BuildRule>of(), ImmutableSet.of(BuildTargetPattern.MATCH_ALL));
    PrebuiltNativeLibraryBuildRule nativeLibraryRule = new PrebuiltNativeLibraryBuildRule(buildRuleParams, "String_Node_Str", traverser);
    BuildContext context = null;
    MoreAsserts.assertListEquals("String_Node_Str" + "String_Node_Str" + "String_Node_Str", ImmutableList.of("String_Node_Str", "String_Node_Str", "String_Node_Str"), nativeLibraryRule.getInputsToCompareToOutput(context));
}

Output:
     BuildContext context = null;
-    MoreAsserts.assertListEquals("String_Node_Str" + "String_Node_Str" + "String_Node_Str", ImmutableList.of("String_Node_Str", "String_Node_Str", "String_Node_Str"), nativeLibraryRule.getInputsToCompareToOutput(context));
+    MoreAsserts.assertIterablesEquals("String_Node_Str" + "String_Node_Str" + "String_Node_Str", ImmutableList.of("String_Node_Str", "String_Node_Str", "String_Node_Str"), nativeLibraryRule.getInputsToCompareToOutput(context));
 }


Input:
public int getNumber() {
    if (isEntryBlock()) {
        return 0;
    } else if (isExitBlock()) {
        return getNumberOfNodes() - 1;
    } else {
        return instructionIndex;
    }
}

Output:
     } else {
-        return instructionIndex;
+        return instructionIndex + 1;
     }


Input:
public ICompletableFuture executeOnKeyInternal(Data key, EntryProcessor entryProcessor, ExecutionCallback callback) {
    final NodeEngine nodeEngine = getNodeEngine();
    int partitionId = nodeEngine.getPartitionService().getPartitionId(key);
    EntryOperation operation = new EntryOperation(name, key, entryProcessor);
    operation.setThreadId(ThreadUtil.getThreadId());
    try {
        if (callback == null) {
            return nodeEngine.getOperationService().invokeOnPartition(SERVICE_NAME, operation, partitionId);
        } else {
            return nodeEngine.getOperationService().createInvocationBuilder(SERVICE_NAME, operation, partitionId).setCallback(new MapExecutionCallbackAdapter(callback)).invoke();
        }
    } catch (Throwable t) {
        throw ExceptionUtil.rethrow(t);
    }
}

Output:
         } else {
-            return nodeEngine.getOperationService().createInvocationBuilder(SERVICE_NAME, operation, partitionId).setCallback(new MapExecutionCallbackAdapter(callback)).invoke();
+            ICompletableFuture future = nodeEngine.getOperationService().createInvocationBuilder(SERVICE_NAME, operation, partitionId).setCallback(new MapExecutionCallbackAdapter(callback)).invoke();
+            invalidateLocalNearCache(key);
+            return future;
         }


Input:
public AssociationKey readObject(ObjectInput input) throws IOException, ClassNotFoundException {
    input.readInt();
    String tableName = input.readUTF();
    String[] columnNames = (String[]) input.readObject();
    Object[] values = (Object[]) input.readObject();
    AssociationKeyMetadata associationKeyMetadata = new AssociationKeyMetadata(tableName, columnNames, null);
    return new AssociationKey(associationKeyMetadata, values, null, null, null);
}

Output:
     Object[] values = (Object[]) input.readObject();
-    AssociationKeyMetadata associationKeyMetadata = new AssociationKeyMetadata(tableName, columnNames, null);
+    AssociationKeyMetadata associationKeyMetadata = new AssociationKeyMetadata(tableName, columnNames, null, null, null, null);
     return new AssociationKey(associationKeyMetadata, values, null, null, null);


Input:
protected void loadCoreData(final String group) {
    ImmutableMap.Builder<String, Object> builder;
    switch(group) {
        case CHAMPION_MASTERY_LOAD_GROUP:
            builder = ImmutableMap.builder();
            if (coreData.getSummonerId() != 0L) {
                builder.put("String_Node_Str", coreData.getSummonerId());
            }
            if (coreData.getChampionId() != 0) {
                builder.put("String_Node_Str", coreData.getChampionId());
            }
            if (coreData.getPlatform() != null) {
                builder.put("String_Node_Str", Platform.withTag(coreData.getPlatform()));
            }
            coreData = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMastery.class, builder.build());
            break;
        default:
            break;
    }
}

Output:
             }
-            coreData = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMastery.class, builder.build());
+            final com.merakianalytics.orianna.types.data.championmastery.ChampionMastery data = Orianna.getSettings().getPipeline().get(com.merakianalytics.orianna.types.data.championmastery.ChampionMastery.class, builder.build());
+            if (data != null) {
+                coreData = data;
+            }
             break;


Input:
protected boolean checkStateBasedActions() {
    boolean somethingHappened = false;
    for (Player player : state.getPlayers().values()) {
        if (!player.hasLost() && (player.getLife() <= 0 || player.isEmptyDraw() || player.getCounters().getCount(CounterType.POISON) >= 10)) {
            player.lost(this);
        }
    }
    List<Permanent> planeswalkers = new ArrayList<Permanent>();
    List<Permanent> legendary = new ArrayList<Permanent>();
    for (Permanent perm : getBattlefield().getAllActivePermanents()) {
        if (perm.getCardType().contains(CardType.CREATURE)) {
            if (perm.getToughness().getValue() <= 0) {
                if (perm.moveToZone(Zone.GRAVEYARD, null, this, false)) {
                    somethingHappened = true;
                    continue;
                }
            } else if (perm.getToughness().getValue() <= perm.getDamage() || perm.isDeathtouched()) {
                if (perm.destroy(null, this, false)) {
                    somethingHappened = true;
                    continue;
                }
            }
            if (perm.getPairedCard() != null) {
                Permanent paired = getPermanent(perm.getPairedCard());
                if (paired == null || !perm.getControllerId().equals(paired.getControllerId()) || paired.getPairedCard() == null) {
                    perm.setPairedCard(null);
                    if (paired != null) {
                        paired.setPairedCard(null);
                    }
                    somethingHappened = true;
                }
            }
        } else if (perm.getPairedCard() != null) {
            Permanent paired = getPermanent(perm.getPairedCard());
            perm.setPairedCard(null);
            if (paired != null) {
                paired.setPairedCard(null);
            }
            somethingHappened = true;
        }
        if (perm.getCardType().contains(CardType.PLANESWALKER)) {
            if (perm.getCounters().getCount(CounterType.LOYALTY) == 0) {
                if (perm.moveToZone(Zone.GRAVEYARD, null, this, false)) {
                    somethingHappened = true;
                    continue;
                }
            }
            planeswalkers.add(perm);
        }
        if (filterAura.match(perm, this)) {
            if (perm.getAttachedTo() == null) {
                if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
                    somethingHappened = true;
            } else {
                Target target = perm.getSpellAbility().getTargets().get(0);
                if (target instanceof TargetPermanent) {
                    Permanent attachedTo = getPermanent(perm.getAttachedTo());
                    if (attachedTo == null) {
                        if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
                            somethingHappened = true;
                    } else {
                        Filter auraFilter = perm.getSpellAbility().getTargets().get(0).getFilter();
                        if (!auraFilter.match(attachedTo, this) || attachedTo.hasProtectionFrom(perm, this)) {
                            if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
                                somethingHappened = true;
                        }
                    }
                } else if (target instanceof TargetPlayer) {
                    Player attachedTo = getPlayer(perm.getAttachedTo());
                    if (attachedTo == null) {
                        if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
                            somethingHappened = true;
                    } else {
                        Filter auraFilter = perm.getSpellAbility().getTargets().get(0).getFilter();
                        if (!auraFilter.match(attachedTo, this) || attachedTo.hasProtectionFrom(perm, this)) {
                            if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
                                somethingHappened = true;
                        }
                    }
                }
            }
        }
        if (filterLegendary.match(perm, this))
            legendary.add(perm);
        if (filterEquipment.match(perm, this)) {
            if (perm.getAttachedTo() != null) {
                Permanent creature = getPermanent(perm.getAttachedTo());
                if (creature == null) {
                    perm.attachTo(null, this);
                } else if (!creature.getCardType().contains(CardType.CREATURE) || creature.hasProtectionFrom(perm, this)) {
                    if (creature.removeAttachment(perm.getId(), this))
                        somethingHappened = true;
                }
            }
        }
        if (filterFortification.match(perm, this)) {
            if (perm.getAttachedTo() != null) {
                Permanent land = getPermanent(perm.getAttachedTo());
                if (land == null) {
                    perm.attachTo(null, this);
                } else if (!land.getCardType().contains(CardType.LAND) || land.hasProtectionFrom(perm, this)) {
                    if (land.removeAttachment(perm.getId(), this))
                        somethingHappened = true;
                }
            }
        }
        if (perm.getAttachments().size() > 0) {
            for (UUID attachmentId : perm.getAttachments()) {
                Permanent attachment = getPermanent(attachmentId);
                if (attachment != null && !(attachment.getSubtype().contains("String_Node_Str") || attachment.getSubtype().contains("String_Node_Str") || attachment.getSubtype().contains("String_Node_Str"))) {
                    if (perm.removeAttachment(attachment.getId(), this)) {
                        somethingHappened = true;
                        break;
                    }
                }
            }
        }
        if (perm.getCounters().containsKey(CounterType.P1P1) && perm.getCounters().containsKey(CounterType.M1M1)) {
            int p1p1 = perm.getCounters().getCount(CounterType.P1P1);
            int m1m1 = perm.getCounters().getCount(CounterType.M1M1);
            int min = Math.min(p1p1, m1m1);
            perm.getCounters().removeCounter(CounterType.P1P1, min);
            perm.getCounters().removeCounter(CounterType.M1M1, min);
        }
    }
    if (planeswalkers.size() > 1) {
        for (Permanent planeswalker : planeswalkers) {
            for (String planeswalkertype : planeswalker.getSubtype()) {
                FilterPlaneswalkerPermanent filterPlaneswalker = new FilterPlaneswalkerPermanent();
                filterPlaneswalker.add(new SubtypePredicate(planeswalkertype));
                if (getBattlefield().contains(filterPlaneswalker, planeswalker.getControllerId(), this, 2)) {
                    for (Permanent perm : getBattlefield().getActivePermanents(filterPlaneswalker, planeswalker.getControllerId(), this)) {
                        perm.moveToZone(Zone.GRAVEYARD, null, this, false);
                    }
                    return true;
                }
            }
        }
    }
    if (legendary.size() > 1) {
        for (Permanent legend : legendary) {
            FilterPermanent filterLegendName = new FilterPermanent();
            filterLegendName.add(new SupertypePredicate("String_Node_Str"));
            filterLegendName.add(new NamePredicate(legend.getName()));
            if (getBattlefield().contains(filterLegendName, legend.getControllerId(), this, 2)) {
                for (Permanent dupLegend : getBattlefield().getActivePermanents(filterLegendName, legend.getControllerId(), this)) {
                    dupLegend.moveToZone(Zone.GRAVEYARD, null, this, false);
                }
                return true;
            }
        }
    }
    return somethingHappened;
}

Output:
             if (perm.getAttachedTo() == null) {
-                if (perm.moveToZone(Zone.GRAVEYARD, null, this, false))
+                if (perm.moveToZone(Zone.GRAVEYARD, null, this, false)) {
                     somethingHappened = true;


Input:
private void updateQuery(final String query) {
    String finalQuery = Utilities.getPreparedQueryForSearch(query);
    ArrayList<ListItem> listItems = new ArrayList<>();
    Cursor teamQueryResults = Database.getInstance(this).getMatchesForTeamQuery(finalQuery);
    if (teamQueryResults != null && teamQueryResults.moveToFirst()) {
        teamQueryResults.moveToPosition(-1);
        teamsHeader = new SearchResultsHeaderListElement(getString(R.string.teams_header));
        if (teamQueryResults.getCount() >= MAX_RESULTS_PER_CATEGORY) {
            teamsHeader.showMoreButton(true);
            teamsHeader.setMoreCount(teamQueryResults.getCount() - MAX_RESULTS_PER_CATEGORY);
        } else {
            teamsHeader.showMoreButton(false);
        }
        listItems.add(teamsHeader);
        while (teamQueryResults.moveToNext()) {
            if (teamQueryResults.getPosition() >= MAX_RESULTS_PER_CATEGORY) {
                break;
            }
            String key = teamQueryResults.getString(teamQueryResults.getColumnIndex(Database.SearchTeam.KEY));
            Team team = Database.getInstance(this).getTeam(key);
            TeamListElement element = new TeamListElement(team);
            listItems.add(element);
            Log.d(Constants.LOG_TAG, "String_Node_Str" + teamQueryResults.getString(teamQueryResults.getColumnIndex(Database.SearchTeam.TITLES)));
        }
    } else {
        teamsHeader = new SearchResultsHeaderListElement(getString(R.string.teams_header));
        teamsHeader.showMoreButton(false);
        listItems.add(teamsHeader);
        listItems.add(new EmptyListElement(getString(R.string.no_teams_found)));
    }
    Cursor eventQueryResults = Database.getInstance(this).getMatchesForEventQuery(finalQuery);
    if (eventQueryResults != null && eventQueryResults.moveToFirst()) {
        eventQueryResults.moveToPosition(-1);
        eventsHeader = new SearchResultsHeaderListElement(getString(R.string.events_header));
        if (eventQueryResults.getCount() >= MAX_RESULTS_PER_CATEGORY) {
            eventsHeader.showMoreButton(true);
            eventsHeader.setMoreCount(teamQueryResults.getCount() - MAX_RESULTS_PER_CATEGORY);
        } else {
            eventsHeader.showMoreButton(false);
        }
        listItems.add(eventsHeader);
        while (eventQueryResults.moveToNext()) {
            if (eventQueryResults.getPosition() >= MAX_RESULTS_PER_CATEGORY) {
                break;
            }
            String key = eventQueryResults.getString(eventQueryResults.getColumnIndex(Database.SearchEvent.KEY));
            Event event = Database.getInstance(this).getEvent(key);
            EventListElement element = new EventListElement(event);
            listItems.add(element);
        }
    } else {
        eventsHeader = new SearchResultsHeaderListElement(getString(R.string.events_header));
        eventsHeader.showMoreButton(false);
        listItems.add(eventsHeader);
        listItems.add(new EmptyListElement(getString(R.string.no_events_found)));
    }
    ListViewAdapter adapter = new ListViewAdapter(this, listItems);
    resultsList.setAdapter(adapter);
    resultsList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
            ListViewAdapter adapter = (ListViewAdapter) adapterView.getAdapter();
            ListItem clickedItem = adapter.getItem(position);
            if (clickedItem instanceof TeamListElement) {
                String teamKey = ((ListElement) clickedItem).getKey();
                Intent i = new Intent(SearchResultsActivity.this, ViewTeamActivity.class);
                i.putExtra(ViewTeamActivity.TEAM_KEY, teamKey);
                startActivity(i);
            } else if (clickedItem instanceof EventListElement) {
                String eventKey = ((ListElement) clickedItem).getKey();
                Intent intent = ViewEventActivity.newInstance(SearchResultsActivity.this, eventKey);
                startActivity(intent);
            } else if (clickedItem == teamsHeader) {
                if (teamsHeader.isShowingMoreButton()) {
                    startActivity(MoreSearchResultsActivity.newInstance(SearchResultsActivity.this, MoreSearchResultsActivity.TEAM_RESULTS, query));
                }
            } else if (clickedItem == eventsHeader) {
                if (eventsHeader.isShowingMoreButton()) {
                    startActivity(MoreSearchResultsActivity.newInstance(SearchResultsActivity.this, MoreSearchResultsActivity.EVENT_RESULTS, query));
                }
            }
        }
    });
}

Output:
         teamsHeader = new SearchResultsHeaderListElement(getString(R.string.teams_header));
-        if (teamQueryResults.getCount() >= MAX_RESULTS_PER_CATEGORY) {
+        if (teamQueryResults.getCount() > MAX_RESULTS_PER_CATEGORY) {
             teamsHeader.showMoreButton(true);


Input:
protected HandshakeResponse respondToOutgoing(HandshakeResponse response) {
    if (!_manager.allowConnection(response)) {
        HandshakingStat.UP_OUTGOING_REJECT_FULL.incrementStat();
        return HandshakeResponse.createRejectOutgoingResponse();
    }
    Properties ret = new Properties();
    if (response.hasLeafGuidance()) {
        if (_manager.allowLeafDemotion() && response.isGoodUltrapeer()) {
            HandshakingStat.UP_OUTGOING_GUIDANCE_FOLLOWED.incrementStat();
            ret.put(HeaderNames.X_ULTRAPEER, "String_Node_Str");
        } else {
            HandshakingStat.UP_OUTGOING_GUIDANCE_IGNORED.incrementStat();
        }
    } else
        HandshakingStat.UP_OUTGOING_ACCEPT.incrementStat();
    if (response.isDeflateAccepted()) {
        ret.put(HeaderNames.CONTENT_ENCODING, HeaderNames.DEFLATE_VALUE);
    }
    return HandshakeResponse.createAcceptOutgoingResponse(ret);
}

Output:
 protected HandshakeResponse respondToOutgoing(HandshakeResponse response) {
-    if (!_manager.allowConnection(response)) {
+    HandshakeStatus status = _manager.allowConnection(response);
+    if (!status.isAcceptable()) {
         HandshakingStat.UP_OUTGOING_REJECT_FULL.incrementStat();


Input:
public synchronized Double sortResults(Map<Integer, AtomAtomMapping> allAtomEnergyMCS, Map<Integer, Double> energySelectionMap) throws CDKException {
    for (Integer Key : allAtomEnergyMCS.keySet()) {
        AtomAtomMapping mcsAtom = allAtomEnergyMCS.get(Key);
        Double Energies = getMappedMoleculeEnergies(mcsAtom);
        energySelectionMap.put(Key, Energies);
    }
    energySelectionMap = sortMapByValueInAscendingOrder(energySelectionMap);
    double lowestEnergyScore = MAX_ENERGY;
    for (Integer key : energySelectionMap.keySet()) {
        lowestEnergyScore = energySelectionMap.get(key);
        break;
    }
    return lowestEnergyScore;
}

Output:
         AtomAtomMapping mcsAtom = allAtomEnergyMCS.get(Key);
-        Double Energies = getMappedMoleculeEnergies(mcsAtom);
-        energySelectionMap.put(Key, Energies);
+        Double energies = getMappedMoleculeEnergies(mcsAtom);
+        energySelectionMap.put(Key, energies);
     }


Input:
protected List<Chunk> optimizeChunkList(final List<Chunk> chunks, final long minimumOffset) {
    Chunk lastChunk = null;
    Collections.sort(chunks);
    final List<Chunk> result = new ArrayList<Chunk>();
    for (final Chunk chunk : chunks) {
        if (chunk.getChunkEnd() <= minimumOffset) {
            continue;
        }
        if (result.isEmpty()) {
            result.add(chunk);
            lastChunk = chunk;
            continue;
        }
        if (!BlockCompressedFilePointerUtil.areInSameOrAdjacentBlocks(lastChunk.getChunkEnd(), chunk.getChunkStart())) {
            result.add(chunk);
            lastChunk = chunk;
        } else {
            if (chunk.getChunkEnd() > lastChunk.getChunkEnd()) {
                lastChunk.setChunkEnd(chunk.getChunkEnd());
            }
        }
    }
    return result;
}

Output:
         }
-        if (!BlockCompressedFilePointerUtil.areInSameOrAdjacentBlocks(lastChunk.getChunkEnd(), chunk.getChunkStart())) {
+        if (!lastChunk.overlaps(chunk) && !lastChunk.isAdjacentTo(chunk)) {
             result.add(chunk);


Input:
public void deleteColumn(String indexColumnFamily, String rowKey, byte[] columnName, String persistenceUnit, ConsistencyLevel consistencyLevel) {
    Mutator mutator = Pelops.createMutator(PelopsUtils.generatePoolName(persistenceUnit));
    mutator.deleteColumn(indexColumnFamily, rowKey, Bytes.fromByteArray(columnName));
    mutator.execute(consistencyLevel);
}

Output:
     Mutator mutator = Pelops.createMutator(PelopsUtils.generatePoolName(persistenceUnit));
-    mutator.deleteColumn(indexColumnFamily, rowKey, Bytes.fromByteArray(columnName));
+    mutator.deleteColumn(indexColumnFamily, rowKey, Bytes.fromByteArray(superColumnName));
     mutator.execute(consistencyLevel);


Input:
protected EndPoint findEndPointInScope(Scope scope, String sqlBase, Long poolId) {
    StringBuilder sbuilder = new StringBuilder();
    sbuilder.append(sqlBase);
    if (scope.getScopeType() == ScopeType.HOST) {
        sbuilder.append("String_Node_Str");
        sbuilder.append(scope.getScopeId());
    } else if (scope.getScopeType() == ScopeType.CLUSTER) {
        sbuilder.append("String_Node_Str");
        sbuilder.append(scope.getScopeId());
    } else if (scope.getScopeType() == ScopeType.ZONE) {
        sbuilder.append("String_Node_Str");
        sbuilder.append(scope.getScopeId());
    }
    sbuilder.append("String_Node_Str");
    String sql = sbuilder.toString();
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    HostVO host = null;
    TransactionLegacy txn = TransactionLegacy.currentTxn();
    try {
        pstmt = txn.prepareStatement(sql);
        pstmt.setLong(1, poolId);
        rs = pstmt.executeQuery();
        while (rs.next()) {
            long id = rs.getLong(1);
            host = hostDao.findById(id);
        }
    } catch (SQLException e) {
        s_logger.warn("String_Node_Str", e);
    } finally {
        try {
            if (rs != null) {
                rs.close();
            }
            if (pstmt != null) {
                pstmt.close();
            }
        } catch (SQLException e) {
        }
    }
    if (host == null) {
        return null;
    }
    return RemoteHostEndPoint.getHypervisorHostEndPoint(host);
}

Output:
     TransactionLegacy txn = TransactionLegacy.currentTxn();
-    try {
-        pstmt = txn.prepareStatement(sql);
+    try (PreparedStatement pstmt = txn.prepareStatement(sql)) {
         pstmt.setLong(1, poolId);


Input:
public void drawBackgroundImage(String imageURI, float x, float y, float width, float height, float positionX, float positionY, int repeat) {
    if (imageURI == null || imageURI.length() == 0) {
        return;
    }
    float imageWidth = 0;
    float imageHeight = 0;
    byte[] imageData = null;
    InputStream imageStream = null;
    try {
        URL url = new URL(imageURI);
        imageStream = url.openStream();
        imageData = getImageData(imageStream);
        imageStream.close();
        imageStream = url.openStream();
        Image image = ImageIO.read(imageStream);
        ImageIcon imageIcon = new ImageIcon(image);
        imageWidth = imageIcon.getIconWidth();
        imageHeight = imageIcon.getIconHeight();
    } catch (IOException ioe) {
        logger.log(Level.WARNING, ioe.getMessage(), ioe);
    } finally {
        if (imageStream != null) {
            try {
                imageStream.close();
            } catch (IOException e) {
            }
        }
    }
    String extension = getImageExtension(imageURI);
    ImageInfo imageInfo = getImageInfo(imageURI, imageData, extension);
    Position areaPosition = new Position(x, y);
    Position areaSize = new Position(width, height);
    Position imagePosition = new Position(x + positionX, y + positionY);
    Position imageSize = new Position(imageWidth, imageHeight);
    BackgroundImageLayout layout = new BackgroundImageLayout(areaPosition, areaSize, imagePosition, imageSize);
    Collection positions = layout.getImagePositions(repeat);
    Iterator iterator = positions.iterator();
    while (iterator.hasNext()) {
        Position position = (Position) iterator.next();
        exportImageDefn(imageInfo.imageName, imageInfo.imageId, imageWidth, imageHeight, position.getX(), position.getY(), null);
    }
}

Output:
     }
-    float imageWidth = 0;
-    float imageHeight = 0;
+    float imageWidth = iWidth;
+    float imageHeight = iHeight;
     byte[] imageData = null;


Input:
public void accept(Void aVoid) throws Exception {
    PushConfigurationState pushConfigurationState = new PushConfigurationState();
    pushConfigurationState.setPushToken(token);
    pushConfigurationState.setDeviceIdentifier(pushRegistrationOverall.getOcs().getData().getDeviceIdentifier());
    pushConfigurationState.setDeviceIdentifierSignature(pushRegistrationOverall.getOcs().getData().getSignature());
    pushConfigurationState.setUserPublicKey(pushRegistrationOverall.getOcs().getData().getPublicKey());
    pushConfigurationState.setUsesRegularPass(false);
    userUtils.createOrUpdateUser(userEntity.getUsername(), userEntity.getToken(), userEntity.getBaseUrl(), userEntity.getDisplayName(), LoganSquare.serialize(pushConfigurationState), null).subscribe(new Consumer<UserEntity>() {

        public void accept(UserEntity userEntity) throws Exception {
        }
    }, new Consumer<Throwable>() {
        public void accept(Throwable throwable) throws Exception {
        }
    });
}

Output:
     pushConfigurationState.setUsesRegularPass(false);
-    userUtils.createOrUpdateUser(userEntity.getUsername(), userEntity.getToken(), userEntity.getBaseUrl(), userEntity.getDisplayName(), LoganSquare.serialize(pushConfigurationState), null).subscribe(new Consumer<UserEntity>() {
+    userUtils.createOrUpdateUser(userEntity.getUsername(), userEntity.getToken(), userEntity.getBaseUrl(), userEntity.getDisplayName(), LoganSquare.serialize(pushConfigurationState), null, null).subscribe(new Consumer<UserEntity>() {


Input:
public static <T extends SurfaceForm, U extends Sense> Collection<Vertex> verticesFromSenses(Graph graph, SurfaceFormSenses<T, U> surfaceFormSenses) {
    Collection<Vertex> vertices = new ArrayList<>(surfaceFormSenses.getSenses().size());
    for (Sense sense : surfaceFormSenses.getSenses()) vertices.add(Graphs.vertexByUri(graph, sense.fullUri()));
    return vertices;
}

Output:
     Collection<Vertex> vertices = new ArrayList<>(surfaceFormSenses.getSenses().size());
-    for (Sense sense : surfaceFormSenses.getSenses()) vertices.add(Graphs.vertexByUri(graph, sense.fullUri()));
+    for (Sense sense : surfaceFormSenses.getSenses()) {
+        Vertex v = Graphs.vertexByUri(graph, sense.fullUri());
+        if (v != null)
+            vertices.add(v);
+        else
+            logger.warn("String_Node_Str", sense.fullUri());
+    }
     return vertices;


Input:
private Document createDocument(RepositoryMetadata repoMetadata) {
    Document doc = new Document();
    doc.add(Field.Keyword(FLD_ID, (String) repoMetadata.getKey()));
    Metadata metadata = repoMetadata.getMetadata();
    doc.add(Field.Text(FLD_NAME, repository.pathOfRemoteRepositoryMetadata(repoMetadata)));
    Versioning versioning = metadata.getVersioning();
    if (versioning != null) {
        doc.add(Field.Text(FLD_LASTUPDATE, versioning.getLastUpdated()));
    } else {
        doc.add(Field.Text(FLD_LASTUPDATE, "String_Node_Str"));
    }
    List plugins = metadata.getPlugins();
    String pluginAppended = "String_Node_Str";
    for (Iterator iter = plugins.iterator(); iter.hasNext(); ) {
        Plugin plugin = (Plugin) iter.next();
        if (plugin.getPrefix() != null && !"String_Node_Str".equals(plugin.getPrefix())) {
            pluginAppended = plugin.getPrefix() + "String_Node_Str";
        }
    }
    doc.add(Field.Text(FLD_PLUGINPREFIX, pluginAppended));
    doc.add(Field.Text(FLD_GROUPID, metadata.getGroupId()));
    if (metadata.getArtifactId() != null && !"String_Node_Str".equals(metadata.getArtifactId())) {
        doc.add(Field.Text(FLD_ARTIFACTID, metadata.getArtifactId()));
    } else {
        doc.add(Field.Text(FLD_ARTIFACTID, "String_Node_Str"));
    }
    if (metadata.getVersion() != null && !"String_Node_Str".equals(metadata.getVersion())) {
        doc.add(Field.Text(FLD_VERSION, metadata.getVersion()));
    } else {
        doc.add(Field.Text(FLD_VERSION, "String_Node_Str"));
    }
    doc.add(Field.Text(FLD_DOCTYPE, METADATA));
    doc.add(Field.Keyword(FLD_PACKAGING, "String_Node_Str"));
    doc.add(Field.Text(FLD_SHA1, "String_Node_Str"));
    doc.add(Field.Text(FLD_MD5, "String_Node_Str"));
    doc.add(Field.Text(FLD_CLASSES, "String_Node_Str"));
    doc.add(Field.Text(FLD_PACKAGES, "String_Node_Str"));
    doc.add(Field.Text(FLD_FILES, "String_Node_Str"));
    doc.add(Field.Keyword(FLD_LICENSE_URLS, "String_Node_Str"));
    doc.add(Field.Keyword(FLD_DEPENDENCIES, "String_Node_Str"));
    doc.add(Field.Keyword(FLD_PLUGINS_BUILD, "String_Node_Str"));
    doc.add(Field.Keyword(FLD_PLUGINS_REPORT, "String_Node_Str"));
    doc.add(Field.Keyword(FLD_PLUGINS_ALL, "String_Node_Str"));
    return doc;
}

Output:
     doc.add(Field.Text(FLD_PLUGINPREFIX, pluginAppended));
-    doc.add(Field.Text(FLD_GROUPID, metadata.getGroupId()));
-    if (metadata.getArtifactId() != null && !"String_Node_Str".equals(metadata.getArtifactId())) {
+    if (metadata.getGroupId() != null) {
+        doc.add(Field.Text(FLD_GROUPID, metadata.getGroupId()));
+    } else {
+        doc.add(Field.Text(FLD_GROUPID, "String_Node_Str"));
+    }
+    if (metadata.getArtifactId() != null) {
         doc.add(Field.Text(FLD_ARTIFACTID, metadata.getArtifactId()));


Input:
public int getInt(String name, int defaultValue) {
    String value = this.getAttribute(name, Integer.toString(defaultValue));
    return Integer.parseInt(value);
}

Output:
 public int getInt(String name, int defaultValue) {
-    String value = this.getAttribute(name, Integer.toString(defaultValue));
-    return Integer.parseInt(value);
+    String value = getString(name);
+    return (value == null) ? defaultValue : PApplet.parseInt(value, defaultValue);
 }


Input:
public void applyContainerBottomStyle(XlsContainer container) {
    ContainerSizeInfo rule = container.getSizeInfo();
    StyleEntry entry = container.getStyle();
    int start = rule.getStartCoordinate();
    int col = engine.getAxis().getColumnIndexByCoordinate(start);
    int span = engine.getAxis().getColumnIndexByCoordinate(rule.getEndCoordinate());
    for (int i = col; i < span; i++) {
        SheetData data = engine.getColumnLastData(i);
        if (data == null) {
            continue;
        }
        StyleBuilder.applyBottomBorder(entry, data.style);
    }
}

Output:
         }
-        StyleBuilder.applyBottomBorder(entry, data.style);
+        if (data.style != null) {
+            StyleBuilder.applyBottomBorder(entry, data.style);
+        }
     }


Input:
public void test() throws Exception {
    if (getSession().getPlatform().isDB2() || getSession().getPlatform().isAccess() || getSession().getPlatform().isSybase()) {
        throw new TestWarningException("String_Node_Str");
    }
    if ((getSession().getPlatform().isMySQL() || getSession().getPlatform().isTimesTen()) && (lockMode == org.eclipse.persistence.queries.ObjectBuildingQuery.LOCK_NOWAIT)) {
        throw new TestWarningException("String_Node_Str");
    }
    uow = getSession().acquireUnitOfWork();
    this.employeeObject = (Employee) uow.registerObject(employeeObject);
    city = employeeObject.getAddress().getCity();
    employeeObject.getAddress().setCity("String_Node_Str");
    startTime = employeeObject.getStartTime();
    employeeObject.setStartTime(null);
    endDate = employeeObject.getPeriod().getEndDate();
    employeeObject.getPeriod().setEndDate(null);
    managerName = employeeObject.getManager().getFirstName();
    employeeObject.getManager().setFirstName("String_Node_Str");
    collectionSize = employeeObject.getPhoneNumbers().size();
    employeeObject.getPhoneNumbers().removeAllElements();
    responsibilityListSize = employeeObject.getResponsibilitiesList().size();
    employeeObject.getResponsibilitiesList().removeAllElements();
    uow.refreshAndLockObject(employeeObject, (short) this.lockMode);
    DatabaseSession session2 = null;
    UnitOfWork uow2 = null;
    try {
        if (getSession() instanceof org.eclipse.persistence.sessions.remote.RemoteSession) {
            session2 = org.eclipse.persistence.testing.tests.remote.RemoteModel.getServerSession().getProject().createDatabaseSession();
        } else {
            session2 = getSession().getProject().createDatabaseSession();
        }
        session2.setSessionLog(getSession().getSessionLog());
        session2.login();
        uow2 = session2.acquireUnitOfWork();
        boolean isLocked = false;
        Object result = null;
        try {
            result = uow2.refreshAndLockObject(employeeObject, org.eclipse.persistence.queries.ObjectBuildingQuery.LOCK_NOWAIT);
        } catch (EclipseLinkException exeception) {
            session2.logMessage(exeception.toString());
            isLocked = true;
        }
        if (result == null) {
            isLocked = true;
        }
        if (!isLocked) {
            throw new TestWarningException("String_Node_Str");
        }
    } catch (RuntimeException e) {
        if (uow2 != null) {
            uow2.release();
        }
        if (session2 != null) {
            session2.logout();
        }
        throw e;
    }
}

Output:
     }
-    if ((getSession().getPlatform().isMySQL() || getSession().getPlatform().isTimesTen()) && (lockMode == org.eclipse.persistence.queries.ObjectBuildingQuery.LOCK_NOWAIT)) {
+    if ((getSession().getPlatform().isMySQL()) && (lockMode == org.eclipse.persistence.queries.ObjectBuildingQuery.LOCK_NOWAIT)) {
         throw new TestWarningException("String_Node_Str");


Input:
private void mouseMotionCB(MouseEvent e) {
    if (!cc.viewer.viewOnly.getValue())
        cc.writePointerEvent(e);
    if (cursorAvailable) {
        if (e.getX() != cursorPosX || e.getY() != cursorPosY) {
            hideLocalCursor();
            if (e.getX() >= 0 && e.getX() < im.width() && e.getY() >= 0 && e.getY() < im.height()) {
                cursorPosX = e.getX();
                cursorPosY = e.getY();
                if (softCursor == null)
                    showLocalCursor();
            }
        }
    }
    lastX = e.getX();
    lastY = e.getY();
}

Output:
                 cursorPosY = e.getY();
-                if (softCursor == null)
+                if (!cc.cp.supportsLocalCursor)
                     showLocalCursor();


Input:
public StackElementLength[] getPushes() {
    return pushes;
}

Output:
 public StackElementLength[] getPushes() {
-    return pushes;
+    return new StackElementLength[] { this.returnType };
 }


Input:
public void testGetRecentGames() throws Exception {
    try {
        handler.getRecentGames(SUMMONER_ID_2).get(1, MINUTES);
    } catch (RequestException ex) {
        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
            throw ex;
    }
}

Output:
     } catch (RequestException ex) {
-        if (ex.getErrorType().code < 500 || ex.getErrorType().code > 599)
+        if (isNotServerside(ex))
             throw ex;


Input:
private void removeConditional(ManaType manaType, Ability ability, Game game) {
    for (ConditionalMana mana : getConditionalMana()) {
        if (mana.get(manaType) > 0 && mana.apply(ability, game, mana.getManaProducerId())) {
            mana.set(manaType, mana.get(manaType) - 1);
            game.fireEvent(new GameEvent(GameEvent.EventType.MANA_PAYED, ability.getId(), mana.getManaProducerId(), ability.getControllerId()));
            break;
        }
    }
}

Output:
             mana.set(manaType, mana.get(manaType) - 1);
-            game.fireEvent(new GameEvent(GameEvent.EventType.MANA_PAYED, ability.getId(), mana.getManaProducerId(), ability.getControllerId()));
+            game.fireEvent(new GameEvent(GameEvent.EventType.MANA_PAYED, ability.getId(), mana.getManaProducerId(), ability.getControllerId(), 0, mana.getFlag()));
             break;


Input:
private void generateElement(ElementDefn root, ElementDefn e, String paramType, Map<String, String> rules) throws Exception {
    List<TypeRef> types = e.getTypes();
    if (types.size() > 1 || (types.size() == 1 && types.get(0).isWildcardType())) {
        if (!e.getName().contains("String_Node_Str"))
            throw new Exception("String_Node_Str" + e.getName() + "String_Node_Str" + root.getName());
        if ((types.size() == 1 && types.get(0).isWildcardType())) {
            generateAny(root, e, e.getName().replace("String_Node_Str", "String_Node_Str"), null);
        } else {
            String close = "String_Node_Str";
            ;
            if (!forCodeGeneration) {
                write("String_Node_Str" + checkRule(e.getMinCardinality().toString(), e.getName() + "String_Node_Str", rules) + "String_Node_Str");
                if (e.hasDefinition()) {
                    write("String_Node_Str");
                    write("String_Node_Str" + Utilities.escapeXml(checkRule(e.getDefinition(), e.getName() + "String_Node_Str", rules)) + "String_Node_Str");
                    write("String_Node_Str");
                }
                close = "String_Node_Str";
            }
            for (TypeRef t : types) {
                String type = encodeType(e, t, true);
                String name = e.getName().substring(0, e.getName().length() - 3) + nameForType(type);
                write("String_Node_Str" + name + "String_Node_Str" + type + "String_Node_Str");
                if (e.unbounded())
                    write("String_Node_Str" + checkRule("String_Node_Str", e.getName() + "String_Node_Str", rules) + "String_Node_Str" + close + "String_Node_Str");
                else
                    write("String_Node_Str" + checkRule("String_Node_Str", e.getName() + "String_Node_Str", rules) + "String_Node_Str" + close + "String_Node_Str");
                if (forCodeGeneration) {
                    write("String_Node_Str");
                    if (e.hasDefinition()) {
                        write("String_Node_Str" + Utilities.escapeXml(checkRule(e.getDefinition(), e.getName() + "String_Node_Str", rules)) + "String_Node_Str" + e.getName().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str");
                    } else {
                        write("String_Node_Str" + e.getName().replace("String_Node_Str", "String_Node_Str") + "String_Node_Str");
                    }
                    write("String_Node_Str");
                    write("String_Node_Str");
                }
            }
            if (!forCodeGeneration)
                write("String_Node_Str");
        }
    } else {
        write("String_Node_Str");
        if ("String_Node_Str".equals(e.getName()))
            write("String_Node_Str" + e.getName() + "String_Node_Str");
        else if ("String_Node_Str".equals(e.getName()) && e.typeCode().equals("String_Node_Str"))
            write("String_Node_Str");
        else if (e.usesCompositeType()) {
            ElementDefn ref = root.getElementByName(e.typeCode().substring(1));
            String rtn = this.types.get(ref);
            if (rtn == null)
                throw new Exception("String_Node_Str" + types.toString() + "String_Node_Str");
            write("String_Node_Str" + e.getName() + "String_Node_Str" + rtn + "String_Node_Str");
        } else if (types.size() == 0 && e.getElements().size() > 0) {
            String tn = root.getName() + "String_Node_Str" + Utilities.capitalize(e.getName());
            int i = 0;
            while (structures.containsKey(tn)) {
                i++;
                tn = root.getName() + "String_Node_Str" + Utilities.capitalize(e.getName()) + Integer.toString(i);
            }
            write("String_Node_Str" + e.getName() + "String_Node_Str" + tn + "String_Node_Str");
            structures.put(tn, e);
            this.types.put(e, tn);
            typenames.add(tn);
        } else if (types.size() == 1) {
            if (types.get(0).isUnboundGenericParam() && paramType != null)
                write("String_Node_Str" + e.getName() + "String_Node_Str" + paramType + "String_Node_Str");
            else if (!Utilities.noString(e.getRegex())) {
                String tn = root.getName() + Utilities.capitalize(e.getName()) + "String_Node_Str";
                regexQueue.put(tn, e.getRegex());
                write("String_Node_Str" + e.getName() + "String_Node_Str" + tn + "String_Node_Str");
            } else
                write("String_Node_Str" + e.getName() + "String_Node_Str" + encodeType(e, types.get(0), true) + "String_Node_Str");
        } else
            throw new Exception("String_Node_Str" + e.getName() + "String_Node_Str" + root.getName() + "String_Node_Str" + Integer.toString(types.size()));
        write("String_Node_Str" + checkRule(e.getMinCardinality().toString(), e.getName() + "String_Node_Str", rules) + "String_Node_Str");
        if (e.unbounded())
            write("String_Node_Str" + checkRule("String_Node_Str", e.getName() + "String_Node_Str", rules) + "String_Node_Str");
        else
            write("String_Node_Str" + checkRule("String_Node_Str", e.getName() + "String_Node_Str", rules) + "String_Node_Str");
        if (e.hasDefinition()) {
            write("String_Node_Str");
            write("String_Node_Str");
            write("String_Node_Str" + Utilities.escapeXml(checkRule(e.getDefinition(), e.getName() + "String_Node_Str", rules)) + "String_Node_Str");
            write("String_Node_Str");
            write("String_Node_Str");
        } else {
            write("String_Node_Str");
        }
    }
}

Output:
             int i = 0;
-            while (structures.containsKey(tn)) {
+            while (typenames.contains(tn)) {
                 i++;


Input:
protected synchronized void registerMemberForTopic(String topic, String partition, Member member) {
    Pattern pattern = Pattern.compile(partition);
    List<Registration> regs = map.query(member, topic, pattern);
    if (regs.isEmpty()) {
        Registration reg = new Registration(member, topic, pattern);
        map.add(reg);
        if (LOG.isTraceEnabled()) {
            LOG.trace(new StringBuilder().append("String_Node_Str").append(MemberKey.getKey(member)).append("String_Node_Str").append(topic).append("String_Node_Str").append(partition).append("String_Node_Str").toString());
        }
    }
}

Output:
 protected synchronized void registerMemberForTopic(String topic, String partition, Member member) {
-    Pattern pattern = Pattern.compile(partition);
-    List<Registration> regs = map.query(member, topic, pattern);
-    if (regs.isEmpty()) {
-        Registration reg = new Registration(member, topic, pattern);
-        map.add(reg);
+    if (map.get(member) == null) {
+        map.put(member, new HashMap<String, List<Registration>>());
+    }
+    if (map.get(member).get(topic) == null) {
+        map.get(member).put(topic, new ArrayList<Registration>());
+    }
+    boolean found = false;
+    for (Registration reg : map.get(member).get(topic)) {
+        if (topic.equals(reg.getTopic()) && partition.equals(reg.getPartition()) && member.equals(reg.getMember())) {
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        Registration reg = new Registration(member, topic, partition);
+        map.get(member).get(topic).add(reg);
         if (LOG.isTraceEnabled()) {


Input:
ActivityRecord findActivityLocked(Intent intent, ActivityInfo info) {
    ComponentName cls = intent.getComponent();
    if (info.targetActivity != null) {
        cls = new ComponentName(info.packageName, info.targetActivity);
    }
    final int userId = UserHandle.getUserId(info.applicationInfo.uid);
    for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
        final TaskRecord task = mTaskHistory.get(taskNdx);
        final boolean notCurrentUserTask = !mStackSupervisor.isCurrentProfileLocked(task.userId);
        final ArrayList<ActivityRecord> activities = task.mActivities;
        for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
            ActivityRecord r = activities.get(activityNdx);
            if (notCurrentUserTask && (r.info.flags & FLAG_SHOW_FOR_ALL_USERS) == 0) {
                return null;
            }
            if (!r.finishing && r.intent.getComponent().equals(cls) && r.userId == userId) {
                return r;
            }
        }
    }
    return null;
}

Output:
             if (notCurrentUserTask && (r.info.flags & FLAG_SHOW_FOR_ALL_USERS) == 0) {
-                return null;
+                continue;
             }


Input:
private BigInteger Hint(byte[] h) {
    BigInteger hsum = BigInteger.ZERO;
    for (int i = 0; i < 2 * key.getParams().getCurve().getField().getb(); i++) {
        hsum = hsum.add(BigInteger.valueOf(2).pow(i).multiply(BigInteger.valueOf(bit(h, i))));
    }
    return hsum;
}

Output:
 private BigInteger Hint(byte[] h) {
-    BigInteger hsum = BigInteger.ZERO;
-    for (int i = 0; i < 2 * key.getParams().getCurve().getField().getb(); i++) {
-        hsum = hsum.add(BigInteger.valueOf(2).pow(i).multiply(BigInteger.valueOf(bit(h, i))));
+    if (h.length != key.getParams().getCurve().getField().getb() / 4)
+        throw new IllegalArgumentException("String_Node_Str");
+    for (int i = 0; i < h.length / 2; i++) {
+        byte tmp = h[i];
+        h[i] = h[h.length - 1 - i];
+        h[h.length - 1 - i] = tmp;
     }


Input:
public Map<String, Object> executeImpl(WebScriptRequest req, Status status, Cache cache) {
    String reqContentAsString;
    try {
        reqContentAsString = req.getContent().getContent();
    } catch (IOException iox) {
        throw new WebScriptException(Status.STATUS_BAD_REQUEST, "String_Node_Str", iox);
    }
    String actionName = null;
    List<NodeRef> targetNodeRefs = new ArrayList<NodeRef>(1);
    Map<String, Serializable> actionParams = new HashMap<String, Serializable>(3);
    try {
        JSONObject jsonObj = new JSONObject(new JSONTokener(reqContentAsString));
        if (jsonObj.has(PARAM_NAME)) {
            actionName = jsonObj.getString(PARAM_NAME);
        }
        if (jsonObj.has(PARAM_NODE_REF)) {
            NodeRef nodeRef = new NodeRef(jsonObj.getString(PARAM_NODE_REF));
            targetNodeRefs.add(nodeRef);
        }
        if (jsonObj.has(PARAM_NODE_REFS)) {
            JSONArray jsonArray = jsonObj.getJSONArray(PARAM_NODE_REFS);
            if (jsonArray.length() != 0) {
                targetNodeRefs = new ArrayList<NodeRef>(jsonArray.length());
                for (int i = 0; i < jsonArray.length(); i++) {
                    NodeRef nodeRef = new NodeRef(jsonArray.getString(i));
                    targetNodeRefs.add(nodeRef);
                }
            }
        }
        if (jsonObj.has(PARAM_PARAMS)) {
            JSONObject paramsObj = jsonObj.getJSONObject(PARAM_PARAMS);
            for (Iterator<String> iter = paramsObj.keys(); iter.hasNext(); ) {
                String nextKeyString = iter.next();
                Object nextValue = paramsObj.get(nextKeyString);
                if (nextValue instanceof JSONObject) {
                    if (((JSONObject) nextValue).has("String_Node_Str")) {
                        String dateStringValue = ((JSONObject) nextValue).getString("String_Node_Str");
                        nextValue = ISO8601DateFormat.parse(dateStringValue);
                    }
                }
                actionParams.put(nextKeyString, (Serializable) nextValue);
            }
        }
    } catch (JSONException exception) {
        throw new WebScriptException(Status.STATUS_BAD_REQUEST, "String_Node_Str", exception);
    }
    if (actionName == null) {
        throw new WebScriptException(Status.STATUS_BAD_REQUEST, "String_Node_Str");
    }
    StringBuffer targetNodeRefsString = new StringBuffer(30);
    boolean firstTime = true;
    for (NodeRef targetNodeRef : targetNodeRefs) {
        if (!nodeService.exists(targetNodeRef)) {
            throw new WebScriptException(Status.STATUS_NOT_FOUND, "String_Node_Str" + targetNodeRef.toString() + "String_Node_Str");
        }
        if (firstTime) {
            firstTime = false;
        } else {
            targetNodeRefsString.append("String_Node_Str");
        }
        targetNodeRefsString.append(targetNodeRef.toString());
    }
    if (logger.isDebugEnabled()) {
        StringBuilder msg = new StringBuilder();
        msg.append("String_Node_Str").append(actionName).append("String_Node_Str").append(targetNodeRefsString.toString()).append("String_Node_Str").append(actionParams);
        logger.debug(msg.toString());
    }
    Map<String, Object> model = new HashMap<String, Object>();
    if (targetNodeRefs.isEmpty()) {
        RecordsManagementActionResult result = this.rmActionService.executeRecordsManagementAction(actionName, actionParams);
        if (result.getValue() != null) {
            model.put("String_Node_Str", result.getValue().toString());
        }
    } else {
        Map<NodeRef, RecordsManagementActionResult> resultMap = this.rmActionService.executeRecordsManagementAction(targetNodeRefs, actionName, actionParams);
        Map<String, String> results = new HashMap<String, String>(resultMap.size());
        for (NodeRef nodeRef : resultMap.keySet()) {
            Object value = resultMap.get(nodeRef).getValue();
            if (value != null) {
                results.put(nodeRef.toString(), resultMap.get(nodeRef).getValue().toString());
            }
        }
        model.put("String_Node_Str", results);
    }
    model.put("String_Node_Str", "String_Node_Str" + actionName + "String_Node_Str" + targetNodeRefsString.toString());
    return model;
}

Output:
                 Object nextValue = paramsObj.get(nextKeyString);
-                if (nextValue instanceof JSONObject) {
-                    if (((JSONObject) nextValue).has("String_Node_Str")) {
-                        String dateStringValue = ((JSONObject) nextValue).getString("String_Node_Str");
-                        nextValue = ISO8601DateFormat.parse(dateStringValue);
-                    }
+                if ((nextValue instanceof JSONObject) && ((JSONObject) nextValue).has("String_Node_Str")) {
+                    String dateStringValue = ((JSONObject) nextValue).getString("String_Node_Str");
+                    nextValue = ISO8601DateFormat.parse(dateStringValue);
                 }


Input:
protected void initialize(DataManager manager) {
    this.requirements = 0x0;
    for (PrivacyCriterion c : criteria) {
        c.initialize(manager);
        this.requirements |= c.getRequirements();
    }
    absMaxOutliers = (int) Math.floor(this.relMaxOutliers * (double) manager.getDataQI().getDataLength());
    List<PrivacyCriterion> list = new ArrayList<PrivacyCriterion>();
    if (this.containsCriterion(DPresence.class)) {
        list.add(this.getCriterion(DPresence.class));
    }
    if (this.containsCriterion(LDiversity.class)) {
        list.add(this.getCriterion(LDiversity.class));
    }
    if (this.containsCriterion(TCloseness.class)) {
        list.add(this.getCriterion(TCloseness.class));
    }
    this.optimizedCriteria = list.toArray(new PrivacyCriterion[0]);
    if (this.containsCriterion(KAnonymity.class)) {
        list.add(0, this.getCriterion(KAnonymity.class));
        this.criteria = list.toArray(new PrivacyCriterion[0]);
    }
    this.snapshotLength = 2;
    if (this.requires(REQUIREMENT_DISTRIBUTION)) {
        this.snapshotLength += 2;
    }
    if (this.requires(REQUIREMENT_SECONDARY_COUNTER)) {
        this.snapshotLength += 1;
    }
}

Output:
     }
-    this.optimizedCriteria = list.toArray(new PrivacyCriterion[0]);
-    if (this.containsCriterion(KAnonymity.class)) {
-        list.add(0, this.getCriterion(KAnonymity.class));
-        this.criteria = list.toArray(new PrivacyCriterion[0]);
-    }
+    this.aCriteria = list.toArray(new PrivacyCriterion[0]);
     this.snapshotLength = 2;


Input:
public void updateGoal() {
    if (!isCreature())
        return;
    if (hasGoal()) {
        switch(intent) {
            case ATTACK:
                LivingEntity goalEntity = ((EntityGoal) goal).getEntity();
                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goalEntity.getLocation()) > ATTACK_RANGE) {
                    setPathEntity(((EntityGoal) goal).getEntity().getLocation());
                } else {
                    setTarget(((EntityGoal) goal).getEntity());
                }
                break;
            case FOLLOW:
                setTarget(null);
                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goal.getLocation()) < GOAL_RANGE) {
                    setPathEntity(getBukkitEntity().getLocation());
                    intent = IntentType.PAUSE;
                } else {
                    setPathEntity(((EntityGoal) goal).getEntity().getLocation());
                }
                break;
            case PAUSE:
                setTarget(null);
                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goal.getLocation()) > GOAL_RANGE) {
                    setPathEntity(((EntityGoal) goal).getEntity().getLocation());
                    intent = IntentType.FOLLOW;
                } else {
                    setPathEntity(getBukkitEntity().getLocation());
                }
                break;
            case MOUNT:
                break;
            case PASSIVE:
                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goal.getLocation()) < GOAL_RANGE)
                    stop();
                break;
            case STOP:
                setTarget(null);
                setPathEntity(((LocationGoal) goal).getLocation());
                break;
        }
        updateSpeed();
    }
}

Output:
             case PASSIVE:
-                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goal.getLocation()) < GOAL_RANGE)
+                if (vehicle.getBukkitEntity().getLocation().distanceSquared(goal.getLocation()) < GOAL_RANGE) {
                     stop();


Input:
private void createControlDependenciesFromEntryNode() {
    for (GraphNode node : cfg.nodes) {
        CFGNode cfgNode = (CFGNode) node;
        if (!isNested(cfgNode)) {
            processCFGNode(entryNode, cfgNode, true);
        }
    }
    Map<CFGBlockNode, List<CFGNode>> directlyNestedNodesInBlocks = cfg.getDirectlyNestedNodesInBlocks();
    for (CFGBlockNode blockNode : directlyNestedNodesInBlocks.keySet()) {
        PDGBlockNode pdgBlockNode = null;
        if (blockNode instanceof CFGTryNode) {
            CFGTryNode tryNode = (CFGTryNode) blockNode;
            pdgBlockNode = new PDGTryNode(tryNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
        } else if (blockNode instanceof CFGSynchronizedNode) {
            CFGSynchronizedNode synchronizedNode = (CFGSynchronizedNode) blockNode;
            pdgBlockNode = new PDGSynchronizedNode(synchronizedNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
        }
        nodes.add(pdgBlockNode);
    }
}

Output:
     for (CFGBlockNode blockNode : directlyNestedNodesInBlocks.keySet()) {
-        PDGBlockNode pdgBlockNode = null;
-        if (blockNode instanceof CFGTryNode) {
-            CFGTryNode tryNode = (CFGTryNode) blockNode;
-            pdgBlockNode = new PDGTryNode(tryNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
-        } else if (blockNode instanceof CFGSynchronizedNode) {
-            CFGSynchronizedNode synchronizedNode = (CFGSynchronizedNode) blockNode;
-            pdgBlockNode = new PDGSynchronizedNode(synchronizedNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
+        if (!containsNodeWithID(blockNode.getId())) {
+            PDGBlockNode pdgBlockNode = null;
+            if (blockNode instanceof CFGTryNode) {
+                CFGTryNode tryNode = (CFGTryNode) blockNode;
+                pdgBlockNode = new PDGTryNode(tryNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
+            } else if (blockNode instanceof CFGSynchronizedNode) {
+                CFGSynchronizedNode synchronizedNode = (CFGSynchronizedNode) blockNode;
+                pdgBlockNode = new PDGSynchronizedNode(synchronizedNode, variableDeclarationsInMethod, fieldsAccessedInMethod);
+            }
+            if (pdgBlockNode != null) {
+                nodes.add(pdgBlockNode);
+            }
         }


Input:
public void progress() {
    delegete.progress();
    if (finalReceiverProgress.compareAndSet(false, true)) {
        finalReceiver.progress();
        finalReceiverProgress.compareAndSet(true, false);
    }
    if (partialRecevierProgress.compareAndSet(false, true)) {
        partialReceiver.progress();
        partialRecevierProgress.compareAndSet(true, false);
    }
}

Output:
     delegete.progress();
-    if (finalReceiverProgress.compareAndSet(false, true)) {
-        finalReceiver.progress();
-        finalReceiverProgress.compareAndSet(true, false);
+    if (lock.tryLock()) {
+        try {
+            finalReceiver.progress();
+        } finally {
+            lock.unlock();
+        }
     }


Input:
public MethodHandler getInvoker(Object proxy) {
    return ((MethodInterceptorInvoker) ((Factory) proxy).getCallback(0)).invoker;
}

Output:
 public MethodHandler getInvoker(Object proxy) {
-    return ((MethodInterceptorInvoker) ((Factory) proxy).getCallback(0)).invoker;
+    if (proxy instanceof Factory) {
+        Factory factory = (Factory) proxy;
+        Callback callback = factory.getCallback(0);
+        if (callback instanceof MethodInterceptorInvoker) {
+            return ((MethodInterceptorInvoker) callback).invoker;
+        }
+    }
+    return null;
 }


Input:
public boolean executeAsyncAction(Action action, final ICommandListener listener) {
    final String type = action.getType();
    Bundle data = action.getData();
    switch(type) {
        case MissionActions.ACTION_LOAD_WAYPOINTS:
            CommonApiUtils.loadWaypoints(this);
            return true;
        case MissionActions.ACTION_SET_MISSION:
            data.setClassLoader(com.o3dr.services.android.lib.drone.mission.Mission.class.getClassLoader());
            com.o3dr.services.android.lib.drone.mission.Mission mission = data.getParcelable(MissionActions.EXTRA_MISSION);
            boolean pushToDrone = data.getBoolean(MissionActions.EXTRA_PUSH_TO_DRONE);
            CommonApiUtils.setMission(this, mission, pushToDrone);
            return true;
        case MissionActions.ACTION_START_MISSION:
            boolean forceModeChange = data.getBoolean(MissionActions.EXTRA_FORCE_MODE_CHANGE);
            boolean forceArm = data.getBoolean(MissionActions.EXTRA_FORCE_ARM);
            CommonApiUtils.startMission(this, forceModeChange, forceArm, listener);
            return true;
        case ExperimentalActions.ACTION_EPM_COMMAND:
            boolean release = data.getBoolean(ExperimentalActions.EXTRA_EPM_RELEASE);
            CommonApiUtils.epmCommand(this, release, listener);
            return true;
        case ExperimentalActions.ACTION_TRIGGER_CAMERA:
            CommonApiUtils.triggerCamera(this);
            return true;
        case ExperimentalActions.ACTION_SET_ROI:
            LatLongAlt roi = data.getParcelable(ExperimentalActions.EXTRA_SET_ROI_LAT_LONG_ALT);
            if (roi != null) {
                Coord3D coord3DRoi = new Coord3D(roi.getLatitude(), roi.getLongitude(), roi.getAltitude());
                MavLinkDoCmds.setROI(this, coord3DRoi, listener);
            }
            return true;
        case ExperimentalActions.ACTION_SEND_MAVLINK_MESSAGE:
            data.setClassLoader(MavlinkMessageWrapper.class.getClassLoader());
            MavlinkMessageWrapper messageWrapper = data.getParcelable(ExperimentalActions.EXTRA_MAVLINK_MESSAGE);
            CommonApiUtils.sendMavlinkMessage(this, messageWrapper);
            return true;
        case ExperimentalActions.ACTION_SET_RELAY:
            int relayNumber = data.getInt(ExperimentalActions.EXTRA_RELAY_NUMBER);
            boolean isOn = data.getBoolean(ExperimentalActions.EXTRA_IS_RELAY_ON);
            MavLinkDoCmds.setRelay(this, relayNumber, isOn, listener);
            return true;
        case ExperimentalActions.ACTION_SET_SERVO:
            int channel = data.getInt(ExperimentalActions.EXTRA_SERVO_CHANNEL);
            int pwm = data.getInt(ExperimentalActions.EXTRA_SERVO_PWM);
            MavLinkDoCmds.setServo(this, channel, pwm, listener);
            return true;
        case ControlActions.ACTION_DO_GUIDED_TAKEOFF:
            double takeoffAltitude = data.getDouble(ControlActions.EXTRA_ALTITUDE);
            CommonApiUtils.doGuidedTakeoff(this, takeoffAltitude, listener);
            return true;
        case ControlActions.ACTION_SEND_GUIDED_POINT:
            data.setClassLoader(LatLong.class.getClassLoader());
            boolean force = data.getBoolean(ControlActions.EXTRA_FORCE_GUIDED_POINT);
            LatLong guidedPoint = data.getParcelable(ControlActions.EXTRA_GUIDED_POINT);
            CommonApiUtils.sendGuidedPoint(this, guidedPoint, force, listener);
            return true;
        case ControlActions.ACTION_SET_GUIDED_ALTITUDE:
            double guidedAltitude = data.getDouble(ControlActions.EXTRA_ALTITUDE);
            CommonApiUtils.setGuidedAltitude(this, guidedAltitude);
            return true;
        case ControlActions.ACTION_SET_CONDITION_YAW:
            final float targetAngle = data.getFloat(ControlActions.EXTRA_YAW_TARGET_ANGLE);
            final float yawRate = data.getFloat(ControlActions.EXTRA_YAW_CHANGE_RATE);
            final boolean isClockwise = data.getBoolean(ControlActions.EXTRA_YAW_IS_CLOCKWISE);
            final boolean isRelative = data.getBoolean(ControlActions.EXTRA_YAW_IS_RELATIVE);
            MavLinkModes.setConditionYaw(this, targetAngle, yawRate, isClockwise, isRelative, listener);
            return true;
        case ControlActions.ACTION_SET_VELOCITY:
            final float xVel = data.getFloat(ControlActions.EXTRA_VELOCITY_X);
            final float yVel = data.getFloat(ControlActions.EXTRA_VELOCITY_Y);
            final float zVel = data.getFloat(ControlActions.EXTRA_VELOCITY_Z);
            MavLinkModes.setVelocityInLocalFrame(this, xVel, yVel, zVel, listener);
            return true;
        case ParameterActions.ACTION_REFRESH_PARAMETERS:
            CommonApiUtils.refreshParameters(this);
            return true;
        case ParameterActions.ACTION_WRITE_PARAMETERS:
            data.setClassLoader(com.o3dr.services.android.lib.drone.property.Parameters.class.getClassLoader());
            com.o3dr.services.android.lib.drone.property.Parameters parameters = data.getParcelable(ParameterActions.EXTRA_PARAMETERS);
            CommonApiUtils.writeParameters(this, parameters);
            return true;
        case StateActions.ACTION_ARM:
            boolean doArm = data.getBoolean(StateActions.EXTRA_ARM);
            boolean emergencyDisarm = data.getBoolean(StateActions.EXTRA_EMERGENCY_DISARM);
            CommonApiUtils.arm(this, doArm, emergencyDisarm, listener);
            return true;
        case StateActions.ACTION_SET_VEHICLE_HOME:
            final LatLongAlt homeLoc = data.getParcelable(StateActions.EXTRA_VEHICLE_HOME_LOCATION);
            if (homeLoc != null) {
                MavLinkDoCmds.setVehicleHome(this, homeLoc, new AbstractCommandListener() {
                    public void onSuccess() {
                        CommonApiUtils.postSuccessEvent(listener);
                        home.requestHomeUpdate();
                    }
                    public void onError(int executionError) {
                        CommonApiUtils.postErrorEvent(executionError, listener);
                        home.requestHomeUpdate();
                    }
                    public void onTimeout() {
                        CommonApiUtils.postTimeoutEvent(listener);
                        home.requestHomeUpdate();
                    }
                });
            } else {
                CommonApiUtils.postErrorEvent(CommandExecutionError.COMMAND_FAILED, listener);
            }
            return true;
        case CalibrationActions.ACTION_START_IMU_CALIBRATION:
            CommonApiUtils.startIMUCalibration(this, listener);
            return true;
        case CalibrationActions.ACTION_SEND_IMU_CALIBRATION_ACK:
            int imuAck = data.getInt(CalibrationActions.EXTRA_IMU_STEP);
            CommonApiUtils.sendIMUCalibrationAck(this, imuAck);
            return true;
        case CalibrationActions.ACTION_START_MAGNETOMETER_CALIBRATION:
            final boolean retryOnFailure = data.getBoolean(CalibrationActions.EXTRA_RETRY_ON_FAILURE, false);
            final boolean saveAutomatically = data.getBoolean(CalibrationActions.EXTRA_SAVE_AUTOMATICALLY, true);
            final int startDelay = data.getInt(CalibrationActions.EXTRA_START_DELAY, 0);
            CommonApiUtils.startMagnetometerCalibration(this, retryOnFailure, saveAutomatically, startDelay);
            return true;
        case CalibrationActions.ACTION_CANCEL_MAGNETOMETER_CALIBRATION:
            CommonApiUtils.cancelMagnetometerCalibration(this);
            return true;
        case CalibrationActions.ACTION_ACCEPT_MAGNETOMETER_CALIBRATION:
            CommonApiUtils.acceptMagnetometerCalibration(this);
            return true;
        case GimbalActions.ACTION_SET_GIMBAL_ORIENTATION:
            float pitch = data.getFloat(GimbalActions.GIMBAL_PITCH);
            float roll = data.getFloat(GimbalActions.GIMBAL_ROLL);
            float yaw = data.getFloat(GimbalActions.GIMBAL_YAW);
            MavLinkDoCmds.setGimbalOrientation(this, pitch, roll, yaw, listener);
            return true;
        case GimbalActions.ACTION_RESET_GIMBAL_MOUNT_MODE:
            MavLinkDoCmds.resetROI(this, listener);
            return true;
        case GimbalActions.ACTION_SET_GIMBAL_MOUNT_MODE:
            final int mountMode = data.getInt(GimbalActions.GIMBAL_MOUNT_MODE, MAV_MOUNT_MODE.MAV_MOUNT_MODE_MAVLINK_TARGETING);
            Parameter mountParam = this.parameters.getParameter("String_Node_Str");
            if (mountParam == null) {
                msg_mount_configure msg = new msg_mount_configure();
                msg.target_system = getSysid();
                msg.target_component = getCompid();
                msg.mount_mode = (byte) mountMode;
                msg.stab_pitch = 0;
                msg.stab_roll = 0;
                msg.stab_yaw = 0;
                getMavClient().sendMavMessage(msg, listener);
            } else {
                MavLinkParameters.sendParameter(this, "String_Node_Str", 1, mountMode);
            }
            return true;
        default:
            return super.executeAsyncAction(action, listener);
    }
}

Output:
         case GimbalActions.ACTION_SET_GIMBAL_MOUNT_MODE:
-            final int mountMode = data.getInt(GimbalActions.GIMBAL_MOUNT_MODE, MAV_MOUNT_MODE.MAV_MOUNT_MODE_MAVLINK_TARGETING);
+            final int mountMode = data.getInt(GimbalActions.GIMBAL_MOUNT_MODE, MAV_MOUNT_MODE.MAV_MOUNT_MODE_RC_TARGETING);
+            Timber.i("String_Node_Str", mountMode);
             Parameter mountParam = this.parameters.getParameter("String_Node_Str");


Input:
public static MultiScore createScore(TablePerspective strat, Group group, boolean createGSEA) {
    AGSEAAlgorithm algorithm;
    if (createGSEA)
        algorithm = new GSEAAlgorithm(strat.getRecordPerspective(), group, 1.0f);
    else
        algorithm = new PGSEAAlgorithm(strat.getRecordPerspective(), group);
    String label = String.format("String_Node_Str", strat.getRecordPerspective().getLabel());
    IScore gsea = new GeneSetScore("String_Node_Str" + label, algorithm, false);
    IScore pValue = new GeneSetScore("String_Node_Str" + label, algorithm.asPValue(), true);
    MultiScore s = new MultiScore(gsea.getLabel(), color, bgColor, 1);
    s.add(gsea);
    s.add(pValue);
    return s;
}

Output:
     String label = String.format("String_Node_Str", strat.getRecordPerspective().getLabel());
-    IScore gsea = new GeneSetScore("String_Node_Str" + label, algorithm, false);
-    IScore pValue = new GeneSetScore("String_Node_Str" + label, algorithm.asPValue(), true);
-    MultiScore s = new MultiScore(gsea.getLabel(), color, bgColor, 1);
+    IScore gsea = new GeneSetScore("String_Node_Str", algorithm, false);
+    IScore pValue = new GeneSetScore("String_Node_Str", algorithm.asPValue(), true);
+    MultiScore s = new MultiScore(label, color, bgColor, 1);
     s.add(gsea);


Input:
private void addResource(GrillSessionHandle sessionid, String type, String path, boolean addToSession) {
    String command = "String_Node_Str" + type.toLowerCase() + "String_Node_Str" + path;
    try {
        acquire(sessionid);
        getCliService().executeStatement(getHiveSessionHandle(sessionid), command, null);
        if (addToSession) {
            getSession(sessionid).addResource(type, path);
        }
    } catch (HiveSQLException e) {
        throw new WebApplicationException(e);
    } catch (GrillException e) {
        throw new WebApplicationException(e);
    } finally {
        try {
            release(sessionid);
        } catch (GrillException e) {
            throw new WebApplicationException(e);
        }
    }
}

Output:
     } finally {
-        try {
-            release(sessionid);
-        } catch (GrillException e) {
-            throw new WebApplicationException(e);
-        }
+        release(sessionid);
     }


Input:
public ListenableFuture<Optional<String>> apply(Void input) throws Exception {
    long fileSize = projectFilesystem.getFileSize(output.getPath());
    if (!performTwoLevelStores || fileSize < minimumTwoLevelStoredArtifactSize || (maximumTwoLevelStoredArtifactSize.isPresent() && fileSize > maximumTwoLevelStoredArtifactSize.get())) {
        return Futures.immediateFuture(Optional.<String>absent());
    }
    long hashComputationStart = System.currentTimeMillis();
    String hashCode = projectFilesystem.computeSha1(output.getPath()) + "String_Node_Str";
    long hashComputationEnd = System.currentTimeMillis();
    secondLevelHashComputationTimeMs.addSample(hashComputationEnd - hashComputationStart);
    return Futures.transform(delegate.store(ArtifactInfo.builder().addRuleKeys(new RuleKey(hashCode)).build(), output), Functions.constant(Optional.of(hashCode)));
}

Output:
     if (!performTwoLevelStores || fileSize < minimumTwoLevelStoredArtifactSize || (maximumTwoLevelStoredArtifactSize.isPresent() && fileSize > maximumTwoLevelStoredArtifactSize.get())) {
-        return Futures.immediateFuture(Optional.<String>absent());
+        return Futures.immediateFuture(false);
     }


Input:
private IProjectPO initProject(Project xml, boolean assignNewGuid) {
    IProjectPO proj = null;
    if (xml.getGUID() != null) {
        Integer majorProjVersion = null;
        if (!xml.isNilMajorProjectVersion() && xml.isSetMajorProjectVersion() || xml.isSetMajorNumber()) {
            majorProjVersion = xml.isSetMajorNumber() ? xml.getMajorNumber() : xml.getMajorProjectVersion();
        }
        Integer minorProjVersion = null;
        if (!xml.isNilMinorProjectVersion() && xml.isSetMinorProjectVersion() || xml.isSetMinorNumber()) {
            minorProjVersion = xml.isSetMinorNumber() ? xml.getMinorNumber() : xml.getMinorProjectVersion();
        }
        Integer microProjVersion = !xml.isSetMicroProjectVersion() || xml.isNilMicroProjectVersion() ? null : xml.getMicroProjectVersion();
        String postFixProjVersion = !xml.isSetProjectVersionQualifier() || xml.isNilProjectVersionQualifier() ? null : xml.getProjectVersionQualifier();
        if (!assignNewGuid) {
            proj = NodeMaker.createProjectPO(IVersion.JB_CLIENT_METADATA_VERSION, majorProjVersion, minorProjVersion, microProjVersion, postFixProjVersion, xml.getGUID());
        } else {
            proj = NodeMaker.createProjectPO(IVersion.JB_CLIENT_METADATA_VERSION, majorProjVersion, minorProjVersion, microProjVersion, postFixProjVersion);
        }
        ProjectNameBP.getInstance().setName(xml.getGUID(), xml.getName(), false);
    } else {
        proj = NodeMaker.createProjectPO(xml.getName(), IVersion.JB_CLIENT_METADATA_VERSION);
        if (assignNewGuid) {
            m_oldToNewGuids.put(xml.getGUID(), proj.getGuid());
        }
    }
    return proj;
}

Output:
         }
-        ProjectNameBP.getInstance().setName(xml.getGUID(), xml.getName(), false);
+        ProjectNameBP.getInstance().setName(proj.getGuid(), xml.getName(), false);
     } else {


Input:
private static Calendar initCalendar(int year) {
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, year);
    cal.set(Calendar.MONTH, 0);
    cal.set(Calendar.DAY_OF_MONTH, 1);
    return cal;
}

Output:
 private static Calendar initCalendar(int year) {
-    Calendar cal = Calendar.getInstance();
+    final Calendar cal = Calendar.getInstance();
     cal.set(Calendar.YEAR, year);


Input:
public static Date createDate(int year, int month, int day) {
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, year);
    cal.set(Calendar.MONTH, month);
    cal.set(Calendar.DATE, day);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    Date jsqlD = new Date(cal.getTime().getTime());
    return jsqlD;
}

Output:
     cal.set(Calendar.YEAR, year);
-    cal.set(Calendar.MONTH, month);
+    cal.set(Calendar.MONTH, month - 1);
     cal.set(Calendar.DATE, day);