Input:
public void check(MarkerList markers, IContext context) {
    if (this.receiver != null) {
        this.receiver.check(markers, context);
    }
    if (this.method != null) {
        IType receiverType = this.receiver.getType();
        IType methodReturnType = super.getType();
        if (!receiverType.isSuperTypeOf(methodReturnType)) {
            Marker marker = I18n.createMarker(this.position, "String_Node_Str", this.name, this.receiver.toString());
            marker.addInfo(I18n.getString("String_Node_Str", receiverType));
            marker.addInfo(I18n.getString("String_Node_Str", methodReturnType));
            markers.add(marker);
        }
        this.method.checkCall(markers, this.position, context, this.receiver, this.arguments, this.getGenericData());
    }
    this.arguments.check(markers, context);
}

Output:
     if (this.method != null) {
-        IType receiverType = this.receiver.getType();
-        IType methodReturnType = super.getType();
-        if (!receiverType.isSuperTypeOf(methodReturnType)) {
-            Marker marker = I18n.createMarker(this.position, "String_Node_Str", this.name, this.receiver.toString());
-            marker.addInfo(I18n.getString("String_Node_Str", receiverType));
-            marker.addInfo(I18n.getString("String_Node_Str", methodReturnType));
-            markers.add(marker);
+        if (this.receiver != null) {
+            IType receiverType = this.receiver.getType();
+            IType methodReturnType = this.method.getType();
+            if (!receiverType.isSuperTypeOf(methodReturnType)) {
+                Marker marker = I18n.createMarker(this.position, "String_Node_Str", this.name, this.receiver.toString());
+                marker.addInfo(I18n.getString("String_Node_Str", receiverType));
+                marker.addInfo(I18n.getString("String_Node_Str", methodReturnType));
+                markers.add(marker);
+            }
         }


Input:
protected void setOrAddAttributeValue(UnmarshalRecord unmarshalRecord, Object value, XPathFragment xPathFragment, Object collection) {
    if (!xmlAnyObjectMapping.usesXMLRoot()) {
        unmarshalRecord.setAttributeValue(value, xmlAnyObjectMapping);
    } else {
        XMLRoot xmlRoot = new XMLRoot();
        xmlRoot.setNamespaceURI(xPathFragment.getNamespaceURI());
        xmlRoot.setSchemaType(unmarshalRecord.getTypeQName());
        xmlRoot.setLocalName(xPathFragment.getLocalName());
        xmlRoot.setObject(value);
        unmarshalRecord.setAttributeValue(xmlRoot, xmlAnyObjectMapping);
    }
}

Output:
     } else {
-        XMLRoot xmlRoot = new XMLRoot();
+        Root xmlRoot = new XMLRoot();
         xmlRoot.setNamespaceURI(xPathFragment.getNamespaceURI());


Input:
protected void addItemReference(Component modelOwner, final Component comp, int index, String varnm) {
    if (comp.getDefinition().isNative()) {
        for (Component child : comp.getChildren()) {
            addItemReference(modelOwner, child, index, varnm);
        }
    } else {
        final Binder binder = BinderUtil.getBinder(comp, true);
        if (binder == null)
            return;
        final String expression;
        if (comp.getAttribute(IS_TEMPLATE_MODEL_ENABLED_ATTR) != null) {
            expression = BindELContext.getModelName(modelOwner) + "String_Node_Str" + CURRENT_INDEX_RESOLVER_ATTR + "String_Node_Str";
        } else {
            expression = BindELContext.getModelName(modelOwner) + "String_Node_Str" + index + "String_Node_Str";
        }
        comp.setAttribute(varnm, new ReferenceBindingImpl(binder, comp, varnm, expression));
    }
}

Output:
         if (comp.getAttribute(IS_TEMPLATE_MODEL_ENABLED_ATTR) != null) {
-            expression = BindELContext.getModelName(modelOwner) + "String_Node_Str" + CURRENT_INDEX_RESOLVER_ATTR + "String_Node_Str";
+            expression = BindELContext.getModelName(modelOwner) + "String_Node_Str" + CURRENT_INDEX_RESOLVER_ATTR + "String_Node_Str" + index + "String_Node_Str";
         } else {


Input:
public byte[] toBinary() {
    return new byte[] {};
}

Output:
 public byte[] toBinary() {
-    return new byte[] {};
+    return new byte[] { (byte) (((min > -180) && (max < 180)) ? 0 : 1) };
 }


Input:
protected void onDraw(Canvas canvas) {
    if (!mBlocked && (mFaces != null) && (mFaces.length > 0)) {
        int rw, rh;
        rw = mUncroppedWidth;
        rh = mUncroppedHeight;
        if (((rh > rw) && ((mDisplayOrientation == 0) || (mDisplayOrientation == 180))) || ((rw > rh) && ((mDisplayOrientation == 90) || (mDisplayOrientation == 270)))) {
            int temp = rw;
            rw = rh;
            rh = temp;
        }
        CameraUtil.prepareMatrix(mMatrix, mMirror, mDisplayOrientation, rw, rh);
        int dx = (getWidth() - rw) / 2;
        int dy = (getHeight() - rh) / 2;
        canvas.save();
        mMatrix.postRotate(mOrientation);
        canvas.rotate(-mOrientation);
        for (int i = 0; i < mFaces.length; i++) {
            if (mFaces[i].score < 50)
                continue;
            mRect.set(mFaces[i].rect);
            if (LOGV)
                CameraUtil.dumpRect(mRect, "String_Node_Str");
            mMatrix.mapRect(mRect);
            if (LOGV)
                CameraUtil.dumpRect(mRect, "String_Node_Str");
            mPaint.setColor(mColor);
            mRect.offset(dx, dy);
            canvas.drawOval(mRect, mPaint);
            if (mFaces[i] instanceof ExtendedFace) {
                ExtendedFace face = (ExtendedFace) mFaces[i];
                float[] point = new float[4];
                int delta_x = mFaces[i].rect.width() / 12;
                int delta_y = mFaces[i].rect.height() / 12;
                Log.e(TAG, "String_Node_Str" + face.getLeftEyeBlinkDegree() + "String_Node_Str" + face.getRightEyeBlinkDegree() + "String_Node_Str");
                if (face.leftEye != null) {
                    point[0] = face.leftEye.x + dx;
                    point[1] = face.leftEye.y - delta_y / 2;
                    point[2] = face.leftEye.x;
                    point[3] = face.leftEye.y + delta_y / 2;
                    mMatrix.mapPoints(point);
                    if (face.getLeftEyeBlinkDegree() >= blink_threshold) {
                        canvas.drawLine(point[0] + dx, point[1] + dy, point[2] + dx, point[3] + dy, mPaint);
                    }
                }
                if (face.rightEye != null) {
                    point[0] = face.rightEye.x;
                    point[1] = face.rightEye.y - delta_y / 2;
                    point[2] = face.rightEye.x;
                    point[3] = face.rightEye.y + delta_y / 2;
                    mMatrix.mapPoints(point);
                    if (face.getRightEyeBlinkDegree() >= blink_threshold) {
                        canvas.drawLine(point[0] + dx, point[1] + dy, point[2] + dx, point[3] + dy, mPaint);
                    }
                }
                if (face.getLeftRightGazeDegree() != 0 || face.getTopBottomGazeDegree() != 0) {
                    double length = Math.sqrt((face.leftEye.x - face.rightEye.x) * (face.leftEye.x - face.rightEye.x) + (face.leftEye.y - face.rightEye.y) * (face.leftEye.y - face.rightEye.y)) / 2.0;
                    double nGazeYaw = -face.getLeftRightGazeDegree();
                    double nGazePitch = -face.getTopBottomGazeDegree();
                    float gazeRollX = (float) ((-Math.sin(nGazeYaw / 180.0 * Math.PI) * Math.cos(-face.getRollDirection() / 180.0 * Math.PI) + Math.sin(nGazePitch / 180.0 * Math.PI) * Math.cos(nGazeYaw / 180.0 * Math.PI) * Math.sin(-face.getRollDirection() / 180.0 * Math.PI)) * (-length) + 0.5);
                    float gazeRollY = (float) ((Math.sin(-nGazeYaw / 180.0 * Math.PI) * Math.sin(-face.getRollDirection() / 180.0 * Math.PI) - Math.sin(nGazePitch / 180.0 * Math.PI) * Math.cos(nGazeYaw / 180.0 * Math.PI) * Math.cos(-face.getRollDirection() / 180.0 * Math.PI)) * (-length) + 0.5);
                    if (face.getLeftEyeBlinkDegree() < blink_threshold) {
                        point[0] = face.leftEye.x;
                        point[1] = face.leftEye.y;
                        point[2] = face.leftEye.x + gazeRollX;
                        point[3] = face.leftEye.y + gazeRollY;
                        mMatrix.mapPoints(point);
                        canvas.drawLine(point[0] + dx, point[1] + dy, point[2] + dx, point[3] + dy, mPaint);
                    }
                    if (face.getRightEyeBlinkDegree() < blink_threshold) {
                        point[0] = face.rightEye.x;
                        point[1] = face.rightEye.y;
                        point[2] = face.rightEye.x + gazeRollX;
                        point[3] = face.rightEye.y + gazeRollY;
                        mMatrix.mapPoints(point);
                        canvas.drawLine(point[0] + dx, point[1] + dy, point[2] + dx, point[3] + dy, mPaint);
                    }
                }
                if (face.mouth != null) {
                    Log.e(TAG, "String_Node_Str" + face.getSmileDegree() + "String_Node_Str" + face.getSmileScore());
                    if (face.getSmileDegree() < smile_threashold_no_smile) {
                        if ((mDisplayOrientation == 90) || (mDisplayOrientation == 270)) {
                            point[0] = face.mouth.x;
                            point[1] = face.mouth.y - delta_y + dy;
                            point[2] = face.mouth.x;
                            point[3] = face.mouth.y + delta_y + dy;
                        } else {
                            point[0] = face.mouth.x + dx - delta_x;
                            point[1] = face.mouth.y;
                            point[2] = face.mouth.x + dx + delta_x;
                            point[3] = face.mouth.y;
                        }
                        mMatrix.mapPoints(point);
                        canvas.drawLine(point[0] + dx, point[1] + dy, point[2] + dx, point[3] + dy, mPaint);
                    } else if (face.getSmileDegree() < smile_threashold_small_smile) {
                        mRect.set(face.mouth.x - delta_x, face.mouth.y - delta_y, face.mouth.x + delta_x, face.mouth.y + delta_y);
                        mMatrix.mapRect(mRect);
                        mRect.offset(dx, dy);
                        canvas.drawArc(mRect, 0, 180, true, mPaint);
                    } else {
                        mRect.set(face.mouth.x - delta_x, face.mouth.y - delta_y, face.mouth.x + delta_x, face.mouth.y + delta_y);
                        mMatrix.mapRect(mRect);
                        mRect.offset(dx, dy);
                        canvas.drawOval(mRect, mPaint);
                    }
                }
            }
        }
        canvas.restore();
    }
    super.onDraw(canvas);
}

Output:
                 if (face.leftEye != null) {
-                    point[0] = face.leftEye.x + dx;
+                    point[0] = face.leftEye.x;
                     point[1] = face.leftEye.y - delta_y / 2;


Input:
private void updateMidnightMillis(final long now) {
    updateCachedDate(now);
    midnightToday = calcMidnightMillis(0);
    midnightTomorrow = calcMidnightMillis(1);
}

Output:
     updateCachedDate(now);
-    midnightToday = calcMidnightMillis(0);
-    midnightTomorrow = calcMidnightMillis(1);
+    midnightToday = calcMidnightMillis(now, 0);
+    midnightTomorrow = calcMidnightMillis(now, 1);
 }


Input:
protected void initXMLEntityMappings() {
    xmlEntityMappings = new ArrayList<XMLEntityMappings>();
    addXMLEntityMappings("String_Node_Str");
    for (String mappingFile : persistenceUnitInfo.getMappingFileNames()) {
        if (!mappingFile.equals("String_Node_Str")) {
            addXMLEntityMappings(mappingFile);
        }
    }
    for (XMLEntityMappings entityMappings : xmlEntityMappings) {
        entityMappings.setLoader(factory.getLoader());
        entityMappings.setProject(project);
        entityMappings.setMetadataFactory(factory);
        entityMappings.processPersistenceUnitMetadata();
    }
    HashMap<String, EntityAccessor> entities = new HashMap<String, EntityAccessor>();
    HashMap<String, EmbeddableAccessor> embeddables = new HashMap<String, EmbeddableAccessor>();
    for (XMLEntityMappings entityMappings : xmlEntityMappings) {
        entityMappings.initPersistenceUnitClasses(entities, embeddables);
    }
    for (EntityAccessor entity : entities.values()) {
        project.addEntityAccessor(entity);
        entity.getEntityMappings().processEntityMappingsDefaults(entity);
    }
    for (EmbeddableAccessor embeddable : embeddables.values()) {
        addEmbeddableAccessor(embeddable);
        embeddable.getEntityMappings().processEntityMappingsDefaults(embeddable);
    }
}

Output:
     xmlEntityMappings = new ArrayList<XMLEntityMappings>();
-    addXMLEntityMappings("String_Node_Str");
+    addXMLEntityMappings(MetadataHelper.JPA_ORM_FILE);
+    Boolean excludeEclipseLinkORM = false;
+    if (persistenceUnitProperties.containsKey(PersistenceUnitProperties.EXCLUDE_ECLIPSELINK_ORM_FILE)) {
+        excludeEclipseLinkORM = new Boolean((String) persistenceUnitProperties.get(PersistenceUnitProperties.EXCLUDE_ECLIPSELINK_ORM_FILE));
+    }
+    if (!excludeEclipseLinkORM) {
+        addXMLEntityMappings(MetadataHelper.ECLIPSELINK_ORM_FILE);
+    }
     for (String mappingFile : persistenceUnitInfo.getMappingFileNames()) {


Input:
protected void copy(boolean leftToRight) {
    EList<Diff> differences = getComparison().getDifferences();
    final Command copyCommand = getEditingDomain().createCopyAllNonConflictingCommand(differences, leftToRight);
    getEditingDomain().getCommandStack().execute(copyCommand);
    if (leftToRight) {
        setRightDirty(true);
    } else {
        setLeftDirty(true);
    }
    refresh();
}

Output:
     EList<Diff> differences = getComparison().getDifferences();
-    final Command copyCommand = getEditingDomain().createCopyAllNonConflictingCommand(differences, leftToRight);
+    final Command copyCommand = getEditingDomain().createCopyAllNonConflictingCommand(differences, leftToRight, EMFCompareIDEPlugin.getDefault().getMergerRegistry());
     getEditingDomain().getCommandStack().execute(copyCommand);


Input:
public void actionPerformed(ActionEvent e) {
    Object o = e.getSource();
    if (o == kettleTxt) {
        double x = SBStringUtils.round(myRecipe.getKettleLoss(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(kettleTxt.getText()), 2);
        if (x != y) {
            myRecipe.setKettleLoss(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(kettleTxt.getText())));
        }
    } else if (o == miscLossTxt) {
        double x = SBStringUtils.round(myRecipe.getMiscLoss(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(miscLossTxt.getText()), 2);
        if (x != y) {
            myRecipe.setKettleLoss(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(miscLossTxt.getText())));
        }
    } else if (o == trubLossTxt) {
        double x = SBStringUtils.round(myRecipe.getTrubLoss(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(trubLossTxt.getText()), 2);
        if (x != y) {
            myRecipe.setTrubLoss(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(trubLossTxt.getText())));
        }
    } else if (o == collectTxt) {
        double x = SBStringUtils.round(myRecipe.getPreBoilVol(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(collectTxt.getText()), 2);
        if (x != y) {
            myRecipe.setPreBoil(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(collectTxt.getText())));
        }
    } else if (o == postBoilTxt) {
        double x = SBStringUtils.round(myRecipe.getPostBoilVol(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(postBoilTxt.getText()), 2);
        if (x != y) {
            myRecipe.setPostBoil(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(postBoilTxt.getText())));
        }
    } else if (o == finalVolTxt) {
        double x = SBStringUtils.round(myRecipe.getFinalWortVol(myRecipe.getVolUnits()), 2);
        double y = SBStringUtils.round(Double.parseDouble(finalVolTxt.getText()), 2);
        if (x != y) {
            myRecipe.setFinalWortVol(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(finalVolTxt.getText())));
        }
    }
    displayWater();
}

Output:
         if (x != y) {
-            myRecipe.setKettleLoss(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(miscLossTxt.getText())));
+            myRecipe.setMiscLoss(new Quantity(myRecipe.getVolUnits(), Double.parseDouble(miscLossTxt.getText())));
         }


Input:
public ResolvedModuleRevision getDependency(DependencyDescriptor dd, ResolveData data) throws ParseException {
    clearIvyAttempts();
    boolean downloaded = false;
    boolean searched = false;
    Date cachedPublicationDate = null;
    ModuleRevisionId mrid = dd.getDependencyRevisionId();
    int index = mrid.getRevision().indexOf("String_Node_Str");
    if (index != -1 && !mrid.getRevision().substring(index + 1).equals(_workspaceName)) {
        Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + mrid.getRevision());
        return null;
    }
    if (!mrid.isExactRevision() && !acceptLatest()) {
        Message.error("String_Node_Str" + getClass().getName() + "String_Node_Str" + mrid);
        return null;
    }
    if (mrid.isExactRevision() && !isCheckmodified() && !dd.isChanging()) {
        ResolvedModuleRevision rmr = data.getIvy().findModuleInCache(mrid, data.getCache(), doValidate(data));
        if (rmr != null) {
            Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + mrid);
            return rmr;
        }
    }
    URL cachedIvyURL = null;
    ResolvedResource ivyRef = findIvyFileRef(dd, data);
    searched = true;
    ModuleDescriptorParser parser;
    ModuleDescriptor md;
    if (ivyRef == null) {
        parser = XmlModuleDescriptorParser.getInstance();
        md = DefaultModuleDescriptor.newDefaultInstance(mrid, dd.getAllDependencyArtifactsIncludes());
        ResolvedResource artifactRef = findFirstArtifactRef(md, dd, data);
        if (artifactRef == null) {
            Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + mrid);
            logIvyNotFound(mrid);
            String[] conf = md.getConfigurationsNames();
            for (int i = 0; i < conf.length; i++) {
                Artifact[] artifacts = md.getArtifacts(conf[i]);
                for (int j = 0; j < artifacts.length; j++) {
                    logArtifactNotFound(artifacts[j]);
                }
            }
            return null;
        } else {
            Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + mrid + "String_Node_Str");
            logIvyNotFound(mrid);
            if (!mrid.isExactRevision()) {
                md.setResolvedModuleRevisionId(new ModuleRevisionId(mrid.getModuleId(), artifactRef.getRevision()));
            }
        }
    } else {
        parser = ModuleDescriptorParserRegistry.getInstance().getParser(ivyRef.getResource());
        if (parser == null) {
            Message.warn("String_Node_Str" + ivyRef.getResource());
            return null;
        }
        Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + mrid);
        Message.verbose("String_Node_Str" + ivyRef);
        Message.debug("String_Node_Str" + parser);
        ModuleRevisionId resolvedMrid = mrid;
        if (!mrid.isExactRevision() && ModuleRevisionId.isExactRevision(ivyRef.getRevision())) {
            resolvedMrid = new ModuleRevisionId(mrid.getModuleId(), ivyRef.getRevision());
            IvyNode node = data.getNode(resolvedMrid);
            if (node != null && node.getModuleRevision() != null) {
                Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + resolvedMrid);
                return searchedRmr(node.getModuleRevision());
            }
        }
        ResolvedModuleRevision rmr = data.getIvy().findModuleInCache(resolvedMrid, data.getCache(), doValidate(data));
        if (rmr != null) {
            if (!isCheckmodified() && !dd.isChanging()) {
                Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + resolvedMrid);
                return searchedRmr(rmr);
            }
            long repLastModified = ivyRef.getLastModified();
            long cacheLastModified = rmr.getDescriptor().getLastModified();
            if (!rmr.getDescriptor().isDefault() && repLastModified <= cacheLastModified) {
                Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + resolvedMrid);
                return searchedRmr(rmr);
            } else {
                Message.verbose("String_Node_Str" + getName() + "String_Node_Str" + resolvedMrid);
                if (dd.isChanging()) {
                    cachedPublicationDate = rmr.getDescriptor().getResolvedPublicationDate();
                }
            }
        }
        try {
            if (ResourceHelper.equals(ivyRef.getResource(), data.getIvy().getIvyFileInCache(data.getCache(), resolvedMrid))) {
                Message.error("String_Node_Str" + getName() + "String_Node_Str");
                return null;
            }
            File ivyTempFile = File.createTempFile("String_Node_Str", "String_Node_Str");
            ivyTempFile.deleteOnExit();
            Message.debug("String_Node_Str" + getName() + "String_Node_Str" + ivyRef.getResource());
            get(ivyRef.getResource(), ivyTempFile);
            downloaded = true;
            try {
                cachedIvyURL = ivyTempFile.toURL();
            } catch (MalformedURLException ex) {
                Message.warn("String_Node_Str" + ivyTempFile + "String_Node_Str" + ex.getMessage());
                return null;
            }
        } catch (IOException ex) {
            Message.warn("String_Node_Str" + ivyRef.getResource() + "String_Node_Str" + ex.getMessage());
            return null;
        }
        try {
            md = parser.parseDescriptor(data.getIvy(), cachedIvyURL, ivyRef.getResource(), doValidate(data));
            Message.debug("String_Node_Str" + getName() + "String_Node_Str" + mrid + "String_Node_Str" + md.getModuleRevisionId());
            if (!mrid.getOrganisation().equals(md.getModuleRevisionId().getOrganisation())) {
                throw new IllegalStateException("String_Node_Str" + ivyRef.getResource() + "String_Node_Str" + mrid.getOrganisation() + "String_Node_Str" + md.getModuleRevisionId().getOrganisation());
            }
            if (!mrid.getName().equals(md.getModuleRevisionId().getName())) {
                throw new IllegalStateException("String_Node_Str" + ivyRef.getResource() + "String_Node_Str" + mrid.getName() + "String_Node_Str" + md.getModuleRevisionId().getName());
            }
            if (ivyRef.getRevision() != null && md.getModuleRevisionId().getRevision() != null && !ModuleRevisionId.acceptRevision(ivyRef.getRevision(), md.getModuleRevisionId().getRevision())) {
                throw new IllegalStateException("String_Node_Str" + ivyRef.getResource() + "String_Node_Str" + ivyRef.getRevision() + "String_Node_Str" + md.getModuleRevisionId().getRevision());
            }
            boolean deleteOldArtifacts = false;
            if (cachedPublicationDate != null && !cachedPublicationDate.equals(md.getResolvedPublicationDate())) {
                Message.verbose("String_Node_Str" + dd + "String_Node_Str");
                deleteOldArtifacts = true;
            }
            if (deleteOldArtifacts) {
                String[] confs = rmr.getDescriptor().getConfigurationsNames();
                for (int i = 0; i < confs.length; i++) {
                    Artifact[] arts = rmr.getDescriptor().getArtifacts(confs[i]);
                    for (int j = 0; j < arts.length; j++) {
                        File artFile = data.getIvy().getArchiveFileInCache(data.getCache(), arts[j]);
                        if (artFile.exists()) {
                            Message.debug("String_Node_Str" + artFile);
                            artFile.delete();
                        }
                    }
                }
            } else if (dd.isChanging()) {
                Message.verbose("String_Node_Str" + dd + "String_Node_Str");
            }
        } catch (IOException ex) {
            Message.warn("String_Node_Str" + ivyRef.getResource() + "String_Node_Str" + ex.getMessage());
            return null;
        }
    }
    if (mrid.getRevision().startsWith("String_Node_Str")) {
        String askedStatus = mrid.getRevision().substring("String_Node_Str".length());
        if (Status.getPriority(askedStatus) < Status.getPriority(md.getStatus())) {
            Message.info("String_Node_Str" + getName() + "String_Node_Str" + md.getStatus() + "String_Node_Str" + askedStatus);
            return null;
        }
    } else if (!mrid.acceptRevision(md.getModuleRevisionId().getRevision())) {
        Message.info("String_Node_Str" + getName() + "String_Node_Str" + md.getModuleRevisionId().getRevision() + "String_Node_Str" + mrid.getRevision());
        return null;
    }
    ModuleRevisionId resolvedMrid = mrid;
    if (!resolvedMrid.isExactRevision()) {
        resolvedMrid = md.getResolvedModuleRevisionId();
        if (resolvedMrid.getRevision() == null || resolvedMrid.getRevision().length() == 0) {
            if (ivyRef.getRevision() == null || ivyRef.getRevision().length() == 0 || !ModuleRevisionId.isExactRevision(ivyRef.getRevision())) {
                resolvedMrid = new ModuleRevisionId(resolvedMrid.getModuleId(), (_envDependent ? "String_Node_Str" : "String_Node_Str") + DATE_FORMAT.format(data.getDate()) + "String_Node_Str" + _workspaceName);
            } else {
                resolvedMrid = new ModuleRevisionId(resolvedMrid.getModuleId(), ivyRef.getRevision());
            }
        }
        Message.verbose("String_Node_Str" + resolvedMrid.getRevision() + "String_Node_Str" + mrid.getModuleId());
    }
    md.setResolvedModuleRevisionId(resolvedMrid);
    if (data.getDate() != null) {
        long pubDate = getPublicationDate(md, dd, data);
        if (pubDate > data.getDate().getTime()) {
            Message.info("String_Node_Str" + getName() + "String_Node_Str" + new Date(pubDate) + "String_Node_Str" + data.getDate());
            return null;
        } else if (pubDate == -1) {
            Message.info("String_Node_Str" + getName() + "String_Node_Str" + mrid);
            return null;
        }
        md.setResolvedPublicationDate(new Date(pubDate));
    }
    try {
        File ivyFile = data.getIvy().getIvyFileInCache(data.getCache(), md.getResolvedModuleRevisionId());
        if (ivyRef == null) {
            XmlModuleDescriptorWriter.write(md, ivyFile);
        } else {
            parser.toIvyFile(cachedIvyURL, ivyRef.getResource(), ivyFile, md);
            long repLastModified = ivyRef.getLastModified();
            if (repLastModified > 0) {
                ivyFile.setLastModified(repLastModified);
            }
        }
    } catch (Exception e) {
        Message.warn("String_Node_Str" + ivyRef.getResource());
    }
    data.getIvy().saveResolver(data.getCache(), md, getName());
    return new DefaultModuleRevision(this, md, searched, downloaded);
}

