Input:
private static String createAndStorePattern(PatternParameters parameters, IFolder selectionFolder, ExpressionType type) {
    Pattern pattern = PatternResourceFileHelper.getInstance().createPattern(parameters.name, parameters.auther, parameters.description, parameters.purpose, parameters.status);
    for (String key : parameters.regex.keySet()) {
        RegularExpression regularExpr = BooleanExpressionHelper.createRegularExpression(key, parameters.regex.get(key), type);
        pattern.getComponents().add(regularExpr);
    }
    boolean validStatus = PatternUtilities.isPatternValid(pattern);
    TaggedValueHelper.setValidStatus(validStatus, pattern);
    String fname = DqRepositoryViewService.createFilename(parameters.name, NewSourcePatternActionProvider.EXTENSION_PATTERN);
    try {
        String[] folderNames = parameters.relativePath.split("String_Node_Str");
        if (1 == folderNames.length && "String_Node_Str".equals(folderNames[0])) {
            switch(type) {
                case SQL_LIKE:
                    folderNames[0] = DQStructureManager.SQL;
                    break;
                case REGEXP:
                    folderNames[0] = DQStructureManager.REGEX;
                    break;
            }
        }
        for (String folderName : folderNames) {
            IFolder folder = selectionFolder.getFolder(folderName);
            if (!folder.exists()) {
                folder.create(false, true, null);
            }
            folder.setPersistentProperty(DQStructureManager.FOLDER_CLASSIFY_KEY, DQStructureManager.PATTERNS_FOLDER_PROPERTY);
            selectionFolder = folder;
        }
    } catch (CoreException e) {
        log.error(e, e);
    }
    IFile pfile = selectionFolder.getFile(fname);
    EMFSharedResources.getInstance().addEObjectToResourceSet(pfile.getFullPath().toString(), pattern);
    EMFSharedResources.getInstance().saveLastResource();
    return selectionFolder.getName();
}

Output:
     EMFSharedResources.getInstance().saveLastResource();
-    return selectionFolder.getName();
+    return ResourceManager.getLibrariesFolder().getFolder(DQStructureManager.PATTERNS).getLocationURI().relativize(selectionFolder.getLocationURI()).toString();
 }


Input:
public static synchronized void handleCompleteApplication(Applications applications) {
    log.info("String_Node_Str");
    ApplicationHolder.acquireReadLock();
    try {
        ApplicationsEventPublisher.sendCompleteApplicationsEvent(applications);
    } finally {
        ApplicationHolder.releaseReadLock();
    }
}

Output:
 public static synchronized void handleCompleteApplication(Applications applications) {
-    log.info("String_Node_Str");
+    if (log.isDebugEnabled()) {
+        log.debug("String_Node_Str");
+    }
     ApplicationHolder.acquireReadLock();


Input:
private <T> T manufacturePojoInternal(Class<T> pojoClass, AttributeMetadata pojoMetadata, ManufacturingContext manufacturingCtx, Type... genericTypeArgs) throws InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException {
    T objectToReuse = (T) strategy.getMemoizedObject(pojoMetadata);
    if (objectToReuse != null) {
        LOG.debug("String_Node_Str", pojoClass, Arrays.toString(genericTypeArgs));
        return objectToReuse;
    } else {
        LOG.debug("String_Node_Str", pojoClass, Arrays.toString(genericTypeArgs));
    }
    final Map<String, Type> typeArgsMap = new HashMap<String, Type>();
    if (pojoClass.isEnum()) {
        T tmp = (T) typeMultiplexer.getTypeValue(strategy, pojoMetadata, typeArgsMap, PodamConstants.ENUMERATION_QUALIFIER);
        return tmp;
    }
    if (pojoClass.isPrimitive()) {
        T tmp = (T) typeMultiplexer.getTypeValue(strategy, pojoMetadata, typeArgsMap, pojoClass.getName());
        return tmp;
    }
    Type[] genericTypeArgsExtra = TypeManufacturerUtil.fillTypeArgMap(typeArgsMap, pojoClass, genericTypeArgs);
    if (pojoClass.isInterface()) {
        return getValueForAbstractType(pojoClass, pojoMetadata, manufacturingCtx, typeArgsMap, genericTypeArgs);
    }
    T retValue = null;
    try {
        retValue = instantiatePojo(pojoClass, manufacturingCtx, typeArgsMap, genericTypeArgsExtra);
    } catch (SecurityException e) {
        throw new PodamMockeryException("String_Node_Str", e);
    }
    if (retValue == null) {
        return getValueForAbstractType(pojoClass, pojoMetadata, manufacturingCtx, typeArgsMap, genericTypeArgs);
    } else {
        strategy.cacheMemoizedObject(pojoMetadata, retValue);
        populatePojoInternal(retValue, manufacturingCtx, typeArgsMap, genericTypeArgsExtra);
    }
    return retValue;
}

Output:
     }