Output:
             if (cachedPublicationDate != null && !cachedPublicationDate.equals(md.getResolvedPublicationDate())) {
-                Message.verbose("String_Node_Str" + dd + "String_Node_Str");
+                Message.verbose(dd + "String_Node_Str");
                 deleteOldArtifacts = true;


Input:
public int compare(String str1, String str2) {
    if (HadoopRole.fromString(str1).shouldRunAfterHDFS()) {
        return 1;
    } else if (HadoopRole.fromString(str2).shouldRunAfterHDFS()) {
        return -1;
    } else {
        return 0;
    }
}

Output:
     } else {
-        return 0;
+        return arg0.getGroupType().compareTo(arg1.getGroupType());
     }


Input:
private static void zipFiles(ZipOutputStream zipOut, File[] files, String tempFolderPath) throws FileNotFoundException, IOException {
    if (files == null)
        return;
    for (int i = 0; i < files.length; i++) {
        File file = files[i];
        if (file.isDirectory()) {
            File[] dirFiles = file.listFiles();
            zipFiles(zipOut, dirFiles, tempFolderPath);
        } else {
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
            String relativePath = generateRelativePath(tempFolderPath, file.getPath());
            ZipEntry entry = new ZipEntry(relativePath);
            entry.setTime(file.lastModified());
            zipOut.putNextEntry(entry);
            int len;
            byte[] buf = new byte[1024 * 5];
            while ((len = in.read(buf)) > 0) {
                zipOut.write(buf, 0, len);
            }
            in.close();
            zipOut.closeEntry();
        }
    }
}

Output:
             BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
-            String relativePath = generateRelativePath(tempFolderPath, file.getPath());
-            ZipEntry entry = new ZipEntry(relativePath);
-            entry.setTime(file.lastModified());
-            zipOut.putNextEntry(entry);
-            int len;
-            byte[] buf = new byte[1024 * 5];
-            while ((len = in.read(buf)) > 0) {
-                zipOut.write(buf, 0, len);
+            try {
+                String relativePath = generateRelativePath(tempFolderPath, file.getPath());
+                ZipEntry entry = new ZipEntry(relativePath);
+                try {
+                    entry.setTime(file.lastModified());
+                    zipOut.putNextEntry(entry);
+                    int len;
+                    byte[] buf = new byte[1024 * 5];
+                    while ((len = in.read(buf)) > 0) {
+                        zipOut.write(buf, 0, len);
+                    }
+                } finally {
+                    zipOut.closeEntry();
+                }
+            } finally {
+                in.close();
             }


Input:
protected Collection<Analysis> searchAllAnalysis(IFolder folder) {
    Collection<Analysis> analyses = new ArrayList<Analysis>();
    try {
        for (IResource resource : folder.members()) {
            if (resource.getType() == IResource.FOLDER) {
                if (!resource.getName().startsWith("String_Node_Str")) {
                    analyses.addAll(searchAllAnalysis(folder.getFolder(resource.getName())));
                }
                continue;
            }
            IFile file = (IFile) resource;
            if (null != file.getFileExtension() && file.getFileExtension().equals(FactoriesUtil.ANA)) {
                URI uri = URI.createPlatformResourceURI(file.getFullPath().toString(), false);
                Resource eResource = EMFSharedResources.getInstance().getResource(uri, true);
                if (!eResource.getContents().isEmpty()) {
                    analyses.add((Analysis) eResource.getContents().get(0));
                }
            }
        }
    } catch (Exception e) {
        log.error(e);
    }
    return analyses;
}

Output:
                 Resource eResource = EMFSharedResources.getInstance().getResource(uri, true);
-                if (!eResource.getContents().isEmpty()) {
+                if (eResource.getContents().size() > 0) {
                     analyses.add((Analysis) eResource.getContents().get(0));


Input:
public void createDataPreviewTableFromFile() {
    parser.parse(dataSetDescription.getDataSourcePath(), dataSetDescription.getDelimiter(), false, MAX_PREVIEW_TABLE_ROWS);
    dataMatrix = parser.getDataMatrix();
    totalNumberOfColumns = parser.getTotalNumberOfColumns();
    totalNumberOfRows = parser.getTotalNumberOfRows();
    DataImportWizard wizard = (DataImportWizard) page.getWizard();
    wizard.setTotalNumberOfColumns(totalNumberOfColumns);
    wizard.setTotalNumberOfRows(totalNumberOfRows);
    page.previewTable.createDataPreviewTableFromDataMatrix(dataMatrix);
    updateWidgetsAccordingToTableChanges();
    determineIDTypes();
    guessNumberOfHeaderRows();
    page.previewTable.updateTableColors(dataSetDescription.getNumberOfHeaderLines(), dataSetDescription.getRowOfColumnIDs(), dataSetDescription.getColumnOfRowIds());
    page.parentComposite.pack();
}

Output:
     wizard.setTotalNumberOfRows(totalNumberOfRows);
-    page.previewTable.createDataPreviewTableFromDataMatrix(dataMatrix);
+    page.previewTable.createDataPreviewTableFromDataMatrix(dataMatrix, totalNumberOfColumns);
     updateWidgetsAccordingToTableChanges();


Input:
public void Draw() {
    if (!_isVisible) {
        return;
    }
    XnaManager.Renderer.Draw(_menuBase, GetHudOrigin(), Depth.HudBG, Color.GREEN, GameManager.SpriteWidth, CalculateHeight(StatType.HEALTH));
    XnaManager.Renderer.Draw(_menuBase, _manaPosition, Depth.HudBG, Color.BLUE, GameManager.SpriteWidth, CalculateHeight(StatType.MANA));
    XnaManager.Renderer.Draw(_menuBase, _costPosition, Depth.HudBG, Color.YELLOW, GameManager.SpriteWidth / 2, CostOfCurrentSkill());
    _textHandler.Draw();
}

Output:
     XnaManager.Renderer.Draw(_menuBase, _manaPosition, Depth.HudBG, Color.BLUE, GameManager.SpriteWidth, CalculateHeight(StatType.MANA));
-    XnaManager.Renderer.Draw(_menuBase, _costPosition, Depth.HudBG, Color.YELLOW, GameManager.SpriteWidth / 2, CostOfCurrentSkill());
+    XnaManager.Renderer.Draw(_menuBase, _manaPosition, Depth.HudBG, Color.YELLOW, GameManager.SpriteWidth / 2, CostOfCurrentSkill());
     _textHandler.Draw();


Input:
public void PlayerMove(PlayerMoveEvent event) {
    try {
        Player player = event.getPlayer();
        Location from = event.getFrom();
        Location to = event.getTo();
        if ((from.getBlockX() != to.getBlockX()) || (from.getBlockZ() != to.getBlockZ())) {
            if (!isPlotWorld(player.getWorld())) {
                return;
            }
            if (enteredPlot(event.getFrom(), event.getTo())) {
                Plot plot = getCurrentPlot(event.getTo());
                if (plot.hasOwner()) {
                    if (C.TITLE_ENTERED_PLOT.s().length() > 2) {
                        String sTitleMain = C.TITLE_ENTERED_PLOT.s().replaceFirst("String_Node_Str", plot.getDisplayName());
                        String sTitleSub = C.TITLE_ENTERED_PLOT_SUB.s().replaceFirst("String_Node_Str", getName(plot.owner));
                        ChatColor sTitleMainColor = ChatColor.valueOf(C.TITLE_ENTERED_PLOT_COLOR.s());
                        ChatColor sTitleSubColor = ChatColor.valueOf(C.TITLE_ENTERED_PLOT_SUB_COLOR.s());
                        Title title = new Title(sTitleMain, sTitleSub, 10, 20, 10);
                        title.setTitleColor(sTitleMainColor);
                        title.setSubtitleColor(sTitleSubColor);
                        title.setTimingsToTicks();
                        title.send(player);
                    }
                    {
                        PlayerEnterPlotEvent callEvent = new PlayerEnterPlotEvent(player, plot);
                        Bukkit.getPluginManager().callEvent(callEvent);
                    }
                    boolean admin = player.hasPermission("String_Node_Str");
                    PlayerFunctions.sendMessage(player, plot.settings.getJoinMessage());
                    if (plot.deny_entry(player) && !admin) {
                        event.setCancelled(true);
                        return;
                    }
                    if (plot.settings.getRain()) {
                        PlayerFunctions.togglePlotWeather(player, plot);
                    }
                    if (plot.settings.getChangeTime()) {
                        PlayerFunctions.togglePlotTime(player, plot);
                    }
                }
            } else if (leftPlot(event.getFrom(), event.getTo())) {
                Plot plot = getCurrentPlot(event.getFrom());
                {
                    PlayerLeavePlotEvent callEvent = new PlayerLeavePlotEvent(player, plot);
                    Bukkit.getPluginManager().callEvent(callEvent);
                }
                event.getPlayer().resetPlayerTime();
                event.getPlayer().resetPlayerWeather();
                PlayerFunctions.sendMessage(player, plot.settings.getLeaveMessage());
            }
        }
    } catch (Exception e) {
    }
}

Output:
             }
-            if (enteredPlot(event.getFrom(), event.getTo())) {
+            if (enteredPlot(from, to)) {
                 Plot plot = getCurrentPlot(event.getTo());


Input:
private HandlerProcessingResult processAnnotation(AnnotationInfo ainfo, WebBundleDescriptor webBundleDesc) throws AnnotationProcessorException {
    Class filterClass = (Class) ainfo.getAnnotatedElement();
    if (!javax.servlet.Filter.class.isAssignableFrom(filterClass)) {
        log(Level.SEVERE, ainfo, localStrings.getLocalString("String_Node_Str", "String_Node_Str", new Object[] { filterClass.getName(), WebFilter.class.getName(), javax.servlet.Filter.class.getName() }));
        return getDefaultFailedResult();
    }
    WebFilter webFilterAn = (WebFilter) ainfo.getAnnotation();
    String filterName = webFilterAn.filterName();
    if (filterName == null || filterName.length() == 0) {
        filterName = filterClass.getName();
    }
    ServletFilterDescriptor servletFilterDesc = null;
    for (ServletFilter sfDesc : webBundleDesc.getServletFilters()) {
        if (filterName.equals(sfDesc.getName())) {
            servletFilterDesc = (ServletFilterDescriptor) sfDesc;
            break;
        }
    }
    if (servletFilterDesc == null) {
        servletFilterDesc = new ServletFilterDescriptor();
        servletFilterDesc.setName(filterName);
        webBundleDesc.addServletFilter(servletFilterDesc);
    } else {
        String filterImpl = servletFilterDesc.getClassName();
        if (filterImpl != null && filterImpl.length() > 0 && !filterImpl.equals(filterClass.getName())) {
            log(Level.SEVERE, ainfo, localStrings.getLocalString("String_Node_Str", "String_Node_Str", new Object[] { filterName, filterImpl, filterClass.getName(), WebFilter.class.getName() }));
            return getDefaultFailedResult();
        }
    }
    servletFilterDesc.setClassName(filterClass.getName());
    if (servletFilterDesc.getDescription() == null || servletFilterDesc.getDescription().length() == 0) {
        servletFilterDesc.setDescription(webFilterAn.description());
    }
    if (servletFilterDesc.hasSetDisplayName()) {
        servletFilterDesc.setDisplayName(webFilterAn.displayName());
    }
    if (servletFilterDesc.getInitializationParameters().size() == 0) {
        WebInitParam[] initParams = webFilterAn.initParams();
        if (initParams != null && initParams.length > 0) {
            for (WebInitParam initParam : initParams) {
                servletFilterDesc.addInitializationParameter(new EnvironmentProperty(initParam.name(), initParam.value(), initParam.description()));
            }
        }
    }
    if (servletFilterDesc.getSmallIconUri() == null) {
        servletFilterDesc.setSmallIconUri(webFilterAn.smallIcon());
    }
    if (servletFilterDesc.getLargeIconUri() == null) {
        servletFilterDesc.setLargeIconUri(webFilterAn.largeIcon());
    }
    if (servletFilterDesc.isAsyncSupported() == null) {
        servletFilterDesc.setAsyncSupported(webFilterAn.asyncSupported());
    }
    ServletFilterMapping servletFilterMappingDesc = null;
    boolean hasUrlPattern = false;
    boolean hasServletName = false;
    for (ServletFilterMapping sfm : webBundleDesc.getServletFilterMappings()) {
        if (filterName.equals(sfm.getName())) {
            servletFilterMappingDesc = sfm;
            hasUrlPattern = hasUrlPattern || (sfm.getURLPatterns().size() > 0);
            hasServletName = hasServletName || (sfm.getServletNames().size() > 0);
        }
    }
    if (servletFilterMappingDesc == null) {
        servletFilterMappingDesc = new ServletFilterMappingDescriptor();
        servletFilterMappingDesc.setName(filterName);
        webBundleDesc.addServletFilterMapping(servletFilterMappingDesc);
    }
    if (!hasUrlPattern) {
        String[] urlPatterns = webFilterAn.urlPatterns();
        if (urlPatterns == null || urlPatterns.length == 0) {
            urlPatterns = webFilterAn.value();
        }
        boolean validUrlPatterns = true;
        if (urlPatterns != null && urlPatterns.length > 0) {
            for (String up : urlPatterns) {
                if (!URLPattern.isValid(up)) {
                    validUrlPatterns = false;
                    break;
                }
                servletFilterMappingDesc.addURLPattern(up);
            }
        }
        if (!validUrlPatterns) {
            String urlPatternString = (urlPatterns != null) ? Arrays.toString(urlPatterns) : "String_Node_Str";
            throw new IllegalArgumentException(localStrings.getLocalString("String_Node_Str", "String_Node_Str", urlPatternString));
        }
    }
    if (!hasServletName) {
        String[] servletNames = webFilterAn.servletNames();
        if (servletNames != null && servletNames.length > 0) {
            for (String sn : servletNames) {
                servletFilterMappingDesc.addServletName(sn);
            }
        }
    }
    if (servletFilterMappingDesc.getDispatchers().size() == 0) {
        DispatcherType[] dispatcherTypes = webFilterAn.dispatcherTypes();
        if (dispatcherTypes != null && dispatcherTypes.length > 0) {
            for (DispatcherType dType : dispatcherTypes) {
                servletFilterMappingDesc.addDispatcher(dType.name());
            }
        }
    }
    return getDefaultProcessedResult();
}

Output:
             servletFilterMappingDesc = sfm;
-            hasUrlPattern = hasUrlPattern || (sfm.getURLPatterns().size() > 0);
+            hasUrlPattern = hasUrlPattern || (sfm.getUrlPatterns().size() > 0);
             hasServletName = hasServletName || (sfm.getServletNames().size() > 0);


Input:
private void deployToWeblogicServer(String serverprotocol, String serverhost, String serverport, String serverusername, String serverpassword) throws MojoExecutionException {
    try {
        StringBuilder sb = new StringBuilder();
        sb.append(MVN_CMD);
        sb.append(STR_SPACE);
        sb.append(WEBLOGIC_GOAL);
        sb.append(STR_SPACE);
        sb.append(SERVER_HOST);
        sb.append(serverhost);
        sb.append(STR_SPACE);
        sb.append(SERVER_PORT);
        sb.append(serverport);
        sb.append(STR_SPACE);
        sb.append(SERVER_USERNAME);
        sb.append(serverusername);
        sb.append(STR_SPACE);
        sb.append(SERVER_PASSWORD);
        sb.append(serverpassword);
        sb.append(STR_SPACE);
        sb.append(SKIP_TESTS);
        Commandline cl = new Commandline(sb.toString());
        cl.setWorkingDirectory(baseDir);
        Process process = cl.execute();
        getLog().info("String_Node_Str" + serverprotocol + "String_Node_Str" + serverhost + "String_Node_Str" + serverport + "String_Node_Str" + context);
    } catch (CommandLineException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }
}

Output:
         Process process = cl.execute();
-        getLog().info("String_Node_Str" + serverprotocol + "String_Node_Str" + serverhost + "String_Node_Str" + serverport + "String_Node_Str" + context);
+        in = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String line = null;
+        while ((line = in.readLine()) != null) {
+            if (line.startsWith("String_Node_Str")) {
+                System.out.println(line);
+                errorParam = true;
+            }
+        }
+        if (errorParam) {
+            throw new MojoExecutionException("String_Node_Str");
+        } else {
+            getLog().info("String_Node_Str" + serverprotocol + "String_Node_Str" + serverhost + "String_Node_Str" + serverport + "String_Node_Str" + context);
+        }
     } catch (CommandLineException e) {


Input:
public void handle(Message inputMessage, IMessageTarget messageTarget) {
    getComponentStatistics().incrementInboundMessages();
    ArrayList<String> inputRows = inputMessage.getPayload();
    ArrayList<EntityData> outputPayload = new ArrayList<EntityData>();
    Message outputMessage = inputMessage.copy(getFlowStepId(), outputPayload);
    int headerRowsToSkip = numberOfHeaderLinesToSkip;
    try {
        int rowCount = 0;
        for (String inputRow : inputRows) {
            if (headerRowsToSkip == 0) {
                if (rowCount + numberOfFooterLinesToSkip < inputRows.size()) {
                    EntityData data = processInputRow(inputRow);
                    if (data != null) {
                        outputPayload.add(data);
                    }
                }
            } else {
                headerRowsToSkip--;
            }
            rowCount++;
        }
    } catch (IOException e) {
        throw new IoException(e);
    }
    getComponentStatistics().incrementOutboundMessages();
    outputMessage.getHeader().setSequenceNumber(getComponentStatistics().getNumberOutboundMessages());
    outputMessage.getHeader().setLastMessage(inputMessage.getHeader().isLastMessage());
    messageTarget.put(outputMessage);
}

Output:
             if (headerRowsToSkip == 0) {
-                if (rowCount + numberOfFooterLinesToSkip < inputRows.size()) {
+                if (!inputMessage.getHeader().isLastMessage() || (rowCount + numberOfFooterLinesToSkip < inputRows.size())) {
                     EntityData data = processInputRow(inputRow);


Input:
private void writeFont(String fontName, String size, String bold, String italic, String strikeThrough, String underline, String color) {
    writer.openTag("String_Node_Str");
    if (isValid(fontName)) {
        writer.attribute("String_Node_Str", fontName);
    }
    if (isValid(size)) {
        writer.attribute("String_Node_Str", size);
    }
    if (isValid(bold)) {
        writer.attribute("String_Node_Str", bold);
    }
    if (isValid(italic)) {
        writer.attribute("String_Node_Str", italic);
    }
    if (isValid(strikeThrough)) {
        writer.attribute("String_Node_Str", strikeThrough);
    }
    if (isValid(underline) && !"String_Node_Str".equalsIgnoreCase(underline)) {
        writer.attribute("String_Node_Str", "String_Node_Str");
    }
    if (isValid(color)) {
        writer.attribute("String_Node_Str", color);
    }
    writer.closeTag("String_Node_Str");
}

Output:
     }
-    if (isValid(size)) {
+    if (size != null) {
         writer.attribute("String_Node_Str", size);


Input:
public void testExecuteOnMembers() {
    final IExecutorService service = client.getExecutorService(randomString());
    final String mapName = randomString();
    final Collection collection = new ArrayList();
    final Member member1 = instance1.getCluster().getLocalMember();
    final Member member3 = instance3.getCluster().getLocalMember();
    collection.add(member1);
    collection.add(member3);
    service.executeOnMembers(new MapPutRunnable(mapName), collection);
    final IMap map = client.getMap(mapName);
    assertTrueEventually(new AssertTask() {
        public void run() throws Exception {
            assertTrue(map.containsKey(member1.getUuid()));
            assertTrue(map.containsKey(member3.getUuid()));
        }
    });
}

Output:
     final String mapName = randomString();
-    final Collection collection = new ArrayList();
+    final Collection<Member> collection = new ArrayList<Member>();
     final Member member1 = instance1.getCluster().getLocalMember();


Input:
void fitLinesUsingCorners(int anchor0, int numLines) {
    for (int i = 1; i <= numLines; i++) {
        int index0 = workCorners.get(CircularIndex.addOffset(anchor0, i - 1, workCorners.size));
        int index1 = workCorners.get(CircularIndex.addOffset(anchor0, i, workCorners.size));
        if (!fitLine(workCorners.get(index0), workCorners.get(index1), lines.get(i - 1))) {
            throw new RuntimeException("String_Node_Str");
        }
    }
}

Output:
     for (int i = 1; i <= numLines; i++) {
-        int index0 = workCorners.get(CircularIndex.addOffset(anchor0, i - 1, workCorners.size));
-        int index1 = workCorners.get(CircularIndex.addOffset(anchor0, i, workCorners.size));
-        if (!fitLine(workCorners.get(index0), workCorners.get(index1), lines.get(i - 1))) {
+        int index0 = cornerIndexes.get(CircularIndex.addOffset(anchor0, i - 1, cornerIndexes.size));
+        int index1 = cornerIndexes.get(CircularIndex.addOffset(anchor0, i, cornerIndexes.size));
+        if (index0 == index1)
+            return false;
+        if (!fitLine(index0, index1, lines.get(i - 1))) {
+            throw new RuntimeException("String_Node_Str");
+        }
+        LineGeneral2D_F64 l = lines.get(i - 1);
+        if (Double.isNaN(l.A) || Double.isNaN(l.B) || Double.isNaN(l.C)) {
+            Point2D_I32 c0 = contour.get(index0);
+            Point2D_I32 c1 = contour.get(index1);
             throw new RuntimeException("String_Node_Str");


Input:
public void removeNotificationListener(ObjectName name, NotificationListener listener, NotificationFilter filter, Object handback) throws InstanceNotFoundException, ListenerNotFoundException {
    try {
        registerMBeanIfDelayed(name);
    } catch (NotCompliantMBeanException e) {
        emitJMXNotificationEvent(name, listener, filter, handback, "String_Node_Str", "String_Node_Str", "String_Node_Str");
        newInstanceNotFoundException(e);
    } catch (InstanceAlreadyExistsException e) {
        emitJMXNotificationEvent(name, listener, filter, handback, "String_Node_Str", "String_Node_Str", "String_Node_Str");
        newInstanceNotFoundException(e);
    } catch (MBeanRegistrationException e) {
        emitJMXNotificationEvent(name, listener, filter, handback, "String_Node_Str", "String_Node_Str", "String_Node_Str");
        newInstanceNotFoundException(e);
    }
    super.removeNotificationListener(name, listener, filter, handback);
    emitJMXNotificationEvent(name, listener, filter, handback, "String_Node_Str", "String_Node_Str", "String_Node_Str");
}

Output:
     }
-    super.removeNotificationListener(name, listener, filter, handback);
+    try {
+        super.removeNotificationListener(name, listener, filter, handback);
+    } catch (InstanceNotFoundException e) {
+        emitJMXNotificationEvent(name, listener, null, null, "String_Node_Str", "String_Node_Str", "String_Node_Str");
+        throw e;
+    } catch (ListenerNotFoundException e) {
+        emitJMXNotificationEvent(name, listener, null, null, "String_Node_Str", "String_Node_Str", "String_Node_Str");
+        throw e;
+    }
     emitJMXNotificationEvent(name, listener, filter, handback, "String_Node_Str", "String_Node_Str", "String_Node_Str");


Input:
protected void getIp(NicProfile nic, DataCenter dc, VirtualMachineProfile vm, Network network) throws InsufficientVirtualNetworkCapcityException, InsufficientAddressCapacityException, ConcurrentOperationException {
    if (nic.getIp4Address() == null) {
        PublicIp ip = _ipAddrMgr.assignPublicIpAddress(dc.getId(), null, vm.getOwner(), VlanType.VirtualNetwork, null, null, false);
        nic.setIp4Address(ip.getAddress().toString());
        nic.setGateway(ip.getGateway());
        nic.setNetmask(ip.getNetmask());
        nic.setIsolationUri(IsolationType.Vlan.toUri(ip.getVlanTag()));
        nic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(ip.getVlanTag()));
        nic.setBroadcastType(BroadcastDomainType.Vlan);
        nic.setFormat(AddressFormat.Ip4);
        nic.setReservationId(String.valueOf(ip.getVlanTag()));
        nic.setMacAddress(ip.getMacAddress());
    }
    nic.setDns1(dc.getDns1());
    nic.setDns2(dc.getDns2());
}

Output:
         nic.setNetmask(ip.getNetmask());
-        nic.setIsolationUri(IsolationType.Vlan.toUri(ip.getVlanTag()));
-        nic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(ip.getVlanTag()));
-        nic.setBroadcastType(BroadcastDomainType.Vlan);
+        if (network.getBroadcastDomainType() == BroadcastDomainType.Vxlan) {
+            nic.setIsolationUri(BroadcastDomainType.Vxlan.toUri(ip.getVlanTag()));
+            nic.setBroadcastUri(BroadcastDomainType.Vxlan.toUri(ip.getVlanTag()));
+            nic.setBroadcastType(BroadcastDomainType.Vxlan);
+        } else {
+            nic.setIsolationUri(IsolationType.Vlan.toUri(ip.getVlanTag()));
+            nic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(ip.getVlanTag()));
+            nic.setBroadcastType(BroadcastDomainType.Vlan);
+        }
         nic.setFormat(AddressFormat.Ip4);


Input:
private String getRunIdOfRunningProgram(final Id.Program programId) throws Exception {
    Tasks.waitFor(1, new Callable<Integer>() {
        public Integer call() throws Exception {
            return getProgramRuns(programId, ProgramRunStatus.RUNNING).size();
        }
    }, 5, TimeUnit.SECONDS);
    List<RunRecord> historyRuns = getProgramRuns(programId, ProgramRunStatus.RUNNING);
    Assert.assertEquals(1, historyRuns.size());
    RunRecord record = historyRuns.get(0);
    return record.getPid();
}

Output:
 private String getRunIdOfRunningProgram(final Id.Program programId) throws Exception {
-    Tasks.waitFor(1, new Callable<Integer>() {
-        public Integer call() throws Exception {
-            return getProgramRuns(programId, ProgramRunStatus.RUNNING).size();
-        }
-    }, 5, TimeUnit.SECONDS);
+    Tasks.waitFor(1, () -> getProgramRuns(programId, ProgramRunStatus.RUNNING).size(), 5, TimeUnit.SECONDS);
     List<RunRecord> historyRuns = getProgramRuns(programId, ProgramRunStatus.RUNNING);


Input:
public Pat getPat(String oxdId) {
    validationService.notBlankOxdId(oxdId);
    SiteConfiguration site = siteService.getSite(oxdId);
    if (site.getPat() != null && site.getPatCreatedAt() != null && site.getPatExpiresIn() > 0) {
        Calendar c = Calendar.getInstance();
        c.setTime(site.getPatCreatedAt());
        c.add(Calendar.SECOND, site.getPatExpiresIn());
        boolean isExpired = c.getTime().after(new Date());
        if (!isExpired) {
            LOG.debug("String_Node_Str" + site.getPat());
            return new Pat(site.getPat(), "String_Node_Str", site.getPatExpiresIn());
        }
    }
    return obtainPat(oxdId);
}

Output:
         c.add(Calendar.SECOND, site.getPatExpiresIn());
-        boolean isExpired = c.getTime().after(new Date());
+        boolean isExpired = c.getTime().before(new Date());
         if (!isExpired) {


Input:
public static void main(String[] args) throws UnknownHostException, ScribbleRuntimeException, IOException, ClassNotFoundException {
    Buff<Integer> i1 = new Buff<>(1);
    Buff<Integer> i2 = new Buff<>(2);
    Adder adder = new Adder();
    SessionEndpoint se = adder.project(Adder.C, new ObjectStreamFormatter());
    try (Adder_C_0 s0 = new Adder_C_0(se)) {
        s0.connect(Adder.S, "String_Node_Str", 8888);
        Adder_C_1 s1 = s0.init();
        s1.send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.BYE).end();
        System.out.println("String_Node_Str" + i1.val);
    }
}

Output:
         Adder_C_1 s1 = s0.init();
-        s1.send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.BYE).end();
+        s1.send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.ADD, i1.val, i1.val).receive(Adder.RES, i1).send(Adder.S, Adder.BYE).receive(Adder.BYE);
         System.out.println("String_Node_Str" + i1.val);


Input:
public boolean isOidUsed(long oid) {
    checkOpen();
    ZooPCImpl co = cache.findCoByOID(oid);
    if (co != null) {
        return true;
    }
    GenericObject go = cache.getGeneric(oid);
    if (go != null) {
        return true;
    }
    for (Node n : nodes) {
        if (n.checkIfObjectExists(oid)) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean isOidUsed(long oid) {
-    checkOpen();
+    checkActive();
     ZooPCImpl co = cache.findCoByOID(oid);


Input:
protected void generateExtraBindings(BaseQueryDefinition query) throws ChartException {
    SeriesDefinition categorySD = null;
    SeriesDefinition orthSD = null;
    Axis[] orthAxisArray = null;
    if (fChartModel instanceof ChartWithAxes) {
        ChartWithAxes cwa = (ChartWithAxes) fChartModel;
        categorySD = cwa.getBaseAxes()[0].getSeriesDefinitions().get(0);
        orthAxisArray = cwa.getOrthogonalAxes(cwa.getBaseAxes()[0], true);
        orthSD = orthAxisArray[0].getSeriesDefinitions().get(0);
    } else if (fChartModel instanceof ChartWithoutAxes) {
        ChartWithoutAxes cwoa = (ChartWithoutAxes) fChartModel;
        categorySD = cwoa.getSeriesDefinitions().get(0);
        orthSD = categorySD.getSeriesDefinitions().get(0);
    }
    initYGroupingNSortKey(query, categorySD, orthSD, orthAxisArray);
    GroupDefinition categoryGroupDefinition = initCategoryGrouping(query, categorySD);
    Map<String, String[]> valueExprMap = addAggregateBindings(query, categorySD, orthAxisArray);
    if (bCreateBindingForExpression) {
        String exprCategory = (categorySD.getDesignTimeSeries().getDataDefinition().get(0)).getDefinition();
        String exprYGroup = orthSD.getQuery().getDefinition();
        try {
            exprCodec.decode(exprCategory);
            if (!exprCodec.isRowBinding(false)) {
                addExtraBinding(query, exprCodec);
            }
            exprCodec.decode(exprYGroup);
            if (!exprCodec.isRowBinding(false)) {
                addExtraBinding(query, exprCodec);
            }
            if (query instanceof ISubqueryDefinition) {
                ChartReportItemUtil.copyAndInsertBindingFromContainer((ISubqueryDefinition) query, exprCategory);
                ChartReportItemUtil.copyAndInsertBindingFromContainer((ISubqueryDefinition) query, exprYGroup);
                if (!categorySD.getGrouping().isEnabled()) {
                    for (SeriesDefinition sd : ChartUtil.getAllOrthogonalSeriesDefinitions(fChartModel)) {
                        List<Query> queries = sd.getDesignTimeSeries().getDataDefinition();
                        for (Query queryExpr : queries) {
                            ChartReportItemUtil.copyAndInsertBindingFromContainer((ISubqueryDefinition) query, queryExpr.getDefinition());
                        }
                    }
                }
            }
        } catch (DataException e) {
            throw new ChartException(ChartReportItemPlugin.ID, ChartException.DATA_BINDING, e);
        }
    }
    if (categorySD != null) {
        bindSortOnCategorySeries(query, categorySD, categoryGroupDefinition, valueExprMap);
    }
}

Output:
     if (categorySD != null) {
-        bindSortOnCategorySeries(query, categorySD, categoryGroupDefinition, valueExprMap);
+        bindSortOnCategorySeries(query, categorySD, categoryGroupDefinition, valueExprMap, orthAxisArray);
     }


Input:
protected Long handleInternally(JSONObject content) {
    final Long guildId = content.has("String_Node_Str") ? content.getLong("String_Node_Str") : null;
    if (guildId != null && api.getGuildLock().isLocked(guildId))
        return guildId;
    if (guildId == null)
        return super.handleInternally(content);
    final long userId = content.getLong("String_Node_Str");
    final Long channelId = !content.isNull("String_Node_Str") ? content.getLong("String_Node_Str") : null;
    Guild guild = api.getGuildById(guildId);
    if (guild == null)
        return super.handleInternally(content);
    Member member = guild.getMemberById(userId);
    if (member == null)
        return super.handleInternally(content);
    if (!member.equals(guild.getSelfMember()))
        return super.handleInternally(content);
    VoiceChannel channel = channelId != null ? guild.getVoiceChannelById(channelId) : null;
    JdaLink link = lavalink.getLink(guildId.toString());
    if (channelId == null) {
        if (link.getState() != Link.State.DESTROYED) {
            link.onDisconnected();
        }
    } else if (channel != null) {
        link.setChannel(channel);
    }
    if (link.getState() == Link.State.CONNECTED) {
        api.getClient().updateAudioConnection(guildId, channel);
    }
    return super.handleInternally(content);
}

Output:
     } else if (channel != null) {
-        link.setChannel(channel);
+        link.setChannel(channel.getId());
     }


Input:
protected void generateMethodBody(int access, String name, String desc, String signature, String[] exceptions) {
    String resolvedSignature = signature;
    if (signature != null) {
        resolvedSignature = mockedTypeInfo.genericTypeMap.resolveReturnType(signature);
    }
    mw = cw.visitMethod(ACC_PUBLIC, name, desc, resolvedSignature, exceptions);
    generateDirectCallToHandler(mw, interfaceName, access, name, desc, resolvedSignature);
    generateReturnWithObjectAtTopOfTheStack(desc);
    mw.visitMaxs(1, 0);
}

Output:
     if (signature != null) {
-        resolvedSignature = mockedTypeInfo.genericTypeMap.resolveReturnType(signature);
+        resolvedSignature = mockedTypeInfo.genericTypeMap.resolveReturnType(interfaceName, signature);
     }


Input:
public boolean apply(Game game, Ability source) {
    FairgroundsTrumpeterWatcher watcher = (FairgroundsTrumpeterWatcher) game.getState().getWatchers().get("String_Node_Str");
    return watcher != null && watcher.p1p1AddedToPermanent(source.getControllerId());
}

Output:
 public boolean apply(Game game, Ability source) {
-    FairgroundsTrumpeterWatcher watcher = (FairgroundsTrumpeterWatcher) game.getState().getWatchers().get("String_Node_Str");
+    FairgroundsTrumpeterWatcher watcher = (FairgroundsTrumpeterWatcher) game.getState().getWatchers().get(FairgroundsTrumpeterWatcher.class.getName());
     return watcher != null && watcher.p1p1AddedToPermanent(source.getControllerId());


Input:
public void start(BundleContext context) throws Exception {
    try {
        super.start(context);
    } catch (IllegalArgumentException iae) {
        AbstractCmdlineClient.printConsoleError(iae.getMessage());
        throw iae;
    }
}

Output:
     } catch (IllegalArgumentException iae) {
-        AbstractCmdlineClient.printConsoleError(iae.getMessage());
+        AbstractCmdlineClient.printlnConsoleError(iae.getMessage());
         throw iae;


Input:
public boolean addResource(Resource resource) {
    return resources.add(resource);
}

Output:
 public boolean addResource(Resource resource) {
-    return resources.add(resource);
+    if (this.resources == null)
+        this.resources = new HashSet<Resource>();
+    return this.resources.add(resource);
 }


Input:
public IChunkProvider createChunkGenerator() {
    int dim = worldObj.provider.dimensionId;
    long seed = DimletConfiguration.randomizeSeed ? calculateSeed((long) (Math.random() * 10000 + 1), dim) : calculateSeed(worldObj.getSeed(), dim);
    return new GenericChunkProvider(worldObj, seed);
}

Output:
     int dim = worldObj.provider.dimensionId;
-    long seed = DimletConfiguration.randomizeSeed ? calculateSeed((long) (Math.random() * 10000 + 1), dim) : calculateSeed(worldObj.getSeed(), dim);
+    setSeed(dim);
     return new GenericChunkProvider(worldObj, seed);


Input:
public void testConstruction() {
    try {
        api_client.setResponse("String_Node_Str" + DataForTests.definition_hash + "String_Node_Str", 200);
        Historic h = def.createHistoric(DataForTests.historic_start, DataForTests.historic_end, DataForTests.historic_feeds, DataForTests.historic_sample, DataForTests.historic_name);
        assertEquals("String_Node_Str", DataForTests.definition_hash, h.getStreamHash());
        assertEquals("String_Node_Str", DataForTests.historic_name, h.getName());
        assertEquals("String_Node_Str", DataForTests.historic_start, h.getStartDate());
        assertEquals("String_Node_Str", DataForTests.historic_end, h.getEndDate());
        assertEquals("String_Node_Str", "String_Node_Str", h.getStatus());
        assertEquals("String_Node_Str", 0, h.getProgress());
        assertEquals("String_Node_Str", DataForTests.historic_sample, h.getSample());
        String[] feeds_input = DataForTests.historic_feeds.split("String_Node_Str");
        ArrayList<String> feeds = h.getFeeds();
        assertEquals("String_Node_Str", feeds_input.length, feeds.size());
        for (String feed : feeds_input) {
            assertTrue("String_Node_Str" + feed + "String_Node_Str", feeds.contains(feed));
        }
        HashMap<String, Integer> volume_info = h.getVolumeInfo();
        assertEquals("String_Node_Str", 0, volume_info.size());
    } catch (EInvalidData e) {
        fail("String_Node_Str" + e.getMessage());
    } catch (EAccessDenied e) {
        fail("String_Node_Str" + e.getMessage());
    }
}

Output:
         api_client.setResponse("String_Node_Str" + DataForTests.definition_hash + "String_Node_Str", 200);
-        Historic h = def.createHistoric(DataForTests.historic_start, DataForTests.historic_end, DataForTests.historic_feeds, DataForTests.historic_sample, DataForTests.historic_name);
+        Historic h = def.createHistoric(DataForTests.historic_start, DataForTests.historic_end, DataForTests.historic_sources, DataForTests.historic_sample, DataForTests.historic_name);
         assertEquals("String_Node_Str", DataForTests.definition_hash, h.getStreamHash());


Input:
public String learn(int id, String format) throws ClientNotKnownException {
    ClientState state = getState(id);
    state.getLearningAlgorithm().start();
    Description solution = state.getLearningAlgorithm().getBestSolution();
    if (format == "String_Node_Str")
        return solution.toManchesterSyntaxString(state.getReasoningService().getBaseURI(), new HashMap<String, String>());
    else if (format == "String_Node_Str")
        return solution.toKBSyntaxString();
    else
        return solution.toString();
}

Output:
     Description solution = state.getLearningAlgorithm().getBestSolution();
-    if (format == "String_Node_Str")
+    if (format.equals("String_Node_Str"))
         return solution.toManchesterSyntaxString(state.getReasoningService().getBaseURI(), new HashMap<String, String>());


Input:
public void before() {
    DateTimeUtils.setCurrentMillisFixed(NOW.getMillis());
    BridgeConfig mockConfig = mock(BridgeConfig.class);
    when(mockConfig.get("String_Node_Str")).thenReturn(BridgeConfigFactory.getConfig().get("String_Node_Str"));
    when(mockConfig.getEnvironment()).thenReturn(Environment.UAT);
    controller = spy(new AuthenticationController());
    controller.setBridgeConfig(mockConfig);
    controller.setAuthenticationService(authenticationService);
    controller.setCacheProvider(cacheProvider);
    controller.setAccountWorkflowService(accountWorkflowService);
    userSession = new UserSession();
    userSession.setReauthToken(REAUTH_TOKEN);
    userSession.setSessionToken(TEST_SESSION_TOKEN);
    userSession.setParticipant(new StudyParticipant.Builder().withId(TEST_ACCOUNT_ID).build());
    userSession.setInternalSessionToken(TEST_INTERNAL_SESSION_ID);
    userSession.setStudyIdentifier(TEST_STUDY_ID);
    study = new DynamoStudy();
    study.setIdentifier(TEST_STUDY_ID_STRING);
    study.setDataGroups(TestConstants.USER_DATA_GROUPS);
    when(studyService.getStudy(TEST_STUDY_ID_STRING)).thenReturn(study);
    when(studyService.getStudy(TEST_STUDY_ID)).thenReturn(study);
    controller.setStudyService(studyService);
    doReturn(metrics).when(controller).getMetrics();
}

Output:
     BridgeConfig mockConfig = mock(BridgeConfig.class);
-    when(mockConfig.get("String_Node_Str")).thenReturn(BridgeConfigFactory.getConfig().get("String_Node_Str"));
+    when(mockConfig.get("String_Node_Str")).thenReturn(WEBSERVICES_URL);
     when(mockConfig.getEnvironment()).thenReturn(Environment.UAT);


Input:
public void writeValue(Value v) {
    int start = pos;
    if (v == ValueNull.INSTANCE) {
        data[pos++] = 0;
        return;
    }
    int type = v.getType();
    switch(type) {
        case Value.BOOLEAN:
            writeByte((byte) (v.getBoolean().booleanValue() ? BOOLEAN_TRUE : BOOLEAN_FALSE));
            break;
        case Value.BYTE:
            writeByte((byte) type);
            writeByte(v.getByte());
            break;
        case Value.SHORT:
            writeByte((byte) type);
            writeShortInt(v.getShort());
            break;
        case Value.INT:
            {
                int x = v.getInt();
                if (x < 0) {
                    writeByte((byte) INT_NEG);
                    writeVarInt(-x);
                } else if (x < 16) {
                    writeByte((byte) (INT_0_15 + x));
                } else {
                    writeByte((byte) type);
                    writeVarInt(x);
                }
                break;
            }
        case Value.LONG:
            {
                long x = v.getLong();
                if (x < 0) {
                    writeByte((byte) LONG_NEG);
                    writeVarLong(-x);
                } else if (x < 8) {
                    writeByte((byte) (LONG_0_7 + x));
                } else {
                    writeByte((byte) type);
                    writeVarLong(x);
                }
                break;
            }
        case Value.DECIMAL:
            {
                BigDecimal x = v.getBigDecimal();
                if (BigDecimal.ZERO.equals(x)) {
                    writeByte((byte) DECIMAL_0_1);
                } else if (BigDecimal.ONE.equals(x)) {
                    writeByte((byte) (DECIMAL_0_1 + 1));
                } else {
                    int scale = x.scale();
                    BigInteger b = x.unscaledValue();
                    int bits = b.bitLength();
                    if (bits <= 63) {
                        if (scale == 0) {
                            writeByte((byte) DECIMAL_SMALL_0);
                            writeVarLong(b.longValue());
                        } else {
                            writeByte((byte) DECIMAL_SMALL);
                            writeVarInt(scale);
                            writeVarLong(b.longValue());
                        }
                    } else {
                        writeByte((byte) type);
                        writeVarInt(scale);
                        byte[] bytes = b.toByteArray();
                        writeVarInt(bytes.length);
                        write(bytes, 0, bytes.length);
                    }
                }
                break;
            }
        case Value.TIME:
            if (SysProperties.STORE_LOCAL_TIME) {
                writeByte((byte) LOCAL_TIME);
                ValueTime t = (ValueTime) v;
                long nanos = t.getNanos();
                long millis = nanos / 1000000;
                nanos -= millis * 1000000;
                writeVarLong(millis);
                writeVarLong(nanos);
            } else {
                writeByte((byte) type);
                writeVarLong(DateTimeUtils.getTimeLocalWithoutDst(v.getTime()));
            }
            break;
        case Value.DATE:
            {
                if (SysProperties.STORE_LOCAL_TIME) {
                    writeByte((byte) LOCAL_DATE);
                    long x = ((ValueDate) v).getDateValue();
                    writeVarLong(x);
                } else {
                    writeByte((byte) type);
                    long x = DateTimeUtils.getTimeLocalWithoutDst(v.getDate());
                    writeVarLong(x / MILLIS_PER_MINUTE);
                }
                break;
            }
        case Value.TIMESTAMP:
            {
                if (SysProperties.STORE_LOCAL_TIME) {
                    writeByte((byte) LOCAL_TIMESTAMP);
                    ValueTimestamp ts = (ValueTimestamp) v;
                    long dateValue = ts.getDateValue();
                    writeVarLong(dateValue);
                    long nanos = ts.getTimeNanos();
                    long millis = nanos / 1000000;
                    nanos -= millis * 1000000;
                    writeVarLong(millis);
                    writeVarLong(nanos);
                } else {
                    Timestamp ts = v.getTimestamp();
                    writeByte((byte) type);
                    writeVarLong(DateTimeUtils.getTimeLocalWithoutDst(ts));
                    writeVarInt(ts.getNanos());
                }
                break;
            }
        case Value.GEOMETRY:
        case Value.JAVA_OBJECT:
            {
                writeByte((byte) type);
                byte[] b = v.getBytesNoCopy();
                int len = b.length;
                writeVarInt(len);
                write(b, 0, len);
                break;
            }
        case Value.BYTES:
            {
                byte[] b = v.getBytesNoCopy();
                int len = b.length;
                if (len < 32) {
                    writeByte((byte) (BYTES_0_31 + len));
                    write(b, 0, len);
                } else {
                    writeByte((byte) type);
                    writeVarInt(len);
                    write(b, 0, len);
                }
                break;
            }
        case Value.UUID:
            {
                writeByte((byte) type);
                ValueUuid uuid = (ValueUuid) v;
                writeLong(uuid.getHigh());
                writeLong(uuid.getLow());
                break;
            }
        case Value.STRING:
            {
                String s = v.getString();
                int len = s.length();
                if (len < 32) {
                    writeByte((byte) (STRING_0_31 + len));
                    writeStringWithoutLength(s, len);
                } else {
                    writeByte((byte) type);
                    writeString(s);
                }
                break;
            }
        case Value.STRING_IGNORECASE:
        case Value.STRING_FIXED:
            writeByte((byte) type);
            writeString(v.getString());
            break;
        case Value.DOUBLE:
            {
                double x = v.getDouble();
                if (x == 1.0d) {
                    writeByte((byte) (DOUBLE_0_1 + 1));
                } else {
                    long d = Double.doubleToLongBits(x);
                    if (d == ValueDouble.ZERO_BITS) {
                        writeByte((byte) DOUBLE_0_1);
                    } else {
                        writeByte((byte) type);
                        writeVarLong(Long.reverse(d));
                    }
                }
                break;
            }
        case Value.FLOAT:
            {
                float x = v.getFloat();
                if (x == 1.0f) {
                    writeByte((byte) (FLOAT_0_1 + 1));
                } else {
                    int f = Float.floatToIntBits(x);
                    if (f == ValueFloat.ZERO_BITS) {
                        writeByte((byte) FLOAT_0_1);
                    } else {
                        writeByte((byte) type);
                        writeVarInt(Integer.reverse(f));
                    }
                }
                break;
            }
        case Value.BLOB:
        case Value.CLOB:
            {
                writeByte((byte) type);
                if (v instanceof ValueLob) {
                    ValueLob lob = (ValueLob) v;
                    lob.convertToFileIfRequired(handler);
                    byte[] small = lob.getSmall();
                    if (small == null) {
                        int t = -1;
                        if (!lob.isLinked()) {
                            t = -2;
                        }
                        writeVarInt(t);
                        writeVarInt(lob.getTableId());
                        writeVarInt(lob.getObjectId());
                        writeVarLong(lob.getPrecision());
                        writeByte((byte) (lob.isCompressed() ? 1 : 0));
                        if (t == -2) {
                            writeString(lob.getFileName());
                        }
                    } else {
                        writeVarInt(small.length);
                        write(small, 0, small.length);
                    }
                } else {
                    ValueLobDb lob = (ValueLobDb) v;
                    byte[] small = lob.getSmall();
                    if (small == null) {
                        writeVarInt(-3);
                        writeVarInt(lob.getTableId());
                        writeVarLong(lob.getLobId());
                        writeVarLong(lob.getPrecision());
                    } else {
                        writeVarInt(small.length);
                        write(small, 0, small.length);
                    }
                }
                break;
            }
        case Value.ARRAY:
            {
                writeByte((byte) type);
                Value[] list = ((ValueArray) v).getList();
                writeVarInt(list.length);
                for (Value x : list) {
                    writeValue(x);
                }
                break;
            }
        case Value.RESULT_SET:
            {
                writeByte((byte) type);
                try {
                    ResultSet rs = ((ValueResultSet) v).getResultSet();
                    rs.beforeFirst();
                    ResultSetMetaData meta = rs.getMetaData();
                    int columnCount = meta.getColumnCount();
                    writeVarInt(columnCount);
                    for (int i = 0; i < columnCount; i++) {
                        writeString(meta.getColumnName(i + 1));
                        writeVarInt(meta.getColumnType(i + 1));
                        writeVarInt(meta.getPrecision(i + 1));
                        writeVarInt(meta.getScale(i + 1));
                    }
                    while (rs.next()) {
                        writeByte((byte) 1);
                        for (int i = 0; i < columnCount; i++) {
                            int t = DataType.getValueTypeFromResultSet(meta, i + 1);
                            Value val = DataType.readValue(null, rs, i + 1, t);
                            writeValue(val);
                        }
                    }
                    writeByte((byte) 0);
                    rs.beforeFirst();
                } catch (SQLException e) {
                    throw DbException.convert(e);
                }
                break;
            }
        default:
            DbException.throwInternalError("String_Node_Str" + v.getType());
    }
    if (SysProperties.CHECK2) {
        if (pos - start != getValueLen(v, handler)) {
            throw DbException.throwInternalError("String_Node_Str" + (pos - start) + "String_Node_Str" + getValueLen(v, handler));
        }
    }
}

Output:
                     writeVarLong(DateTimeUtils.getTimeLocalWithoutDst(ts));
-                    writeVarInt(ts.getNanos());
+                    writeVarInt(ts.getNanos() % 1000000);
                 }


Input:
public void testArray() {
    Random rand = new Random();
    for (int x = 0; x < 16; x++) {
        for (int z = 0; z < 16; z++) {
            for (int y = 0; y < 16; y++) {
                short id = (short) (rand.nextInt());
                short data = (short) (((rand.nextInt() & 0x3) != 0) ? (0) : (rand.nextInt()));
                Integer auxData = (((rand.nextInt() & 0x3) != 0) ? (null) : (rand.nextInt()));
                set(x, y, z, id, data, auxData);
            }
        }
    }
    System.out.println("String_Node_Str");
    BlockFullState<Integer> fullData = new BlockFullState<Integer>();
    for (int x = 0; x < 16; x++) {
        for (int z = 0; z < 16; z++) {
            for (int y = 0; y < 16; y++) {
                check(x, y, z, fullData);
            }
        }
    }
    System.out.println("String_Node_Str");
    for (int i = 0; i < 16384; i++) {
        short id = (short) (rand.nextInt());
        short data = (short) (((rand.nextInt() & 0x3) != 0) ? (0) : (rand.nextInt()));
        Integer auxData = (((rand.nextInt() & 0x3) != 0) ? (null) : (rand.nextInt()));
        int x = rand.nextInt() & 0xF;
        int y = rand.nextInt() & 0xF;
        int z = rand.nextInt() & 0xF;
        set(x, y, z, id, data, auxData);
        check(x, y, z, fullData);
    }
    System.out.println("String_Node_Str");
    for (int x = 15; x >= 0; x--) {
        for (int y = 15; y >= 0; y--) {
            for (int z = 15; z >= 0; z--) {
                check(x, y, z, fullData);
            }
        }
    }
}

Output:
     System.out.println("String_Node_Str");
-    for (int i = 0; i < 16384; i++) {
+    for (int i = 0; i < 32768; i++) {
         short id = (short) (rand.nextInt());


Input:
public void run() {
    if (coopInviteList.containsKey(targetPlayerUUID) && inviteList.get(targetPlayerUUID).equals(playerUUID)) {
        inviteList.remove(targetPlayerUUID);
        if (plugin.getServer().getPlayer(playerUUID) != null) {
            Util.sendMessage(plugin.getServer().getPlayer(playerUUID), ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).inviteremovingInvite);
        }
        if (plugin.getServer().getPlayer(targetPlayerUUID) != null) {
            Util.sendMessage(plugin.getServer().getPlayer(targetPlayerUUID), ChatColor.YELLOW + plugin.myLocale(player.getUniqueId()).inviteremovingInvite);
        }
    }
}

Output:
 public void run() {
-    if (coopInviteList.containsKey(targetPlayerUUID) && inviteList.get(targetPlayerUUID).equals(playerUUID)) {
-        inviteList.remove(targetPlayerUUID);
+    if (coopInviteList.containsKey(targetPlayerUUID) && coopInviteList.get(targetPlayerUUID).equals(playerUUID)) {
+        coopInviteList.remove(targetPlayerUUID);
         if (plugin.getServer().getPlayer(playerUUID) != null) {


Input:
public List<waypoint> generate() {
    List<LatLng> polygonPoints = poly.getLatLngList();
    List<LineLatLng> circumscribedGrid = new Generator(polygonPoints, angle, lineDist).getGrid();
    List<LineLatLng> trimedGrid = new Trimmer(circumscribedGrid, polygonPoints).getTrimmedGrid();
    EndpointSorter gridSorter = new EndpointSorter(trimedGrid, lastLocation, altitude);
    gridSorter.sortGrid();
    gridPoints = gridSorter.getWaypoints();
    return gridPoints;
}

Output:
     List<LineLatLng> trimedGrid = new Trimmer(circumscribedGrid, polygonPoints).getTrimmedGrid();
-    EndpointSorter gridSorter = new EndpointSorter(trimedGrid, lastLocation, altitude);
-    gridSorter.sortGrid();
+    EndpointSorter gridSorter = new EndpointSorter(trimedGrid, altitude);
+    gridSorter.sortGrid(lastLocation);
     gridPoints = gridSorter.getWaypoints();


Input:
public void generateAnyObjectMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
    XMLAnyObjectMapping mapping = new XMLAnyObjectMapping();
    mapping.setAttributeName(property.getPropertyName());
    if (property.isMethodProperty()) {
        mapping.setGetMethodName(property.getGetMethodName());
        mapping.setSetMethodName(property.getSetMethodName());
    }
    mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
    descriptor.addMapping(mapping);
}

Output:
     }
-    mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
+    if (property.getType().getQualifiedName().equals("String_Node_Str")) {
+        mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT);
+    } else {
+        mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
+    }
     descriptor.addMapping(mapping);


Input:
static void processNodes(Element ele, Map cssStyles, IContent content, ActionContent action, int nestCount) {
    int level = 0;
    for (Node node = ele.getFirstChild(); node != null; node = node.getNextSibling()) {
        if (node.getNodeName().equals(TAG_VALUEOF)) {
            if (node.getFirstChild() instanceof Element) {
                processNodes((Element) node.getFirstChild(), cssStyles, content, action, nestCount);
            }
        } else if (node.getNodeName().equals(TAG_IMAGE)) {
            if (node.getFirstChild() instanceof Element) {
                processNodes((Element) node.getFirstChild(), cssStyles, content, action, nestCount);
            }
        } else if (node.getNodeName().equals(TAG_SCRIPT)) {
            continue;
        } else if (node.getNodeType() == Node.TEXT_NODE) {
            ILabelContent label = createLabel(node.getNodeValue(), content);
            if (action != null) {
                label.setHyperlinkAction(action);
            }
        } else if (node.getNodeType() == Node.ELEMENT_NODE) {
            handleElement((Element) node, cssStyles, content, action, ++level, nestCount);
        }
    }
}

Output:
         } else if (node.getNodeType() == Node.TEXT_NODE) {
-            ILabelContent label = createLabel(node.getNodeValue(), content);
-            if (action != null) {
-                label.setHyperlinkAction(action);
+            if (isInExcelMode) {
+                if (isFirst) {
+                    isFirst = false;
+                    builder.append(node.getNodeValue());
+                    ILabelContent label = createLabel(node.getNodeValue(), content);
+                    firstLabel = label;
+                    if (action != null) {
+                        label.setHyperlinkAction(action);
+                    }
+                } else {
+                    if (firstLabel != null) {
+                        firstLabel.setText(builder.append(node.getNodeValue()).toString());
+                        if (action != null) {
+                            firstLabel.setHyperlinkAction(action);
+                        }
+                    }
+                }
+            } else {
+                ILabelContent label = createLabel(node.getNodeValue(), content);
+                if (action != null) {
+                    label.setHyperlinkAction(action);
+                }
             }


Input:
private Sound transformSubsound(Sound[] subSound, int channelNum, int frequency, int length) {
    int percent = (int) (frequency * 100.0 / this.frequency);
    Sound result = subSound[channelNum];
    PitchSoundTransformation pitcher = new PitchSoundTransformation(percent);
    if (percent < 98 || percent > 102) {
        result = pitcher.transform(result);
    }
    double factor = subSound[0].getSamples().length == 0 ? 0 : length * 1.0 / result.getSamples().length;
    if (factor == 0) {
        return result;
    } else if (factor < 0.98 || factor > 1.02) {
        if (factor < 0.98) {
            SpeedUpSoundTransformation speedup = new SpeedUpSoundTransformation(100, (float) (1 / factor));
            result = speedup.transform(result);
        } else if (factor > 1.02) {
            SlowdownSoundTransformation slowdown = new SlowdownSoundTransformation(100, (float) factor);
            result = slowdown.transform(result);
        }
    }
    return result;
}

Output:
     int percent = (int) (frequency * 100.0 / this.frequency);
-    Sound result = subSound[channelNum];
+    Sound result = subSound[(subSound.length > channelNum ? channelNum : subSound.length - 1)];
     PitchSoundTransformation pitcher = new PitchSoundTransformation(percent);


Input:
public void writeStatement(MethodWriter writer) {
    if (this.value == null) {
        return;
    }
    if (this.instance != null) {
        this.instance.writeExpression(writer);
    }
    this.value.writeExpression(writer);
    this.field.writeSet(writer);
}

Output:
     }
-    if (this.instance != null) {
-        this.instance.writeExpression(writer);
-    }
-    this.value.writeExpression(writer);
-    this.field.writeSet(writer);
+    this.field.writeSet(writer, this.instance, this.value);
 }


Input:
protected void clearUp(ModelStep step) throws IOException {
    autoVarSelCondition();
    try {
        this.saveColumnConfigListAndColumnStats(true);
    } catch (Exception e) {
        throw new ShifuException(ShifuErrorCode.ERROR_WRITE_COLCONFIG, e);
    }
    this.syncDataToHdfs(this.modelConfig.getDataSet().getSource());
}

Output:
 protected void clearUp(ModelStep step) throws IOException {
-    autoVarSelCondition();
+    if (!isToReset) {
+        autoVarSelCondition();
+    }
     try {


Input:
private void expandReference(TreeReference sourceRef, AbstractTreeElement node, Vector<TreeReference> refs, boolean includeTemplates) {
    int depth = node.getDepth();
    Vector<XPathExpression> predicates = null;
    if (depth == sourceRef.size()) {
        refs.addElement(node.getRef());
    } else {
        String name = sourceRef.getName(depth);
        predicates = sourceRef.getPredicate(depth);
        int mult = sourceRef.getMultiplicity(depth);
        Vector<AbstractTreeElement> set = new Vector<AbstractTreeElement>();
        if (node.getNumChildren() > 0) {
            if (mult == TreeReference.INDEX_UNBOUND) {
                int count = node.getChildMultiplicity(name);
                for (int i = 0; i < count; i++) {
                    AbstractTreeElement child = node.getChild(name, i);
                    if (child != null) {
                        set.addElement(child);
                    } else {
                        throw new IllegalStateException();
                    }
                }
                if (includeTemplates) {
                    AbstractTreeElement template = node.getChild(name, TreeReference.INDEX_TEMPLATE);
                    if (template != null) {
                        set.addElement(template);
                    }
                }
            } else if (mult != TreeReference.INDEX_ATTRIBUTE) {
                AbstractTreeElement child = node.getChild(name, mult);
                if (child != null) {
                    set.addElement(child);
                }
            }
        }
        if (mult == TreeReference.INDEX_ATTRIBUTE) {
            AbstractTreeElement attribute = node.getAttribute(null, name);
            if (attribute != null) {
                set.addElement(attribute);
            }
        }
        for (Enumeration e = set.elements(); e.hasMoreElements(); ) {
            AbstractTreeElement treeElement = (AbstractTreeElement) e.nextElement();
            if (predicates != null) {
                TreeReference treeRef = treeElement.getRef();
                boolean passedAll = true;
                for (XPathExpression xpe : predicates) {
                    EvaluationContext evalContext = new EvaluationContext(this, treeRef);
                    Object o = xpe.eval(instance, evalContext);
                    if (o instanceof Boolean) {
                        boolean passed = ((Boolean) o).booleanValue();
                        if (!passed) {
                            passedAll = false;
                            break;
                        }
                    }
                }
                if (passedAll) {
                    expandReference(sourceRef, treeElement, refs, includeTemplates);
                }
            } else {
                expandReference(sourceRef, treeElement, refs, includeTemplates);
            }
        }
    }
}

Output:
         Vector<AbstractTreeElement> set = new Vector<AbstractTreeElement>();
-        if (node.getNumChildren() > 0) {
+        if (node.hasChildren()) {
             if (mult == TreeReference.INDEX_UNBOUND) {


Input:
public dItem getSpecialRecipeResult(ItemStack[] matrix) {
    master: for (Map.Entry<dItem, dList> entry : ItemScriptContainer.specialrecipesMap.entrySet()) {
        for (int n = 0; n < 9; n++) {
            dItem valueN = dItem.valueOf(entry.getValue().get(n));
            dItem matrixN = matrix[n] == null ? new dItem(Material.AIR) : new dItem(matrix[n].clone());
            valueN.setStackSize(1);
            matrixN.setStackSize(1);
            if (!valueN.identify().equals(matrixN.identify())) {
                continue master;
            }
        }
        return entry.getKey();
    }
    return null;
}

Output:
             dItem valueN = dItem.valueOf(entry.getValue().get(n));
-            dItem matrixN = matrix[n] == null ? new dItem(Material.AIR) : new dItem(matrix[n].clone());
+            dItem matrixN = matrix.length <= n || matrix[n] == null ? new dItem(Material.AIR) : new dItem(matrix[n].clone());
             valueN.setStackSize(1);


Input:
public boolean hasSourceObjectAbility(Game game, MageObject source, GameEvent event) {
    MageObject object = source;
    if (object == null) {
        object = game.getPermanentEntering(getSourceId());
        if (object == null) {
            object = game.getObject(getSourceId());
        }
    }
    if (object != null && !object.getAbilities().contains(this)) {
        if (object instanceof Permanent) {
            return false;
        } else {
            Abilities<Ability> otherAbilities = game.getState().getAllOtherAbilities(this.getSourceId());
            if (otherAbilities == null || !otherAbilities.contains(this)) {
                return false;
            }
        }
    }
    if (object instanceof Permanent) {
        return ((Permanent) object).isPhasedIn();
    }
    return true;
}

Output:
     }
-    if (object != null && !object.getAbilities().contains(this)) {
+    if (object != null) {
         if (object instanceof Permanent) {


Input:
public static void enableTool(PlayerSession session, Player player) {
    Inventory inv = player.getInventory();
    session.setUsingTool(true);
    ItemStack stack = BlockUtil.itemStringToStack(Config.ToolBlock, 1);
    if (!inv.contains(stack) && Config.GiveTool) {
        int first = inv.firstEmpty();
        if (first == -1)
            player.getWorld().dropItem(player.getLocation(), stack);
        else
            inv.setItem(first, stack);
    }
    if (player.getItemInHand().getType() != Material.LOG && inv.first(Material.LOG) != -1) {
        ItemStack back = player.getItemInHand().clone();
        int slot = inv.first(Material.LOG);
        player.setItemInHand(inv.getItem(inv.first(Material.LOG)));
        if (back.getAmount() == 0)
            inv.clear(slot);
        else
            inv.setItem(slot, back);
    }
    Util.sendMessage(player, "String_Node_Str");
}

Output:
     }
-    if (player.getItemInHand().getType() != Material.LOG && inv.first(Material.LOG) != -1) {
+    int first = inv.first(BlockUtil.getIdFromString(Config.ToolBlock));
+    if (!BlockUtil.getItemString(player.getItemInHand()).equals(Config.ToolBlock) && first != -1) {
         ItemStack back = player.getItemInHand().clone();


Input:
private void saveModifVariant(ProgramVariant variant) {
    modifModel.clear();
    for (CtType st : variant.getAffectedClasses()) {
        modifModel.put(st.getQualifiedName(), st.toString());
    }
}

Output:
     for (CtType st : variant.getAffectedClasses()) {
-        modifModel.put(st.getQualifiedName(), st.toString());
+        try {
+            modifModel.put(st.getQualifiedName(), st.toString());
+        } catch (Exception e) {
+            log.error("String_Node_Str" + st.getQualifiedName());
+        }
     }


Input:
public void execute(long t) {
    if (readData == CMD_MEASURE_TEMP) {
        output[0] = temp >> 8;
        output[1] = temp & 0xff;
    } else if (readData == CMD_MEASURE_HUM) {
        output[0] = humid >> 8;
        output[1] = humid & 0xff;
    } else {
        return;
    }
    int crc = 0;
    crc = crc8Add(crc, readData);
    crc = crc8Add(crc, output[0]);
    crc = crc8Add(crc, output[1]);
    if (DEBUG)
        System.out.println("String_Node_Str" + crc + "String_Node_Str" + rev8bits(crc));
    output[2] = rev8bits(crc);
    sdataPort.setPinState(sdataPin, IOPort.PIN_LOW);
    state = WRITE_BYTE;
    writeData = output[0];
    writePos = 0;
    writeLen = 3;
}

Output:
     if (readData == CMD_MEASURE_TEMP) {
-        output[0] = temp >> 8;
+        output[0] = (temp >> 8) & 0xff;
         output[1] = temp & 0xff;


Input:
public boolean reset() {
    this.duplicateValueCount = DUPLICATE_VALUE_COUNT_EDEFAULT;
    if (duplicateMap != null) {
        duplicateMap.clear();
    }
    duplicateMap = initValueForDBMap(StandardDBName.computeProcess.name());
    if (duplicateObjects != null) {
        duplicateObjects.clear();
    }
    duplicateObjects = initValueForDBSet(StandardDBName.computeProcessSet.name());
    return super.reset();
}

Output:
 public boolean reset() {
-    this.duplicateValueCount = DUPLICATE_VALUE_COUNT_EDEFAULT;
-    if (duplicateMap != null) {
-        duplicateMap.clear();
+    if (this.isUsedMapDBMode()) {
+        if (needReconnect((AbstractDB<?>) duplicateMap)) {
+            duplicateMap = initValueForDBMap(StandardDBName.computeProcess.name());
+            if (duplicateMap != null) {
+                duplicateMap.clear();
+            }
+        }
+        if (needReconnect((AbstractDB<?>) duplicateMap)) {
+            duplicateObjects = initValueForDBSet(StandardDBName.computeProcessSet.name());
+            if (duplicateObjects != null) {
+                duplicateObjects.clear();
+            }
+        }
     }