-    if (pojoClass.isPrimitive()) {
+    if (pojoClass.isPrimitive() || pojoClass.equals(String.class) || TypeManufacturerUtil.isWrapper(pojoClass)) {
         T tmp = (T) typeMultiplexer.getTypeValue(strategy, pojoMetadata, typeArgsMap, pojoClass.getName());


Input:
public void testErrors() {
    this.mojo.gitDir = null;
    try {
        this.mojo.initRepository();
        fail("String_Node_Str");
    } catch (Exception e) {
        assertEquals(FileNotFoundException.class, e.getClass());
        assertEquals("String_Node_Str", e.getMessage());
    }
    this.mojo.gitDir = new File(System.getenv().get("String_Node_Str")).getAbsoluteFile();
    try {
        this.mojo.initRepository();
        fail("String_Node_Str");
    } catch (Exception e) {
        assertEquals(FileNotFoundException.class, e.getClass());
        assertEquals(this.mojo.gitDir + "String_Node_Str", e.getMessage());
    }
    this.mojo.gitDir = new File("String_Node_Str");
    try {
        this.mojo.initRepository();
        fail("String_Node_Str");
    } catch (Exception e) {
        assertEquals(FileNotFoundException.class, e.getClass());
        assertEquals(this.mojo.gitDir + "String_Node_Str", e.getMessage());
    }
    this.mojo.gitDir = new File("String_Node_Str");
    try {
        this.mojo.initRepository();
        fail("String_Node_Str");
    } catch (Exception e) {
        assertEquals(IOException.class, e.getClass());
        assertEquals("String_Node_Str", e.getMessage());
    }
}

Output:
     }
-    this.mojo.gitDir = new File(System.getenv().get("String_Node_Str")).getAbsoluteFile();
+    String home = System.getenv().get("String_Node_Str");
+    if (home == null) {
+        home = System.getenv().get("String_Node_Str") + System.getenv("String_Node_Str");
+    }
+    this.mojo.gitDir = new File(home).getAbsoluteFile();
     try {


Input:
public Value[] getValues(Value[] values) {
    Value CC = new Value("String_Node_Str", this.cc);
    Value CCW = new Value("String_Node_Str", this.ccw);
    Value CC_RT = new Value("String_Node_Str", this.timer.rt());
    return new Value[] { CC, CCW, CC_RT };
}

Output:
     Value CCW = new Value("String_Node_Str", this.ccw);
-    Value CC_RT = new Value("String_Node_Str", this.timer.rt());
-    return new Value[] { CC, CCW, CC_RT };
+    Value RT = new Value("String_Node_Str", this.timer.rt());
+    return new Value[] { CC, CCW, RT };
 }


Input:
public Object exitFromJNI(int offset) {
    RVMThread.leaveJNIFromCallIntoNative();
    JNIRefsTop = JNIRefsSavedFP;
    if (JNIRefsTop > 0) {
        JNIRefsSavedFP = JNIRefs.get((JNIRefsTop >> LOG_BYTES_IN_ADDRESS) + 1).toInt();
    }
    Throwable pe = pendingException;
    if (pe != null) {
        pendingException = null;
        RuntimeEntrypoints.athrow(pe);
    }
    Object result;
    if (offset == 0) {
        result = null;
    } else if (offset < 0) {
        result = JNIGlobalRefTable.ref(offset);
    } else {
        result = Magic.addressAsObject(JNIRefs.get(offset >> LOG_BYTES_IN_ADDRESS));
    }
    return result;
}

Output:
     RVMThread.leaveJNIFromCallIntoNative();
-    JNIRefsTop = JNIRefsSavedFP;
-    if (JNIRefsTop > 0) {
-        JNIRefsSavedFP = JNIRefs.get((JNIRefsTop >> LOG_BYTES_IN_ADDRESS) + 1).toInt();
+    JNIRefsTop = 0;
+    if (JNIRefsSavedFP > 0) {
+        JNIRefsTop = JNIRefsSavedFP - BYTES_IN_ADDRESS;
+        JNIRefsSavedFP = JNIRefs.get(JNIRefsSavedFP >> LOG_BYTES_IN_ADDRESS).toInt();
     }


Input:
public String getPlayerFromID(int id) {
    try {
        Statement statement = conn.createStatement();
        ResultSet resultSet = statement.executeQuery("String_Node_Str" + id + "String_Node_Str");
        if (!resultSet.isBeforeFirst()) {
            resultSet.close();
            return null;
        }
        String name = resultSet.getString("String_Node_Str").toLowerCase();
        resultSet.close();
        return name;
    } catch (SQLException e) {
        logManager.severe("String_Node_Str" + new Integer(id).toString() + "String_Node_Str");
    }
    return null;
}

Output:
         Statement statement = conn.createStatement();
-        ResultSet resultSet = statement.executeQuery("String_Node_Str" + id + "String_Node_Str");
+        ResultSet resultSet = statement.executeQuery("String_Node_Str" + new Integer(id).toString() + "String_Node_Str");
         if (!resultSet.isBeforeFirst()) {


Input:
public static void main(String[] args) throws IOException, NumberFormatException, InterruptedException {
    if (args.length < 4) {
        log.info("String_Node_Str");
    } else {
        Producer<String, String> producer = new Producer<String, String>(createProducerConfig(args[3]));
        Gson gson = new Gson();
        Reader in = new FileReader(args[0]);
        CSVParser parser = CSVFormat.DEFAULT.parse(in);
        List<String> columnNames = new ArrayList<>();
        for (CSVRecord csvRecord : parser.getRecords()) {
            if (columnNames.size() == 0) {
                Iterator<String> iterator = csvRecord.iterator();
                while (iterator.hasNext()) {
                    columnNames.add(iterator.next());
                }
            } else {
                StratioStreamingMessage message = new StratioStreamingMessage();
                message.setOperation(STREAM_OPERATIONS.MANIPULATION.INSERT);
                message.setStreamName(args[1]);
                message.setTimestamp(System.currentTimeMillis());
                message.setSession_id(String.valueOf(System.currentTimeMillis()));
                message.setRequest_id(String.valueOf(System.currentTimeMillis()));
                message.setRequest("String_Node_Str");
                List<ColumnNameTypeValue> sensorData = new ArrayList<>();
                for (int i = 0; i < columnNames.size(); i++) {
                    Object value = null;
                    try {
                        value = Double.valueOf(csvRecord.get(i));
                    } catch (NumberFormatException e) {
                        value = csvRecord.get(i);
                    }
                    sensorData.add(new ColumnNameTypeValue(columnNames.get(i), null, value));
                }
                message.setColumns(sensorData);
                String json = gson.toJson(message);
                log.info("String_Node_Str", json);
                producer.send(new KeyedMessage<String, String>(InternalTopic.TOPIC_DATA.getTopicName(), json));
                log.info("String_Node_Str", args[2]);
                Thread.sleep(Long.valueOf(args[2]));
            }
        }
        log.info("String_Node_Str");
    }
}

Output:
                 StratioStreamingMessage message = new StratioStreamingMessage();
-                message.setOperation(STREAM_OPERATIONS.MANIPULATION.INSERT);
+                message.setOperation(STREAM_OPERATIONS.MANIPULATION.INSERT.toLowerCase());
                 message.setStreamName(args[1]);


Input:
public ACLDTO convertTo(ACL acl, ACLDTO aclDTO) {
    aclDTO = new ACLDTO();
    if (acl != null) {
        for (Map.Entry<User, ACLUserEntry> entry : acl.getUserEntries().entrySet()) {
            ACLUserEntry aclEntry = entry.getValue();
            aclDTO.addUserEntry(aclEntry.getPrincipalLogin(), aclEntry.getPermission());
        }
        for (Map.Entry<UserGroup, ACLUserGroupEntry> entry : acl.getGroupEntries().entrySet()) {
            ACLUserGroupEntry aclEntry = entry.getValue();
            aclDTO.addGroupEntry(aclEntry.getPrincipalId(), aclEntry.getPermission());
        }
    }
    return aclDTO;
}

Output:
     }
-    return aclDTO;
+    return null;
 }


Input:
private void updateCamera(CharacterMovementComponent charMovementComp, Vector3f position, Quat4f rotation) {
    Vector3d cameraPosition = new Vector3d();
    cameraPosition.add(new Vector3d(position), new Vector3d(0, 0.6f, 0));
    playerCamera.getPosition().set(cameraPosition);
    Vector3f viewDir = new Vector3f(0, 0, 1);
    QuaternionUtil.quatRotate(rotation, viewDir, viewDir);
    playerCamera.getViewingDirection().set(viewDir);
    float stepDelta = charMovementComp.footstepDelta - lastStepDelta;
    if (stepDelta < 0)
        stepDelta += charMovementComp.distanceBetweenFootsteps;
    bobFactor += stepDelta;
    lastStepDelta = charMovementComp.footstepDelta;
    if (cameraBobbing) {
        playerCamera.setBobbingRotationOffsetFactor(calcBobbingOffset(0.0f, 0.01f, 2.5f));
        playerCamera.setBobbingVerticalOffsetFactor(calcBobbingOffset((float) java.lang.Math.PI / 4f, 0.025f, 3f));
    } else {
        playerCamera.setBobbingRotationOffsetFactor(0.0);
        playerCamera.setBobbingVerticalOffsetFactor(0.0);
    }
    if (charMovementComp.isGhosting) {
        playerCamera.extendFov(24);
    } else {
        playerCamera.resetFov();
    }
}

Output:
     Vector3f viewDir = new Vector3f(0, 0, 1);
-    QuaternionUtil.quatRotate(rotation, viewDir, viewDir);
-    playerCamera.getViewingDirection().set(viewDir);
+    QuaternionUtil.quatRotate(rotation, viewDir, playerCamera.getViewingDirection());
     float stepDelta = charMovementComp.footstepDelta - lastStepDelta;


Input:
public boolean contains(Tag tag) {
    return mSelectedTopics.contains(tag) || mSelectedTopics.contains(tag);
}

Output:
 public boolean contains(Tag tag) {
-    return mSelectedTopics.contains(tag) || mSelectedTopics.contains(tag);
+    return mSelectedTypes.contains(tag) || mSelectedTopics.contains(tag);
 }


Input:
public void visitConstantExpression(ConstantExpression expression) {
    if (!(expression.isNullExpression() || expression.isTrueExpression() || expression.isFalseExpression() || expression.isEmptyStringExpression())) {
        if (expression instanceof AnnotationConstantExpression) {
            visitTypeReference(expression.getType(), true, true);
        }
        char[] constName = expression.getValue().toString().toCharArray();
        requestor.acceptFieldReference(constName, expression.getStart());
        for (int i = 0; i < 7; i += 1) {
            requestor.acceptMethodReference(constName, i, expression.getStart());
        }
    }
    super.visitConstantExpression(expression);
}

Output:
         requestor.acceptFieldReference(constName, expression.getStart());
-        for (int i = 0; i < 7; i += 1) {
+        for (int i = 0; i <= 7; i += 1) {
             requestor.acceptMethodReference(constName, i, expression.getStart());


Input:
public void testVarJoin() throws Exception {
    final String expected = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    try (AsOfPartitionedJoinRecordSource source = new AsOfPartitionedJoinRecordSource(compiler.compileSource(factory, "String_Node_Str"), 0, new NoRowidSource().of(compiler.compileSource(factory, "String_Node_Str")), 0, keys, keys, 512, 512, 512)) {
        printer.printCursor(source, factory, true);
        TestUtils.assertEquals(expected, sink);
        source.reset();
        sink.clear();
        printer.printCursor(source, factory, true);
        TestUtils.assertEquals(expected, sink);
    }
}

Output:
     try (AsOfPartitionedJoinRecordSource source = new AsOfPartitionedJoinRecordSource(compiler.compileSource(factory, "String_Node_Str"), 0, new NoRowidSource().of(compiler.compileSource(factory, "String_Node_Str")), 0, keys, keys, 512, 512, 512)) {
-        printer.printCursor(source, factory, true);
+        printer.print(source, factory, true);
         TestUtils.assertEquals(expected, sink);


Input:
public static String formatNumberPattern(String givenValue, Locale locale) {
    String returnStr = "String_Node_Str";
    if (givenValue == null) {
        return "String_Node_Str";
    }
    if (givenValue.length() == 1) {
        char ch = givenValue.charAt(0);
        if (ch == 'G' || ch == 'g' || ch == 'd' || ch == 'D') {
            return "String_Node_Str";
        }
        if (ch == 'C' || ch == 'c') {
            return getCurrencySymbol(locale) + "String_Node_Str";
        }
        if (ch == 'f' || ch == 'F') {
            return "String_Node_Str";
        }
        if (ch == 'N' || ch == 'n') {
            return "String_Node_Str";
        }
        if (ch == 'p' || ch == 'P') {
            return "String_Node_Str";
        }
        if (ch == 'e' || ch == 'E') {
            return "String_Node_Str";
        }
        if (ch == 'x' || ch == 'X') {
            return "String_Node_Str";
        }
    } else {
        if (givenValue.equals("String_Node_Str"))
            return "String_Node_Str";
        if (givenValue.equals("String_Node_Str"))
            return "String_Node_Str";
        if (givenValue.equals("String_Node_Str"))
            return "String_Node_Str";
        if (givenValue.equals("String_Node_Str"))
            return "String_Node_Str";
        if (givenValue.equals("String_Node_Str"))
            return "String_Node_Str";
        if (validType(givenValue)) {
            return givenValue;
        }
        int count = givenValue.length();
        boolean flag = false;
        for (int num = 0; num < count; num++) {
            char temp = givenValue.charAt(num);
            if (temp == '\'') {
                if (flag) {
                    flag = false;
                } else {
                    char nextChar = givenValue.charAt(num + 1);
                    if (nextChar == '\'') {
                        returnStr = returnStr + '\'';
                        num++;
                        flag = false;
                    } else {
                        flag = true;
                    }
                }
            } else {
                if (flag) {
                    returnStr = returnStr + "String_Node_Str" + temp;
                } else {
                    if (specialStr.indexOf(temp) != -1) {
                        returnStr = returnStr + "String_Node_Str" + temp;
                    } else if (temp == '¤') {
                        String symbol = getCurrencySymbol(locale);
                        returnStr = returnStr + symbol;
                    } else {
                        returnStr = returnStr + temp;
                    }
                }
            }
        }
    }
    return returnStr;
}

Output:
         }
-    } else {
-        if (givenValue.equals("String_Node_Str"))
-            return "String_Node_Str";
-        if (givenValue.equals("String_Node_Str"))
-            return "String_Node_Str";
-        if (givenValue.equals("String_Node_Str"))
-            return "String_Node_Str";
-        if (givenValue.equals("String_Node_Str"))
-            return "String_Node_Str";
-        if (givenValue.equals("String_Node_Str"))
-            return "String_Node_Str";
-        if (validType(givenValue)) {
-            return givenValue;
-        }
-        int count = givenValue.length();
-        boolean flag = false;
-        for (int num = 0; num < count; num++) {
-            char temp = givenValue.charAt(num);
-            if (temp == '\'') {
-                if (flag) {
+    }
+    if (givenValue.equals("String_Node_Str"))
+        return "String_Node_Str";
+    if (givenValue.equals("String_Node_Str"))
+        return "String_Node_Str";
+    if (givenValue.equals("String_Node_Str"))
+        return "String_Node_Str";
+    if (givenValue.equals("String_Node_Str"))
+        return "String_Node_Str";
+    if (givenValue.equals("String_Node_Str"))
+        return "String_Node_Str";
+    if (validType(givenValue)) {
+        return givenValue;
+    }
+    int count = givenValue.length();
+    boolean flag = false;
+    for (int num = 0; num < count; num++) {
+        char temp = givenValue.charAt(num);
+        if (temp == '\'') {
+            if (flag) {
+                flag = false;
+            } else {
+                char nextChar = givenValue.charAt(num + 1);
+                if (nextChar == '\'') {
+                    returnStr = returnStr + '\'';
+                    num++;
                     flag = false;


Input:
public boolean allocateResources(Quota quota, int cores) {
    return jdbc.update(ALLOCATE_RESOURCE, cores, quota.getQuotaId()) == 1;
}

Output:
 public boolean allocateResources(Quota quota, int cores) {
-    return jdbc.update(ALLOCATE_RESOURCE, cores, quota.getQuotaId()) == 1;
+    Preconditions.checkNotNull(quota);
+    return jdbc.update(ALLOCATE_RESOURCE, cores, quota.getQuotaId(), cores) == 1;
 }


Input:
private void getFirstWriteResults(List<WriteResponse.CHOICE> mmsResponseValues, List<BasicDataAttribute> totalBdasToBeWritten, int[] numBdas, int i, FcModelNode fcModelNode, Data mmsData) {
    WriteResponse.CHOICE writeResult = getWriteResult(fcModelNode, mmsData);
    if (writeResult == null) {
        FcModelNode fcModelNodeCopy = (FcModelNode) fcModelNode.copy();
        try {
            fcModelNodeCopy.setValueFromMmsDataObj(mmsData);
        } catch (ServiceError e) {
            logger.warn("String_Node_Str", e);
            WriteResponse.CHOICE writeResponseChoice = new WriteResponse.CHOICE();
            writeResponseChoice.setFailure(new DataAccessError(serviceErrorToMmsError(e)));
            mmsResponseValues.add(writeResponseChoice);
            return;
        }
        if (fcModelNodeCopy.fc == Fc.CO) {
            fcModelNodeCopy = (BasicDataAttribute) fcModelNodeCopy.getChild("String_Node_Str");
        } else {
        }
        List<BasicDataAttribute> bdas = fcModelNodeCopy.getBasicDataAttributes();
        totalBdasToBeWritten.addAll(bdas);
        numBdas[i] = bdas.size();
        mmsResponseValues.add(null);
    } else {
        mmsResponseValues.add(writeResult);
    }
}

Output:
         if (fcModelNodeCopy.fc == Fc.CO) {
-            fcModelNodeCopy = (BasicDataAttribute) fcModelNodeCopy.getChild("String_Node_Str");
+            fcModelNodeCopy = (FcModelNode) fcModelNodeCopy.getChild("String_Node_Str");
         } else {


Input:
protected void drawLinear(Canvas c, LineDataSet dataSet, ArrayList<Entry> entries) {
    int dataSetIndex = mChart.getLineData().getIndexOfDataSet(dataSet);
    Transformer trans = mChart.getTransformer(dataSet.getAxisDependency());
    float phaseX = mAnimator.getPhaseX();
    float phaseY = mAnimator.getPhaseY();
    mRenderPaint.setStyle(Paint.Style.STROKE);
    LineBuffer buffer = mLineBuffers[dataSetIndex];
    buffer.setPhases(phaseX, phaseY);
    buffer.feed(entries);
    trans.pointValuesToPixel(buffer.buffer);
    if (dataSet.getColors().size() > 1) {
        for (int j = 0; j < buffer.size() - 3; j += 2) {
            if (!mViewPortHandler.isInBoundsRight(buffer.buffer[j]))
                break;
            if (!mViewPortHandler.isInBoundsLeft(buffer.buffer[j + 2]) || (!mViewPortHandler.isInBoundsTop(buffer.buffer[j + 1]) && !mViewPortHandler.isInBoundsBottom(buffer.buffer[j + 3])) || (!mViewPortHandler.isInBoundsTop(buffer.buffer[j + 1]) && !mViewPortHandler.isInBoundsBottom(buffer.buffer[j + 3])))
                continue;
            mRenderPaint.setColor(dataSet.getColor(j / 2));
            c.drawLine(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], mRenderPaint);
        }
    } else {
        int from = mMinX * 4;
        int range = (mMaxX * 4 - mMinX) + 4;
        int to = range + from;
        mRenderPaint.setColor(dataSet.getColor());
        c.drawLines(buffer.buffer, from, to >= buffer.size() ? buffer.size() - from : range, mRenderPaint);
    }
    mRenderPaint.setPathEffect(null);
    if (dataSet.isDrawFilledEnabled() && entries.size() > 0) {
        drawLinearFill(c, dataSet, entries, trans);
    }
}

Output:
     if (dataSet.getColors().size() > 1) {
-        for (int j = 0; j < buffer.size() - 3; j += 2) {
+        for (int j = 0; j < buffer.size(); j += 4) {
             if (!mViewPortHandler.isInBoundsRight(buffer.buffer[j]))


Input:
private void stopRecording() {
    if (this.recorder != null) {
        this.recorder.stop();
        this.recorder.release();
    }
    this.recordingThread.stop();
}

Output:
     }
-    this.recordingThread.stop();
+    this.recordingThread.stopRecording();
 }


Input:
public void onMessage(Message message) {
    try {
        int msgNumProperty = message.getIntProperty(MESSAGE_NUMBER);
        if (complete) {
            LOG.info("String_Node_Str" + msgNumProperty);
            return;
        }
        if (msgNumProperty == 1) {
            if (!seenFirstMessage) {
                LOG.info("String_Node_Str");
                seenFirstMessage = true;
            } else {
                LOG.info("String_Node_Str");
                if (message.getJMSRedelivered()) {
                    LOG.info("String_Node_Str");
                } else {
                    LOG.error("String_Node_Str");
                    complete(true);
                }
                seenFirstMessageTwice = true;
            }
        } else if (msgNumProperty == 2) {
            if (!seenSecondMessage) {
                seenSecondMessage = true;
                LOG.info("String_Node_Str");
                session.recover();
            } else {
                LOG.info("String_Node_Str");
                seenSecondMessageTwice = true;
                if (message.getJMSRedelivered()) {
                    LOG.info("String_Node_Str");
                } else {
                    LOG.error("String_Node_Str");
                    complete(true);
                }
            }
        } else {
            if (msgNumProperty != 3) {
                LOG.error("String_Node_Str" + msgNumProperty);
                complete(true);
            }
            if (!seenFirstMessageTwice && !seenSecondMessageTwice) {
                LOG.error("String_Node_Str");
                complete(true);
            }
            if (message.getJMSRedelivered()) {
                LOG.error("String_Node_Str");
                complete(true);
            } else {
                LOG.info("String_Node_Str");
                complete(false);
            }
        }
    } catch (JMSException e) {
        LOG.error("String_Node_Str", e);
        complete(true);
    }
}

Output:
             }
-            if (!seenFirstMessageTwice && !seenSecondMessageTwice) {
+            if (!(seenFirstMessageTwice && seenSecondMessageTwice)) {
                 LOG.error("String_Node_Str");


Input:
public R value() {
    if (row.isComplete()) {
        OsStats.Cgroup cgroup = row.osStats().getCgroup();
        if (cgroup == null) {
            return null;
        }
        return getter.apply(cgroup);
    }
    return null;
}

Output:
     if (row.isComplete()) {
-        OsStats.Cgroup cgroup = row.osStats().getCgroup();
-        if (cgroup == null) {
-            return null;
+        OsStats.Cgroup cgroup = row.extendedOsStats().osStats().getCgroup();
+        if (cgroup != null) {
+            return getter.apply(cgroup);
         }


Input:
public String getPenetrationDescription(boolean initialPenetration, GameCharacter characterPenetrating, PenetrationType penetrationType, GameCharacter characterPenetrated, OrificeType orifice) {
    if (orifice == OrificeType.ANUS) {
        if (characterPenetrated.isPlayer()) {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (!characterPenetrating.isPlayer()) {
                            switch(getPenisType()) {
                                case ANGEL:
                                    break;
                                case AVIAN:
                                    break;
                                case BOVINE:
                                    return "String_Node_Str";
                                case CANINE:
                                    return "String_Node_Str";
                                case LUPINE:
                                    return "String_Node_Str";
                                case ALLIGATOR_MORPH:
                                    return "String_Node_Str";
                                case SQUIRREL:
                                    return "String_Node_Str";
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                case EQUINE:
                                    return "String_Node_Str";
                                case REINDEER_MORPH:
                                    return "String_Node_Str";
                                case FELINE:
                                    return "String_Node_Str";
                                case HUMAN:
                                    break;
                                case NONE:
                                    break;
                                case SLIME:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        } else {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (characterPenetrating.isPlayer()) {
                            switch(getAssType()) {
                                case DEMON_COMMON:
                                    return "String_Node_Str" + "String_Node_Str";
                                default:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        }
    } else if (orifice == OrificeType.VAGINA) {
        if (characterPenetrated.isPlayer()) {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (!characterPenetrating.isPlayer()) {
                            switch(getPenisType()) {
                                case ANGEL:
                                    break;
                                case AVIAN:
                                    break;
                                case BOVINE:
                                    return "String_Node_Str";
                                case CANINE:
                                    return "String_Node_Str";
                                case LUPINE:
                                    return "String_Node_Str";
                                case ALLIGATOR_MORPH:
                                    return "String_Node_Str";
                                case SQUIRREL:
                                    return "String_Node_Str";
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                case EQUINE:
                                    return "String_Node_Str";
                                case REINDEER_MORPH:
                                    return "String_Node_Str";
                                case FELINE:
                                    return "String_Node_Str";
                                case HUMAN:
                                    break;
                                case NONE:
                                    break;
                                case SLIME:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        } else {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (characterPenetrating.isPlayer()) {
                            switch(getVaginaType()) {
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                default:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        }
    } else if (orifice == OrificeType.NIPPLE) {
        if (characterPenetrated.isPlayer()) {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (!characterPenetrating.isPlayer()) {
                            switch(getPenisType()) {
                                case ANGEL:
                                    break;
                                case AVIAN:
                                    break;
                                case BOVINE:
                                    return "String_Node_Str";
                                case CANINE:
                                    return "String_Node_Str";
                                case LUPINE:
                                    return "String_Node_Str";
                                case ALLIGATOR_MORPH:
                                    return "String_Node_Str";
                                case SQUIRREL:
                                    return "String_Node_Str";
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                case EQUINE:
                                    return "String_Node_Str";
                                case REINDEER_MORPH:
                                    return "String_Node_Str";
                                case FELINE:
                                    return "String_Node_Str";
                                case HUMAN:
                                    break;
                                case NONE:
                                    break;
                                case SLIME:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        } else {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (characterPenetrating.isPlayer()) {
                            switch(getBreastType()) {
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                default:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        }
    } else if (orifice == OrificeType.MOUTH) {
        if (characterPenetrated.isPlayer()) {
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (!characterPenetrating.isPlayer()) {
                            switch(getPenisType()) {
                                case ANGEL:
                                    break;
                                case AVIAN:
                                    break;
                                case BOVINE:
                                    return "String_Node_Str";
                                case CANINE:
                                    return "String_Node_Str";
                                case LUPINE:
                                    return "String_Node_Str";
                                case ALLIGATOR_MORPH:
                                    return "String_Node_Str";
                                case SQUIRREL:
                                    return "String_Node_Str";
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                case EQUINE:
                                    return "String_Node_Str";
                                case REINDEER_MORPH:
                                    return "String_Node_Str";
                                case FELINE:
                                    return "String_Node_Str";
                                case HUMAN:
                                    break;
                                case NONE:
                                    break;
                                case SLIME:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        } else {
            if (penetrationType != PenetrationType.TONGUE && !characterPenetrated.isPlayer()) {
                characterPenetrated.getPlayerKnowsAreas().add(CoverableArea.MOUTH);
            }
            if (initialPenetration) {
                switch(penetrationType) {
                    case PENIS:
                        if (characterPenetrating.isPlayer()) {
                            switch(Main.game.getPlayer().getPenisType()) {
                                case ANGEL:
                                    break;
                                case AVIAN:
                                    break;
                                case BOVINE:
                                    return "String_Node_Str";
                                case CANINE:
                                    return "String_Node_Str";
                                case LUPINE:
                                    return "String_Node_Str";
                                case ALLIGATOR_MORPH:
                                    return "String_Node_Str";
                                case SQUIRREL:
                                    return "String_Node_Str";
                                case DEMON_COMMON:
                                    return "String_Node_Str";
                                case EQUINE:
                                    return "String_Node_Str";
                                case REINDEER_MORPH:
                                    return "String_Node_Str";
                                case FELINE:
                                    return "String_Node_Str";
                                case HUMAN:
                                    break;
                                case NONE:
                                    break;
                                case SLIME:
                                    break;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
            }
            return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
        }
    } else if (orifice == OrificeType.THIGHS) {
        if (initialPenetration) {
            return getGenericInitialPenetration(characterPenetrating, penetrationType, characterPenetrated, orifice);
        }
        return generateGenericPenetrationDescription(characterPenetrating, penetrationType, characterPenetrated, orifice);
    }
    return "String_Node_Str";
}

Output:
                         if (!characterPenetrating.isPlayer()) {
-                            switch(getPenisType()) {
+                            switch(characterPenetrating.getPenisType()) {
                                 case ANGEL:


Input:
public void visitDataItem(DataItemHandle handle) {
    DataItemDesign data = new DataItemDesign();
    setupReportItem(data, handle);
    String expr = handle.getResultSetColumn();
    if (expr != null && expr.trim().length() > 0) {
        data.setBindingColumn(expr);
    }
    ActionHandle action = handle.getActionHandle();
    if (action != null) {
        data.setAction(createAction(action));
    }
    data.setHelpText(handle.getHelpTextKey(), handle.getHelpText());
    setupHighlight(data, expr);
    setMap(data, expr);
    if (extendedItemNestingCount > 0) {
        data.setNeedRefreshMapping(true);
    }
    currentElement = data;
}

Output:
     }
-    currentElement = data;
+    setCurrentElement(data);
 }


Input:
public void start(StockSpace startSpace) {
    super.start(startSpace);
    Train nextAvailableTrain = Iterables.get(gameManager.getTrainManager().getAvailableNewTrains(), 0);
    int trainNumber;
    try {
        trainNumber = Integer.parseInt(nextAvailableTrain.getId());
    } catch (NumberFormatException e) {
        trainNumber = 6;
    }
    trainNumberAvailableAtStart.set(trainNumber);
    if (trainNumber == 6) {
        this.capitalisation = CAPITALISE_FULL;
    }
}

Output:
     try {
-        trainNumber = Integer.parseInt(nextAvailableTrain.getId());
+        trainNumber = Integer.parseInt(nextAvailableTrain.getCertType().getId());
     } catch (NumberFormatException e) {


Input:
private Object getCascadedInstance(String methodNameAndDesc, String returnTypeInternalName) {
    Type returnType = cascadedTypesAndMocks.get(returnTypeInternalName);
    if (returnType == null) {
        returnType = registerIntermediateCascadingType(methodNameAndDesc, returnTypeInternalName);
        if (returnType == null) {
            if (cascadedInstance != null) {
                return cascadedInstance;
            }
            returnType = mockedType;
        }
    }
    return createNewCascadedInstanceOrUseNonCascadedOneIfAvailable(methodNameAndDesc, returnType);
}

Output:
     if (returnType == null) {
-        returnType = registerIntermediateCascadingType(methodNameAndDesc, returnTypeInternalName);
-        if (returnType == null) {
+        Class<?> cascadingClass = mockedType instanceof Class<?> ? (Class<?>) mockedType : (Class<?>) ((ParameterizedType) mockedType).getRawType();
+        Type genericReturnType = getGenericReturnType(cascadingClass, methodNameAndDesc);
+        Class<?> resolvedReturnType = getClassType(genericReturnType);
+        if (resolvedReturnType.isAssignableFrom(cascadingClass)) {
             if (cascadedInstance != null) {


Input:
private void processParsingErrors(Spec spec, IProgressMonitor monitor) {
    switch(spec.getStatus()) {
        case IParseConstants.SYNTAX_ERROR:
            String[] output = ToolIO.getAllMessages();
            int nextMsg = 0;
            while ((nextMsg < output.length) && (output[nextMsg].indexOf("String_Node_Str") != -1)) {
                nextMsg++;
            }
            if ((nextMsg != 0) && (nextMsg != output.length)) {
                int parsingModuleIndex = output[nextMsg - 1].indexOf("String_Node_Str") + 15;
                IFile module = spec.findModule(output[nextMsg - 1].substring(parsingModuleIndex, output[nextMsg - 1].indexOf("String_Node_Str", parsingModuleIndex + 1)));
                int[] coordinates = null;
                String message = output[nextMsg];
                if ((message.indexOf("String_Node_Str") != -1) || (message.indexOf("String_Node_Str") != -1)) {
                    int[] val = findLineAndColumn(0, message);
                    int beginLine = val[0];
                    int beginColumn = val[1];
                    int endLine = 0;
                    int endColumn = 0;
                    val = findLineAndColumn(val[2], message);
                    if ((val[0] > beginLine) || ((val[0] == beginLine) && (val[1] >= beginColumn))) {
                        endLine = val[0];
                        endColumn = val[1];
                    }
                    coordinates = new int[] { beginLine, beginColumn, endLine, endColumn };
                    TLAMarkerHelper.installProblemMarkerOnModule(module, IMarker.SEVERITY_ERROR, coordinates, message, monitor);
                } else {
                    if (parseErrors != null) {
                        String[] aborts = parseErrors.getAborts();
                        if (aborts.length > 0) {
                            message = aborts[0];
                        }
                    }
                    if (message != null && message.indexOf("String_Node_Str") == -1) {
                        coordinates = new int[] { -1, -1, -1, -1 };
                    } else {
                        throw new RuntimeException("String_Node_Str");
                    }
                    if (module == null) {
                        TLAMarkerHelper.installProblemMarkerOnSpec(spec, IMarker.SEVERITY_ERROR, coordinates, message, monitor);
                    } else {
                        TLAMarkerHelper.installProblemMarkerOnModule(module, IMarker.SEVERITY_ERROR, coordinates, message, monitor);
                    }
                }
            } else {
                throw new RuntimeException("String_Node_Str" + "String_Node_Str");
            }
            break;
        case IParseConstants.SEMANTIC_ERROR:
        case IParseConstants.SEMANTIC_WARNING:
            if (semanticErrors != null) {
                String[][] errors = { semanticErrors.getAborts(), semanticErrors.getErrors(), semanticErrors.getWarnings() };
                int[] holderType = { IMarker.SEVERITY_ERROR, IMarker.SEVERITY_ERROR, IMarker.SEVERITY_WARNING };
                for (int j = 0; j < 3; j++) {
                    for (int i = 0; i < errors[j].length; i++) {
                        encodeSematicErrorFromString(spec, errors[j][i], holderType[j], monitor);
                    }
                }
            } else {
                throw new RuntimeException("String_Node_Str" + "String_Node_Str");
            }
            break;
        case IParseConstants.COULD_NOT_FIND_MODULE:
            TLAMarkerHelper.installProblemMarkerOnSpec(spec, IMarker.SEVERITY_ERROR, new int[] { -1, -1, -1, -1 }, "String_Node_Str", monitor);
            break;
        case IParseConstants.PARSED:
            break;
        default:
            throw new RuntimeException("String_Node_Str" + spec.getStatus());
    }
    cleanUp();
}

Output:
                 int parsingModuleIndex = output[nextMsg - 1].indexOf("String_Node_Str") + 15;
-                IFile module = spec.findModule(output[nextMsg - 1].substring(parsingModuleIndex, output[nextMsg - 1].indexOf("String_Node_Str", parsingModuleIndex + 1)));
+                IFile module = spec.findModuleFile(output[nextMsg - 1].substring(parsingModuleIndex, output[nextMsg - 1].indexOf("String_Node_Str", parsingModuleIndex + 1)));
                 int[] coordinates = null;


Input:
public boolean action() throws InvalidEventHandlerException {
    if (clientChannel == null)
        throw new InvalidEventHandlerException();
    long currentTime = Time.currentTimeMillis();
    long millisecondsSinceLastMessageReceived = currentTime - lastTimeMessageReceived;
    long millisecondsSinceLastHeatbeatSend = currentTime - lastheartbeatSentTime;
    if (millisecondsSinceLastMessageReceived >= HEATBEAT_PING_PERIOD && millisecondsSinceLastHeatbeatSend >= HEATBEAT_PING_PERIOD) {
        lastheartbeatSentTime = Time.currentTimeMillis();
        sendHeartbeat();
    }
    long x = millisecondsSinceLastMessageReceived - HEATBEAT_TIMEOUT_PERIOD;
    if (x > 0) {
        LOG.warn("String_Node_Str");
        disconnect();
        throw new InvalidEventHandlerException();
    }
    return true;
}

Output:
         LOG.warn("String_Node_Str");
-        disconnect();
+        closeSocket();
         throw new InvalidEventHandlerException();


Input:
public RemoteViews getViewAt(int position) {
    if (Constants.debugModeWidget)
        Log.d(TAG, "String_Node_Str" + position);
    RssItem rssItem = rssItems.get(position);
    RemoteViews rv = new RemoteViews(context.getPackageName(), R.layout.widget_item);
    try {
        String header = rssItem.getFeed().getFeedTitle();
        String colorString = rssItem.getFeed().getAvgColour();
        String authorOfArticle = rssItem.getAuthor();
        header += authorOfArticle == null ? "String_Node_Str" : "String_Node_Str" + authorOfArticle.trim();
        String title = Html.fromHtml(rssItem.getTitle()).toString();
        long id = rssItem.getId();
        Date date = rssItem.getPubDate();
        String dateString = "String_Node_Str";
        if (date != null) {
            SimpleDateFormat formater = new SimpleDateFormat();
            dateString = formater.format(date);
        }
        rv.setTextViewText(R.id.feed_datetime, dateString);
        rv.setTextViewText(R.id.feed_author_source, header);
        rv.setTextViewText(R.id.feed_title, title);
        int resId = rssItem.getRead_temp() ? R.drawable.ic_check_box_white : R.drawable.ic_check_box_outline_blank_white;
        int contentDescriptionId = rssItem.getRead_temp() ? R.string.content_desc_mark_as_unread : R.string.content_desc_mark_as_read;
        rv.setInt(R.id.cb_lv_item_read, "String_Node_Str", resId);
        rv.setContentDescription(R.id.cb_lv_item_read, context.getString(contentDescriptionId));
        if (colorString != null)
            rv.setInt(R.id.color_line_feed, "String_Node_Str", Integer.parseInt(colorString));
        Intent ei = new Intent();
        ei.putExtra(WidgetProvider.RSS_ITEM_ID, id);
        rv.setOnClickFillInIntent(R.id.cb_lv_item_read_wrapper, ei);
        Intent iCheck = new Intent();
        iCheck.putExtra(WidgetProvider.RSS_ITEM_ID, id);
        iCheck.putExtra(WidgetProvider.ACTION_CHECKED_CLICK, true);
        rv.setOnClickFillInIntent(R.id.cb_lv_item_read, iCheck);
    } catch (Exception ex) {
        Log.e(TAG, "String_Node_Str" + ex.getLocalizedMessage());
    }
    return rv;
}

Output:
         rv.setContentDescription(R.id.cb_lv_item_read, context.getString(contentDescriptionId));
-        if (colorString != null)
+        if (colorString != null) {
             rv.setInt(R.id.color_line_feed, "String_Node_Str", Integer.parseInt(colorString));


Input:
private void structureDocHits(DocHit[] docHits, int startDoc, StringBuffer buf) {
    if (docHits == null)
        return;
    for (int i = 0; i < docHits.length; i++) {
        DocHit docHit = docHits[i];
        String scoreStr;
        if (scoresNormalized)
            scoreStr = Integer.toString(Math.round(docHit.score * 100));
        else {
            if (decFormat == null)
                decFormat = (DecimalFormat) DecimalFormat.getInstance();
            scoreStr = decFormat.format(docHit.score);
        }
        buf.append("String_Node_Str" + "String_Node_Str" + (i + startDoc + 1) + "String_Node_Str" + "String_Node_Str" + TextServlet.makeHtmlString(docHit.filePath()) + "String_Node_Str" + "String_Node_Str" + scoreStr + "String_Node_Str" + "String_Node_Str" + docHit.totalSnippets() + "String_Node_Str");
        if (docHit.recordNum() > 0)
            buf.append("String_Node_Str" + docHit.recordNum() + "String_Node_Str");
        if (docHit.subDocument() != null)
            buf.append("String_Node_Str" + docHit.subDocument() + "String_Node_Str");
        buf.append("String_Node_Str");
        Explanation explanation = docHit.explanation();
        if (explanation != null)
            structureExplanation(explanation, buf);
        if (!docHit.metaData().isEmpty()) {
            buf.append("String_Node_Str");
            for (Iterator atts = docHit.metaData().iterator(); atts.hasNext(); ) {
                Attrib attrib = (Attrib) atts.next();
                buf.append(attrib.value);
            }
            buf.append("String_Node_Str");
        }
        for (int j = 0; j < docHit.nSnippets(); j++) {
            Snippet snippet = docHit.snippet(j, true);
            buf.append("String_Node_Str" + (j + 1) + "String_Node_Str" + Math.round(snippet.score * 100) + "String_Node_Str");
            if (snippet.sectionType != null)
                buf.append("String_Node_Str" + snippet.sectionType + "String_Node_Str");
            buf.append("String_Node_Str" + TextServlet.makeHtmlString(snippet.text, true) + "String_Node_Str");
        }
        buf.append("String_Node_Str");
    }
}

Output:
         if (docHit.subDocument() != null)
-            buf.append("String_Node_Str" + docHit.subDocument() + "String_Node_Str");
+            buf.append("String_Node_Str" + TextServlet.makeHtmlString(docHit.subDocument()) + "String_Node_Str");
         buf.append("String_Node_Str");


Input:
private void switchAccounts(final MaterialAccount newAccount) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
        final ImageView floatingImage = new ImageView(this);
        Rect startingRect = new Rect();
        Rect finalRect = new Rect();
        Point offsetHover = new Point();
        float finalScale = 1.6f;
        final int statusBarHeight;
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT || (Build.VERSION.SDK_INT == Build.VERSION_CODES.KITKAT && !kitkatTraslucentStatusbar)) {
            statusBarHeight = (int) (25 * density);
        } else {
            statusBarHeight = 0;
        }
        ImageView photoClicked;
        if (newAccount.getAccountNumber() == MaterialAccount.SECOND_ACCOUNT) {
            photoClicked = userSecondPhoto;
        } else {
            photoClicked = userThirdPhoto;
        }
        photoClicked.getGlobalVisibleRect(startingRect, offsetHover);
        floatingImage.setImageDrawable(photoClicked.getDrawable());
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(photoClicked.getWidth(), photoClicked.getHeight());
        params.setMargins(offsetHover.x, offsetHover.y - statusBarHeight, 0, 0);
        drawer.addView(floatingImage, params);
        photoClicked.setImageBitmap(currentAccount.getCircularPhoto());
        usercoverSwitcher.setImageBitmap(newAccount.getBackground());
        userphoto.getGlobalVisibleRect(finalRect);
        int offset = (((finalRect.bottom - finalRect.top) - (startingRect.bottom - finalRect.top)) / 2);
        finalRect.offset(offset, offset - statusBarHeight);
        startingRect.offset(0, -statusBarHeight);
        AnimatorSet set = new AnimatorSet();
        set.play(ObjectAnimator.ofFloat(floatingImage, View.X, startingRect.left, finalRect.left)).with(ObjectAnimator.ofFloat(floatingImage, View.Y, startingRect.top, finalRect.top)).with(ObjectAnimator.ofFloat(floatingImage, View.SCALE_X, 1f, finalScale)).with(ObjectAnimator.ofFloat(floatingImage, View.SCALE_Y, 1f, finalScale)).with(ObjectAnimator.ofFloat(userphoto, View.ALPHA, 1f, 0f)).with(ObjectAnimator.ofFloat(usercover, View.ALPHA, 1f, 0f)).with(ObjectAnimator.ofFloat(photoClicked, View.SCALE_X, 0f, 1f)).with(ObjectAnimator.ofFloat(photoClicked, View.SCALE_Y, 0f, 1f));
        set.setDuration(USER_CHANGE_TRANSITION);
        set.setInterpolator(new DecelerateInterpolator());
        set.addListener(new AnimatorListenerAdapter() {
            public void onAnimationEnd(Animator animation) {
                ((View) userphoto).setAlpha(1);
                setFirstAccountPhoto(newAccount.getCircularPhoto());
                drawer.removeView(floatingImage);
                setUserEmail(newAccount.getSubTitle());
                setUsername(newAccount.getTitle());
                setDrawerBackground(newAccount.getBackground());
                ((View) usercover).setAlpha(1);
                currentAccount.setAccountNumber(newAccount.getAccountNumber());
                newAccount.setAccountNumber(MaterialAccount.FIRST_ACCOUNT);
                currentAccount = newAccount;
                if (!deviceSupportMultiPane())
                    layout.closeDrawer(drawer);
            }
            public void onAnimationCancel(Animator animation) {
                onAnimationEnd(animation);
            }
        });
        set.start();
    } else {
        currentAccount.setAccountNumber(newAccount.getAccountNumber());
        newAccount.setAccountNumber(MaterialAccount.FIRST_ACCOUNT);
        currentAccount = newAccount;
        notifyAccountDataChanged();
        if (!deviceSupportMultiPane())
            layout.closeDrawer(drawer);
    }
}

Output:
         drawer.addView(floatingImage, params);
-        photoClicked.setImageBitmap(currentAccount.getCircularPhoto());
-        usercoverSwitcher.setImageBitmap(newAccount.getBackground());
+        photoClicked.setImageDrawable(currentAccount.getCircularPhoto());
+        usercoverSwitcher.setImageDrawable(newAccount.getBackground());
         userphoto.getGlobalVisibleRect(finalRect);


Input:
private void player(Player player, String[] args) {
    Player target = Canary.getServer().matchPlayer(args[1]);
    if (args.length == 2) {
        if (target != null) {
            player.teleportTo(target.getLocation(), TeleportHook.TeleportCause.COMMAND);
            player.message(Colors.YELLOW + Translator.translateAndFormat("String_Node_Str", target.getName()));
        } else {
            World w = Canary.getServer().getWorldManager().getWorld(args[1], player.hasPermission("String_Node_Str") ? true : false);
            if (w == null) {
                player.notice(Translator.translateAndFormat("String_Node_Str", args[1]));
            }
            if (player.hasPermission("String_Node_Str")) {
                player.teleportTo(w.getSpawnLocation());
            }
        }
    } else if (args.length > 3) {
        try {
            double x = Double.parseDouble(args[1]), y = Double.parseDouble(args[2]), z = Double.parseDouble(args[3]);
            if (args.length > 4 && player.hasPermission("String_Node_Str")) {
                try {
                    String dTypeName = args[4].replaceAll("String_Node_Str", "String_Node_Str");
                    DimensionType dType = DimensionType.fromName(dTypeName);
                    String correctedName = dType == null ? args[4] : args[4].replaceAll("String_Node_Str", "String_Node_Str");
                    if (dType == null) {
                        dType = DimensionType.fromName("String_Node_Str");
                    }
                    World world = Canary.getServer().getWorldManager().getWorld(correctedName, dType, args.length > 5 && player.hasPermission("String_Node_Str") ? Boolean.valueOf(args[5]) : false);
                    if (world != null) {
                        player.teleportTo(x, y, z, world);
                    } else {
                        player.notice("String_Node_Str");
                    }
                } catch (UnknownWorldException uwex) {
                    player.notice("String_Node_Str");
                }
            } else {
                player.teleportTo(x, y, z);
            }
        } catch (NumberFormatException nfex) {
            player.notice(Translator.translateAndFormat("String_Node_Str"));
        }
    } else if (target != null) {
        player.teleportTo(target.getLocation(), TeleportHook.TeleportCause.COMMAND);
        player.message(Colors.YELLOW + Translator.translateAndFormat("String_Node_Str", target.getName()));
    } else {
        player.notice(Translator.translateAndFormat("String_Node_Str", args[1]));
    }
}

Output:
         } else {
-            World w = Canary.getServer().getWorldManager().getWorld(args[1], player.hasPermission("String_Node_Str") ? true : false);
+            World w = Canary.getServer().getWorldManager().getWorld(args[1], player.hasPermission("String_Node_Str"));
             if (w == null) {


Input:
public ChannelFactory getChannelFactory() {
    return new NioChannelFactory();
}

Output:
 public ChannelFactory getChannelFactory() {
-    return new NioChannelFactory();
+    boolean spinning = Boolean.getBoolean("String_Node_Str");
+    return spinning ? new SpinningChannelFactory() : new NioChannelFactory();
 }


Input:
public void constructQueryUrl() {
    String http = "String_Node_Str";
    String host = "String_Node_Str";
    String queryUrl = http + lang.getLangCode() + host + "String_Node_Str" + outputFormat + "String_Node_Str" + queryAction + "String_Node_Str" + queryType + "String_Node_Str" + queryLimitPrefix + "String_Node_Str";
    if (this.title != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + (pluralPage ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + title;
    }
    if (this.pageid != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + (pluralPage ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + pageid;
    }
    if ((this.redirects != null) && this.redirects) {
        queryUrl += "String_Node_Str";
    }
    if (this.filterredir != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + "String_Node_Str" + filterredir;
    }
    if (this.from != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + "String_Node_Str" + from;
    }
    if (this.namespace != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + "String_Node_Str" + namespace;
    }
    if (this.prop != null) {
        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + "String_Node_Str" + prop;
    }
    this.queryUrl = queryUrl;
}

Output:
     String queryUrl = http + lang.getLangCode() + host + "String_Node_Str" + outputFormat + "String_Node_Str" + queryAction + "String_Node_Str" + queryType + "String_Node_Str" + queryLimitPrefix + "String_Node_Str";
-    if (this.title != null) {
-        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + (pluralPage ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + title;
+    if (!this.titles.isEmpty()) {
+        queryUrl += "String_Node_Str" + queryInfoPrefix + "String_Node_Str" + (pluralPage ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str" + titles.get(0);
+        for (int i = 1; i < titles.size(); i++) {
+            queryUrl += "String_Node_Str" + titles.get(i);
+        }
     }


Input:
public Integer call() throws Exception {
    if (message == null) {
        return 0;
    }
    if (message.getClients() == null || message.getClients().size() == 0) {
        Collection<Integer> cids = ClientKeeper.gets(product.getAppKey());
        int s = start * limit;
        if (cids.size() < limit) {
            limit = cids.size();
        }
        Integer[] temp = cids.toArray(new Integer[0]);
        SentProgress progress = new SentProgress(limit);
        for (int i = 0; i < limit; i++) {
            int cid = temp[s + i];
            Connection c = ConnectionKeeper.get(cid);
            if (c != null) {
                c.send(progress, message);
            } else {
                progress.incrFailed();
            }
        }
        progress.getCountDownLatch().wait();
        int t0 = progress.getSuccess().get();
        try {
            PayloadService.instance.updateSendStatus(message, t0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (t0 > 0) {
            MetricBuilder.pushMeter.mark(t0);
            MetricBuilder.boradcastMeter.mark(t0);
        }
        return t0;
    }
    return 0;
}

Output:
         }
-        progress.getCountDownLatch().wait();
+        try {
+            progress.getCountDownLatch().await();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
         int t0 = progress.getSuccess().get();


Input:
public SwaggerParseResult readContents(String swaggerAsString, OpenAPI startingModel, List<AuthorizationValue> auth, ParseOptions options) {
    SwaggerParseResult result = new SwaggerParseResult();
    if (swaggerAsString != null && !"String_Node_Str".equals(swaggerAsString.trim())) {
        ObjectMapper mapper = getRightMapper(swaggerAsString);
        if (auth == null) {
            auth = new ArrayList<>();
        }
        if (options != null) {
            if (options.isResolve()) {
                try {
                    OpenAPIDeserializer deserializer = new OpenAPIDeserializer();
                    JsonNode rootNode = mapper.readTree(swaggerAsString.getBytes());
                    result = deserializer.deserialize(rootNode, startingModel);
                    OpenAPIResolver resolver = new OpenAPIResolver(result.getOpenAPI(), auth, null);
                    result.setOpenAPI(resolver.resolve());
                } catch (Exception e) {
                    result.setMessages(Arrays.asList(e.getMessage()));
                }
            } else {
                try {
                    JsonNode rootNode = mapper.readTree(swaggerAsString.getBytes());
                    result = new OpenAPIDeserializer().deserialize(rootNode, null);
                } catch (Exception e) {
                    result.setMessages(Arrays.asList(e.getMessage()));
                }
            }
            if (options.isResolveFully()) {
                result.setOpenAPI(new OpenAPIResolver(result.getOpenAPI(), auth, null).resolve());
                new ResolverFully(options.isResolveCombinators()).resolveFully(result.getOpenAPI());
            }
            if (options.isFlatten()) {
                new InlineModelResolver().flatten(result.getOpenAPI());
            }
        } else {
            try {
                JsonNode rootNode = mapper.readTree(swaggerAsString.getBytes());
                result = new OpenAPIDeserializer().deserialize(rootNode, null);
            } catch (Exception e) {
                result.setMessages(Arrays.asList(e.getMessage()));
            }
        }
    } else {
        result.setMessages(Arrays.asList("String_Node_Str"));
    }
    return result;
}

Output:
                     JsonNode rootNode = mapper.readTree(swaggerAsString.getBytes());
-                    result = new OpenAPIDeserializer().deserialize(rootNode, null);
+                    result = new OpenAPIDeserializer().deserialize(rootNode, startingModel);
                 } catch (Exception e) {


Input:
public void close(ChangeAction action) {
    if (checkRequirementsForClose(action)) {
        int index = undoStack.size() + 1;
        ChangeSet closeSet = new ChangeSet(changeBuilder.build(), action, index);
        log.debug("String_Node_Str" + closeSet);
        undoStack.addLast(closeSet);
        redoStack.clear();
        if (reporter != null) {
            reporter.updateOnClose(closeSet);
        }
        restart();
        updateObservers(closeSet.getStates());
    }
}

Output:
         if (reporter != null) {
-            reporter.updateOnClose(closeSet);
+            reporter.updateOnClose();
         }


Input:
public void toJSON(JSONWriter writer, String key, DataConversion clientConversion, IDataConverterContext dataConverterContext) throws JSONException {
    if (value instanceof UUID || value instanceof UUID) {
        value = value.toString();
    }
    JSONUtils.addKeyIfPresent(writer, key);
    if (jsonValue == null) {
        if (findMode) {
            jsonValue = value instanceof String ? value : (value != null ? String.valueOf(value) : "String_Node_Str");
        } else if (typeOfDP != null) {
            EmbeddableJSONWriter ejw = new EmbeddableJSONWriter(true);
            DataConversion jsonDataConversion = new DataConversion();
            FullValueToJSONConverter.INSTANCE.toJSONValue(ejw, null, value, typeOfDP, jsonDataConversion, dataConverterContext.getWebObject());
            if (jsonDataConversion.getConversions().size() == 0)
                jsonDataConversion = null;
            String str = ejw.toJSONString();
            if (str == null || "String_Node_Str".equals(str)) {
                System.err.println(str);
            }
            jsonValue = new JSONStringWithConversions(ejw.toJSONString(), jsonDataConversion);
        } else {
            jsonValue = value;
        }
    }
    writer.value(jsonValue);
    if (jsonValue instanceof IJSONStringWithConversions)
        clientConversion.convert(((IJSONStringWithConversions) jsonValue).getDataConversions());
}

Output:
             String str = ejw.toJSONString();
-            if (str == null || "String_Node_Str".equals(str)) {
-                System.err.println(str);
+            if (str == null || str.trim().length() == 0) {
+                Debug.error("String_Node_Str" + typeOfDP + "String_Node_Str" + value + "String_Node_Str");
+                str = "String_Node_Str";
             }


Input:
public String updateForm(String id, Model uiModel, HttpServletRequest request) {
    Patient patient = allPatients.findByIdAndClinicId(id, loggedInClinic(request));
    if (patient == null)
        return "String_Node_Str";
    List<SystemCategory> allSystemCategories = SystemCategoryDefinition.all();
    List<SystemCategory> patientSystemCategories = patient.getMedicalHistory().getNonHivMedicalHistory().getSystemCategories();
    List<SystemCategory> systemCategories = getSystemCategories(allSystemCategories, patientSystemCategories);
    patient.getMedicalHistory().getNonHivMedicalHistory().setSystemCategories(systemCategories);
    initUIModel(uiModel, patient);
    uiModel.addAttribute("String_Node_Str", systemCategories);
    uiModel.addAttribute("String_Node_Str", patient.canTransitionToWeekly(minNumberOfDaysOnDailyBeforeTransitioningToWeekly));
    return UPDATE_VIEW;
}

Output:
     initUIModel(uiModel, patient);
-    uiModel.addAttribute("String_Node_Str", systemCategories);
+    uiModel.addAttribute("String_Node_Str", patientSystemCategories);
     uiModel.addAttribute("String_Node_Str", patient.canTransitionToWeekly(minNumberOfDaysOnDailyBeforeTransitioningToWeekly));


Input:
protected Object reduce(Collection<QueryResultEntry> result) {
    HashMap<Data, Data> map = new HashMap<Data, Data>();
    for (QueryResultEntry resultEntry : result) {
        map.put(resultEntry.getKeyData(), resultEntry.getValueData());
    }
    Set<Map.Entry<Data, Data>> entries = map.entrySet();
    return entries;
}

Output:
     HashMap<Data, Data> map = new HashMap<Data, Data>();
-    for (QueryResultEntry resultEntry : result) {
-        map.put(resultEntry.getKeyData(), resultEntry.getValueData());
+    for (QueryResultRow resultEntry : result) {
+        map.put(resultEntry.getKey(), resultEntry.getValue());
     }


Input:
ICubeQueryDefinition createMirroredQueryDefinition() {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(cubeName);
    cqd.createMeasure("String_Node_Str");
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition productLineDim1 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition porductLineHie1 = productLineDim1.createHierarchy("String_Node_Str");
    ILevelDefinition columnLevel1 = porductLineHie1.createLevel("String_Node_Str");
    IDimensionDefinition productLineDim2 = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition porductLineHie2 = productLineDim2.createHierarchy("String_Node_Str");
    ILevelDefinition columnLevel2 = porductLineHie2.createLevel("String_Node_Str");
    columnEdge.setMirrorStartingLevel(columnLevel2);
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IDimensionDefinition geographyDim1 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier1 = geographyDim1.createHierarchy("String_Node_Str");
    geographyHier1.createLevel("String_Node_Str");
    IDimensionDefinition geographyDim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier2 = geographyDim2.createHierarchy("String_Node_Str");
    geographyHier2.createLevel("String_Node_Str");
    IDimensionDefinition geographyDim3 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier3 = geographyDim3.createHierarchy("String_Node_Str");
    ILevelDefinition startLevel = geographyHier3.createLevel("String_Node_Str");
    IDimensionDefinition geographyDim4 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier4 = geographyDim4.createHierarchy("String_Node_Str");
    geographyHier4.createLevel("String_Node_Str");
    rowEdge.setMirrorStartingLevel(startLevel);
    return cqd;
}

Output:
     ILevelDefinition columnLevel2 = porductLineHie2.createLevel("String_Node_Str");
-    columnEdge.setMirrorStartingLevel(columnLevel2);
+    columnEdge.creatMirrorDefinition(columnLevel2, breakHierarchy);
     IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);


Input:
public Double getVertexScore(Vertex v) {
    double degree = Graphs.vertexDegreeWeighted(v, graphType.getDirection(), edgeWeights);
    double centrality = degree / (verticesCount - 1);
    return centrality;
}

Output:
 public Double getVertexScore(Vertex v) {
-    double degree = Graphs.vertexDegreeWeighted(v, graphType.getDirection(), edgeWeights);
+    double degree = Graphs.vertexDegreeWeighted(v, Direction.BOTH, edgeWeights);
     double centrality = degree / (verticesCount - 1);


Input:
private Pod getPodTemplate(KubernetesSlave slave, Label label) {
    final PodTemplate template = getTemplate(label);
    String id = getIdForLabel(label);
    List<EnvVar> env = new ArrayList<EnvVar>(3);
    env.add(new EnvVar("String_Node_Str", slave.getComputer().getJnlpMac(), null));
    env.add(new EnvVar("String_Node_Str", JenkinsLocationConfiguration.get().getUrl(), null));
    String url = StringUtils.isBlank(jenkinsUrl) ? JenkinsLocationConfiguration.get().getUrl() : jenkinsUrl;
    env.add(new EnvVar("String_Node_Str", url, null));
    if (!StringUtils.isBlank(jenkinsTunnel)) {
        env.add(new EnvVar("String_Node_Str", jenkinsTunnel, null));
    }
    url = url.endsWith("String_Node_Str") ? url : url + "String_Node_Str";
    env.add(new EnvVar("String_Node_Str", url + slave.getComputer().getUrl() + "String_Node_Str", null));
    if (template.getEnvVars() != null) {
        for (PodEnvVar podEnvVar : template.getEnvVars()) {
            env.add(new EnvVar(podEnvVar.getKey(), podEnvVar.getValue(), null));
        }
    }
    env.add(new EnvVar("String_Node_Str", template.getRemoteFs(), null));
    List<Volume> volumes = new ArrayList<Volume>();
    List<VolumeMount> volumeMounts = new ArrayList<VolumeMount>();
    {
        int i = 0;
        for (final PodVolumes.PodVolume volume : template.getVolumes()) {
            final String volumeName = "String_Node_Str" + i;
            volumes.add(volume.buildVolume(volumeName));
            volumeMounts.add(new VolumeMount(volume.getMountPath(), volumeName, false));
            i++;
        }
    }
    List<LocalObjectReference> imagePullSecrets = new ArrayList<LocalObjectReference>();
    if (template.getImagePullSecrets() != null) {
        for (PodImagePullSecret podImagePullSecret : template.getImagePullSecrets()) {
            imagePullSecrets.add(new LocalObjectReference(podImagePullSecret.getName()));
        }
    }
    return new PodBuilder().withNewMetadata().withName(slave.getNodeName()).withLabels(getLabelsFor(id)).withAnnotations(getAnnotationsMap(template.getAnnotations())).endMetadata().withNewSpec().withVolumes(volumes).withServiceAccount(template.getServiceAccount()).withImagePullSecrets(imagePullSecrets).addNewContainer().withName(CONTAINER_NAME).withImage(template.getImage()).withImagePullPolicy(template.isAlwaysPullImage() ? "String_Node_Str" : "String_Node_Str").withNewSecurityContext().withPrivileged(template.isPrivileged()).endSecurityContext().withWorkingDir(template.getRemoteFs()).withVolumeMounts(volumeMounts).withEnv(env).withCommand(parseDockerCommand(template.getCommand())).withNewResources().withRequests(getResourcesMap(template.getResourceRequestMemory(), template.getResourceRequestCpu())).withLimits(getResourcesMap(template.getResourceLimitMemory(), template.getResourceLimitCpu())).endResources().addToArgs(slave.getComputer().getJnlpMac()).addToArgs(slave.getComputer().getName()).endContainer().withNodeSelector(getNodeSelectorMap(template.getNodeSelector())).withRestartPolicy("String_Node_Str").endSpec().build();
}

Output:
     env.add(new EnvVar("String_Node_Str", slave.getComputer().getJnlpMac(), null));
-    env.add(new EnvVar("String_Node_Str", JenkinsLocationConfiguration.get().getUrl(), null));
-    String url = StringUtils.isBlank(jenkinsUrl) ? JenkinsLocationConfiguration.get().getUrl() : jenkinsUrl;
+    JenkinsLocationConfiguration locationConfiguration = JenkinsLocationConfiguration.get();
+    String locationConfigurationUrl = locationConfiguration != null ? locationConfiguration.getUrl() : null;
+    env.add(new EnvVar("String_Node_Str", locationConfigurationUrl, null));
+    String url = StringUtils.isBlank(jenkinsUrl) ? locationConfigurationUrl : jenkinsUrl;
     env.add(new EnvVar("String_Node_Str", url, null));


Input:
protected void update(DAnalysis analysis, List<EObject> selectedEObjects) {
    this.activeAnalysis = analysis;
    viewer.setInput(selectedEObjects);
}

Output:
 protected void update(DAnalysis analysis, List<EObject> selectedEObjects) {
-    this.activeAnalysis = analysis;
-    viewer.setInput(selectedEObjects);
+    if (analysis != null) {
+        this.activeAnalysis = analysis;
+        viewer.setInput(selectedEObjects);
+    } else {
+        this.activeAnalysis = null;
+        viewer.setInput(null);
+    }
 }


Input:
public void jailPlayer(CommandSender sender, String[] args) {
    Player player = this.getServer().getPlayer(args[0]);
    args[0] = (player == null) ? args[0].toLowerCase() : player.getName().toLowerCase();
    if (jailed.get(args[0]) != null) {
        sender.sendMessage(ChatColor.RED + "String_Node_Str");
        return;
    }
    if (player != null)
        player.teleport(jailLoc);
    List<String> groupName = this.getGroups(args[0]);
    jailed.set(args[0] + "String_Node_Str", groupName);
    this.setGroup(args[0], jailGroup);
    int minutes = 0;
    if (args.length == 2) {
        minutes = this.parseTimeString(args[1]);
        if (minutes != -1) {
            double tempTime = System.currentTimeMillis() + (minutes * 60000);
            jailed.set(args[0] + "String_Node_Str", tempTime);
        }
    }
    try {
        jailed.save(jailed.getCurrentPath());
    } catch (IOException ex) {
    }
    if (player != null) {
        if (args.length == 1 || minutes == -1)
            player.sendMessage(ChatColor.AQUA + "String_Node_Str");
        else
            player.sendMessage(ChatColor.AQUA + "String_Node_Str" + this.prettifyMinutes(minutes) + "String_Node_Str");
    }
    sender.sendMessage(ChatColor.AQUA + "String_Node_Str");
}

Output:
     }
-    try {
-        jailed.save(jailed.getCurrentPath());
-    } catch (IOException ex) {
-    }
+    this.saveJail();
     if (player != null) {


Input:
public Tuple exec(Tuple input) throws IOException {
    if (input == null || input.size() == 0) {
        return null;
    }
    int size = input.size();
    JexlContext jc = new MapContext();
    Tuple tuple = TupleFactory.getInstance().newTuple();
    String tag = input.get(tagColumnNum).toString();
    if (!(posTags.contains(tag) || negTags.contains(tag))) {
        if (System.currentTimeMillis() % 100 == 0) {
            log.warn("String_Node_Str" + tag);
        }
        return null;
    }
    boolean isNotSampled = DataSampler.isNotSampled(modelConfig.getPosTags(), modelConfig.getNegTags(), modelConfig.getNormalizeSampleRate(), modelConfig.isNormalizeSampleNegOnly(), tag);
    if (isNotSampled) {
        return null;
    }
    Double cutoff = modelConfig.getNormalizeStdDevCutOff();
    for (int i = 0; i < size; i++) {
        ColumnConfig config = columnConfigList.get(i);
        if (weightExpr != null) {
            jc.set(config.getColumnName(), ((input.get(i) == null) ? "String_Node_Str" : input.get(i).toString()));
        }
        if (super.tagColumnNum == i) {
            if (modelConfig.getPosTags().contains(tag)) {
                tuple.append(df.format(Double.valueOf(1)));
            } else if (modelConfig.getNegTags().contains(tag)) {
                tuple.append(df.format(Double.valueOf(0)));
            } else {
                log.error("String_Node_Str" + tag);
                return null;
            }
            continue;
        }
        if (!CommonUtils.isGoodCandidate(config)) {
            tuple.append(null);
        } else {
            String val = ((input.get(i) == null) ? "String_Node_Str" : input.get(i).toString());
            switch(super.modelConfig.getNormalize().getNormType()) {
                case WOE:
                    List<Double> binWoe;
                    if (super.modelConfig.getNormalize().getIsWeightNorm()) {
                        binWoe = config.getColumnBinning().getBinWeightedWoe();
                    } else {
                        binWoe = config.getColumnBinning().getBinCountWoe();
                    }
                    if (StringUtils.isEmpty(val)) {
                        tuple.append(binWoe.get(binWoe.size() - 1));
                    } else {
                        try {
                            int binNum = CommonUtils.getBinNum(config, val);
                            binNum = binNum == -1 ? binWoe.size() - 1 : binNum;
                            tuple.append(binWoe.get(binNum));
                        } catch (NumberFormatException e) {
                            tuple.append(binWoe.get(binWoe.size() - 1));
                        }
                    }
                    break;
                case ZSCALE:
                    Double z = Normalizer.normalize(config, val, cutoff);
                    tuple.append(df.format(z));
                default:
                    break;
            }
        }
    }
    double weight = 1.0d;
    if (weightExpr != null) {
        Object result = weightExpr.evaluate(jc);
        if (result instanceof Integer) {
            weight = ((Integer) result).doubleValue();
        } else if (result instanceof Double) {
            weight = ((Double) result).doubleValue();
        } else if (result instanceof String) {
            try {
                weight = Double.parseDouble((String) result);
            } catch (NumberFormatException e) {
                if (System.currentTimeMillis() % 100 == 0) {
                    log.warn("String_Node_Str" + result + "String_Node_Str");
                }
                weight = 1.0d;
            }
        }
    }
    tuple.append(weight);
    return tuple;
}

Output:
                     if (StringUtils.isEmpty(val)) {
-                        tuple.append(binWoe.get(binWoe.size() - 1));
+                        tuple.append(df.format(binWoe.get(binWoe.size() - 1)));
                     } else {


Input:
public synchronized V get(long h, K key, V value) {
    int hash = intHashFor(h);
    smallMap.startSearch(hash);
    while (true) {
        int pos = smallMap.nextInt();
        if (pos == IntIntMultiMap.UNSET) {
            final DirectStore store = map.get(key);
            if (store == null)
                return null;
            bytes.storePositionAndSize(store, 0, store.size());
            break;
        } else {
            bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize);
            K key2 = getKey();
            if (equals(key, key2))
                break;
        }
    }
    if (bytesMarshallable) {
        try {
            V v = value == null ? (V) NativeBytes.UNSAFE.allocateInstance(vClass) : value;
            ((BytesMarshallable) v).readMarshallable(bytes);
            return v;
        } catch (InstantiationException e) {
            throw new AssertionError(e);
        }
    }
    return (V) bytes.readObject();
}

Output:
         if (pos == IntIntMultiMap.UNSET) {
-            final DirectStore store = map.get(key);
+            Object key2 = key instanceof CharSequence ? key.toString() : key;
+            final DirectStore store = map.get(key2);
             if (store == null)


Input:
public Object evaluate(String property, PropertyHelper propertyHelper) {
    Stack stk = (Stack) getStack.get();
    if (stk.contains(property)) {
        return null;
    }
    stk.push(property);
    try {
        if (propertyHelper.getProperty(property) != null) {
            return null;
        }
    } finally {
        stk.pop();
    }
    Object value = map.get(property);
    if (!(value instanceof String)) {
        return null;
    }
    stk = (Stack) replaceStack.get();
    if (stk.contains(property)) {
        throw new BuildException("String_Node_Str" + name + "String_Node_Str");
    }
    stk.push(property);
    try {
        return propertyHelper.replaceProperties((String) value);
    } finally {
        stk.pop();
    }
}

Output:
     if (stk.contains(property)) {
-        throw new BuildException("String_Node_Str" + name + "String_Node_Str");
+        throw new BuildException("String_Node_Str" + property + "String_Node_Str");
     }


Input:
public boolean checkTrigger(GameEvent event, Game game) {
    if (event.getType() == EventType.ZONE_CHANGE) {
        UUID targetId = event.getTargetId();
        Permanent permanent = game.getPermanent(targetId);
        ZoneChangeEvent zEvent = (ZoneChangeEvent) event;
        if (zEvent.getToZone() == Zone.BATTLEFIELD && permanent.getControllerId().equals(this.controllerId) && (targetId.equals(this.getSourceId()) || (permanent.hasSubtype("String_Node_Str") && !targetId.equals(this.getSourceId())))) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean checkTrigger(GameEvent event, Game game) {
-    if (event.getType() == EventType.ZONE_CHANGE) {
+    if (event.getType() == EventType.ENTERS_THE_BATTLEFIELD) {
         UUID targetId = event.getTargetId();


Input:
public Map<Var, Type> deriveTypeConstraints(RdfView view) {
    Map<Var, Type> result = new HashMap<Var, Type>();
    for (Entry<Node, Expr> entry : view.getBinding().entrySet()) {
        Var var = (Var) entry.getKey();
        ExprFunction termCtor = (ExprFunction) entry.getValue();
        String functionIri = termCtor.getFunctionSymbol().getSymbol();
        if (functionIri.equals(SparqlifyConstants.rdfTermLabel)) {
            Expr arg = termCtor.getArg(1);
            if (arg.isConstant()) {
                Object o = PushDown.getValue(arg.getConstant());
                Number number = (Number) o;
                switch(number.intValue()) {
                    case 1:
                        result.put(var, Type.URI);
                        break;
                    case 2:
                    case 3:
                        result.put(var, Type.LITERAL);
                        break;
                }
            }
        } else if (functionIri.equals(SparqlifyConstants.uriLabel)) {
            result.put(var, Type.URI);
        } else if (functionIri.equals(SparqlifyConstants.plainLiteralLabel) || functionIri.equals(SparqlifyConstants.typedLiteralLabel)) {
            result.put(var, Type.LITERAL);
        }
    }
    return result;
}

Output:
             if (arg.isConstant()) {
-                Object o = PushDown.getValue(arg.getConstant());
+                Object o = NodeValueUtils.getValue(arg.getConstant());
                 Number number = (Number) o;


Input:
protected RealMatrix bootstrapMatrix(RealMatrix mat) {
    double[][] bootstrap;
    if (mat.getRowDimension() < mat.getColumnDimension()) {
        if (mat.getRowDimension() < 3) {
            bootstrap = null;
        } else {
            int Nboot;
            if (mat.getRowDimension() < 100) {
                Nboot = 100;
            } else {
                Nboot = mat.getColumnDimension();
            }
            bootstrap = new double[Nboot][mat.getColumnDimension()];
            int R;
            RandomData rand = new RandomDataImpl();
            for (int c = 0; c < mat.getColumnDimension(); ++c) {
                for (int r = 0; r < bootstrap.length; ++r) {
                    R = rand.nextInt(0, mat.getRowDimension() - 1);
                    bootstrap[r][c] = mat.getEntry(R, c);
                }
            }
        }
    } else {
        bootstrap = mat.getData();
    }
    return new Array2DRowRealMatrix(bootstrap);
}

Output:
     double[][] bootstrap;
-    if (mat.getRowDimension() < mat.getColumnDimension()) {
-        if (mat.getRowDimension() < 3) {
-            bootstrap = null;
+    if ((mat.getRowDimension() < mat.getColumnDimension()) && (mat.getRowDimension() >= 3)) {
+        int Nboot;
+        if (mat.getRowDimension() < 100) {
+            Nboot = 100;
         } else {


Input:
private void switchToNextSegment() {
    segmentPositions.clear();
    segmentIndex--;
    if (segmentIndex >= 0) {
        segments[segmentIndex].visit(this);
    }
}

Output:
     if (segmentIndex >= 0) {
-        segments[segmentIndex].visit(this);
+        final Segment segment = segments[segmentIndex];
+        segment.lock();
+        try {
+            segments[segmentIndex].visit(this);
+        } finally {
+            segment.unlock();
+        }
     }


Input:
public String getShortName(long instant, Locale locale) {
    if (locale == null) {
        locale = Locale.getDefault();
    }
    String nameKey = getNameKey(instant);
    if (nameKey == null) {
        return iID;
    }
    String name = cNameProvider.getShortName(locale, iID, nameKey);
    if (name != null) {
        return name;
    }
    return printTimeZone(getOffset(instant));
}

Output:
     }
-    return printTimeZone(getOffset(instant));
+    return printOffset(getOffset(instant));
 }


Input:
public void update(Token token) throws CoreTokenException {
    try {
        strategy.perfom(token);
    } catch (TokenStrategyFailedException e) {
        throw new CoreTokenException("String_Node_Str", e);
    }
    getAdapter().update(token);
    if (DEBUG.messageEnabled()) {
        DEBUG.message(MessageFormat.format(CoreTokenConstants.DEBUG_HEADER + "String_Node_Str", token.getTokenId()));
    }
}

Output:
     }
-    getAdapter().update(token);
+    adapter.updateOrCreate(token);
     if (DEBUG.messageEnabled()) {


Input:
public JsonValue mapToJsonValue(ResultSet rs, Set<String> columnNames) throws SQLException, InternalServerErrorException {
    JsonValue mappedResult = new JsonValue(new LinkedHashMap<String, Object>());
    for (ColumnMapping entry : columnMappings) {
        Object value = null;
        if (columnNames.contains(entry.dbColName)) {
            if (ColumnMapping.TYPE_STRING.equals(entry.dbColType)) {
                value = rs.getString(entry.dbColName);
                if (cryptoServiceAccessor == null || cryptoServiceAccessor.access() == null) {
                    throw new InternalServerErrorException("String_Node_Str");
                }
                if (JsonUtil.isEncrypted((String) value)) {
                    value = convertToJson(entry.dbColName, "String_Node_Str", (String) value, Map.class).asMap();
                }
            } else if (ColumnMapping.TYPE_JSON_MAP.equals(entry.dbColType)) {
                value = convertToJson(entry.dbColName, entry.dbColType, rs.getString(entry.dbColName), Map.class).asMap();
            } else if (ColumnMapping.TYPE_JSON_LIST.equals(entry.dbColType)) {
                value = convertToJson(entry.dbColName, entry.dbColType, rs.getString(entry.dbColName), List.class).asList();
            } else {
                throw new InternalServerErrorException("String_Node_Str" + entry.dbColType);
            }
            mappedResult.put(entry.objectColPointer, value);
        }
    }
    logger.debug("String_Node_Str", rs, mappedResult);
    return mappedResult;
}

Output:
             }
-            mappedResult.put(entry.objectColPointer, value);
+            mappedResult.putPermissive(entry.objectColPointer, value);
         }


Input:
public static void main(final String[] args) throws IOException, SQLException {
    CoordinatorRegistryCenter regCenter = setUpRegistryCenter();
    DataSource dataSource = OrchestrationMasterSlaveDataSourceFactory.createDataSource(createDataSourceMap(), crateMasterSlaveRuleConfig(), new OrchestrationConfiguration("String_Node_Str", regCenter, false));
    createTable(dataSource);
    insertData(dataSource);
    printSimpleSelect(dataSource);
    System.out.println("String_Node_Str");
    printGroupBy(dataSource);
    System.out.println("String_Node_Str");
    printHintSimpleSelect(dataSource);
    dropTable(dataSource);
}

Output:
     CoordinatorRegistryCenter regCenter = setUpRegistryCenter();
-    DataSource dataSource = OrchestrationMasterSlaveDataSourceFactory.createDataSource(createDataSourceMap(), crateMasterSlaveRuleConfig(), new OrchestrationConfiguration("String_Node_Str", regCenter, false));
+    DataSource dataSource = OrchestrationMasterSlaveDataSourceFactory.createDataSource(createDataSourceMap(), crateMasterSlaveRuleConfig(), new OrchestrationConfiguration("String_Node_Str", regCenter, false), new HashMap<String, Object>());
     createTable(dataSource);


Input:
public boolean marshalAttributes(MarshalRecord marshalRecord, Object object, AbstractSession session) {
    boolean hasValue = false;
    XPathNode attributeNode;
    NamespaceResolver namespaceResolver;
    if (rootXPathNode.getAttributeChildren() != null) {
        int size = rootXPathNode.getAttributeChildren().size();
        for (int x = 0; x < size; x++) {
            attributeNode = (XPathNode) rootXPathNode.getAttributeChildren().get(x);
            namespaceResolver = ((XMLDescriptor) this.getDescriptor()).getNamespaceResolver();
            hasValue = attributeNode.marshal(marshalRecord, object, session, namespaceResolver, ObjectMarshalContext.getInstance()) || hasValue;
        }
    }
    if (rootXPathNode.getAnyAttributeNode() != null) {
        namespaceResolver = ((XMLDescriptor) this.getDescriptor()).getNamespaceResolver();
        hasValue = rootXPathNode.getAnyAttributeNode().marshal(marshalRecord, object, session, namespaceResolver, ObjectMarshalContext.getInstance()) || hasValue;
    }
    if (rootXPathNode.getSelfChildren() != null) {
        XPathNode childNode;
        for (int x = 0; x < rootXPathNode.getSelfChildren().size(); x++) {
            childNode = (XPathNode) rootXPathNode.getSelfChildren().get(x);
            namespaceResolver = ((XMLDescriptor) this.getDescriptor()).getNamespaceResolver();
            childNode.marshalSelfAttributes(marshalRecord, object, session, namespaceResolver, marshalRecord.getMarshaller());
        }
    }
    return hasValue;
}

Output:
     boolean hasValue = false;
-    XPathNode attributeNode;
-    NamespaceResolver namespaceResolver;
-    if (rootXPathNode.getAttributeChildren() != null) {
-        int size = rootXPathNode.getAttributeChildren().size();
-        for (int x = 0; x < size; x++) {
-            attributeNode = (XPathNode) rootXPathNode.getAttributeChildren().get(x);
-            namespaceResolver = ((XMLDescriptor) this.getDescriptor()).getNamespaceResolver();
+    NamespaceResolver namespaceResolver = ((XMLDescriptor) this.getDescriptor()).getNamespaceResolver();
+    List attributeChildren = rootXPathNode.getAttributeChildren();
+    if (null != attributeChildren) {
+        for (int x = 0, attributeChildrenSize = attributeChildren.size(); x < attributeChildrenSize; x++) {
+            XPathNode attributeNode = (XPathNode) rootXPathNode.getAttributeChildren().get(x);
             hasValue = attributeNode.marshal(marshalRecord, object, session, namespaceResolver, ObjectMarshalContext.getInstance()) || hasValue;


Input:
public void highlightError(long startPosition, long endPosition) {
    mCodeEditor.highlightError(startPosition, endPosition);
}

Output:
 public void highlightError(long startPosition, long endPosition) {
-    mCodeEditor.highlightError(startPosition, endPosition);
+    if (mCodeEditor != null) {
+        mCodeEditor.highlightError(startPosition, endPosition);
+    }
 }


Input:
public void CRAMNoIndexTest(final String inputFile) {
    final File input = new File(TEST_DATA_DIR, inputFile);
    final SamReader reader = SamReaderFactory.makeDefault().open(input);
    Assert.assertFalse(reader.hasIndex());
    CloserUtil.close(reader);
}

Output:
     final File input = new File(TEST_DATA_DIR, inputFile);
-    final SamReader reader = SamReaderFactory.makeDefault().open(input);
+    final File reference = new File(TEST_DATA_DIR, referenceFile);
+    final SamReader reader = SamReaderFactory.makeDefault().referenceSequence(reference).open(input);
     Assert.assertFalse(reader.hasIndex());


Input:
public CharSequence optionTok() {
    while (hasNext()) {
        CharSequence cs = next();
        if (!Chars.equals(cs, ' ')) {
            return cs;
        }
    }
    return null;
}

Output:
         CharSequence cs = next();
-        if (!Chars.equals(cs, ' ')) {
+        if (!whitespace.contains(cs)) {
             return cs;


Input:
public void load(String url) {
    removeParent();
    if (url == null || url.equals("String_Node_Str")) {
    } else if (url.startsWith("String_Node_Str")) {
        try {
            URI uri = new URI(url);
            File file = new File(uri);
            loadFile(file);
        } catch (Exception e) {
            handleExceptionMessage(e);
        }
    } else {
        loadWeb(url);
    }
}

Output:
     if (url == null || url.equals("String_Node_Str")) {
-    } else if (url.startsWith("String_Node_Str")) {
+        handleMessage("String_Node_Str");
+        return;
+    }
+    removeParent();
+    if (url.startsWith("String_Node_Str")) {
         try {