Input:
public synchronized static JDFeedMeConfig loadXML(String location) {
    Thread.currentThread().setContextClassLoader(JDUtilities.getJDClassLoader());
    Object loaded = JDIO.loadObject(JDUtilities.getResourceFile(location), true);
    if (loaded != null)
        return (JDFeedMeConfig) loaded;
    else
        return new JDFeedMeConfig();
}

Output:
     Thread.currentThread().setContextClassLoader(JDUtilities.getJDClassLoader());
-    Object loaded = JDIO.loadObject(JDUtilities.getResourceFile(location), true);
-    if (loaded != null)
-        return (JDFeedMeConfig) loaded;
-    else
-        return new JDFeedMeConfig();
+    File xmlFile = JDUtilities.getResourceFile(location);
+    if (xmlFile.exists()) {
+        Object loaded = JDIO.loadObject(xmlFile, true);
+        if (loaded != null)
+            return (JDFeedMeConfig) loaded;
+    }
+    return new JDFeedMeConfig();
 }


Input:
private void handleException(Exception ex) {
    LOG.warn("String_Node_Str" + tableName.getNamespaceAsString() + "String_Node_Str" + tableName.getNameAsString(), ex);
    if (ex instanceof IOException) {
        Thread.currentThread().interrupt();
    }
}

Output:
     LOG.warn("String_Node_Str" + tableName.getNamespaceAsString() + "String_Node_Str" + tableName.getNameAsString(), ex);
-    if (ex instanceof IOException) {
+    if (ex instanceof InterruptedException) {
         Thread.currentThread().interrupt();


Input:
private void initialiseInstanceDescriptor() {
    boolean liteMember = false;
    int hazelcastPort = 5900;
    if (hazelcast.isEnabled()) {
        instanceName = hazelcast.getMemberName();
        instanceGroup = hazelcast.getMemberGroup();
        myCurrentID = hazelcast.getUUID();
        liteMember = hazelcast.isLite();
        hazelcastPort = hazelcast.getPort();
    } else {
        instanceName = "String_Node_Str";
        instanceGroup = "String_Node_Str";
    }
    String instanceType = environment.getRuntimeType().toString();
    List<Integer> ports = new ArrayList<>();
    List<Integer> sslPorts = new ArrayList<>();
    int adminPort = 0;
    for (NetworkListener networkListener : context.getConfigBean().getConfig().getNetworkConfig().getNetworkListeners().getNetworkListener()) {
        if (Boolean.parseBoolean(networkListener.getEnabled())) {
            if (networkListener.findProtocol().getSecurityEnabled().equals("String_Node_Str")) {
                if (networkListener.getName().equals(context.getConfigBean().getConfig().getAdminListener().getName())) {
                    if (instanceType.equals("String_Node_Str")) {
                        ports.add(Integer.parseInt(networkListener.getPort()));
                    }
                    adminPort = Integer.parseInt(networkListener.getPort());
                } else {
                    ports.add(Integer.parseInt(networkListener.getPort()));
                }
            } else if (networkListener.findProtocol().getSecurityEnabled().equals("String_Node_Str")) {
                if (networkListener.getName().equals(context.getConfigBean().getConfig().getAdminListener().getName())) {
                    if (instanceType.equals("String_Node_Str")) {
                        ports.add(Integer.parseInt(networkListener.getPort()));
                    }
                    adminPort = Integer.parseInt(networkListener.getPort());
                } else {
                    sslPorts.add(Integer.parseInt(networkListener.getPort()));
                }
            }
        }
    }
    try {
        Collection<ApplicationDescriptor> deployedApplications = new ArrayList<>();
        if (me != null) {
            deployedApplications = me.getDeployedApplications();
        }
        me = new InstanceDescriptorImpl(myCurrentID);
        me.setInstanceName(instanceName);
        me.setInstanceGroup(instanceGroup);
        for (int port : ports) {
            me.addHttpPort(port);
        }
        for (int sslPort : sslPorts) {
            me.addHttpsPort(sslPort);
        }
        me.setAdminPort(adminPort);
        me.setHazelcastPort(hazelcastPort);
        me.setLiteMember(liteMember);
        me.setInstanceType(instanceType);
        if (!deployedApplications.isEmpty()) {
            for (ApplicationDescriptor application : deployedApplications) {
                me.addApplication(application);
            }
        }
        if (cluster.isEnabled()) {
            cluster.getClusteredStore().set(INSTANCE_STORE_NAME, myCurrentID, me);
        }
    } catch (UnknownHostException ex) {
        logger.log(Level.SEVERE, "String_Node_Str", ex);
    }
}

Output:
     } catch (UnknownHostException ex) {
-        logger.log(Level.SEVERE, "String_Node_Str", ex);
+        log.log(Level.SEVERE, "String_Node_Str", ex);
     }


Input:
protected void createPage2() {
    if (!GlobalServiceRegister.getDefault().isServiceRegistered(ICreateXtextProcessService.class)) {
        return;
    }
    String scriptValue = "String_Node_Str";
    try {
        IProject currentProject = ResourceModelUtils.getProject(ProjectManager.getInstance().getCurrentProject());
        String jobScriptVersion = "String_Node_Str";
        if (getEditorInput() != null && getEditorInput() instanceof RepositoryEditorInput) {
            Item item = ((RepositoryEditorInput) getEditorInput()).getItem();
            if (item != null) {
                Property property = item.getProperty();
                if (property != null) {
                    jobScriptVersion = "String_Node_Str" + property.getVersion();
                }
            }
        }
        IFile file = currentProject.getFolder("String_Node_Str").getFile(getEditorInput().getName() + jobScriptVersion + "String_Node_Str" + "String_Node_Str");
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(scriptValue.getBytes());
        if (file.exists()) {
            file.delete(true, null);
            file.create(byteArrayInputStream, true, null);
            file.setContents(byteArrayInputStream, 0, null);
        } else {
            file.create(byteArrayInputStream, true, null);
        }
        IEditorInput editorInput = new FileEditorInput(file);
        IEditorDescriptor desc = WorkbenchPlugin.getDefault().getEditorRegistry().findEditor("String_Node_Str");
        WorkbenchPage page = (WorkbenchPage) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
        EditorReference ref = new EditorReference(page.getEditorManager(), new FileEditorInput(file), (EditorDescriptor) desc);
        IEditorPart editorPart = ref.getEditor(true);
        if (editorPart != null) {
            int index = addPage(editorPart, editorInput);
            setPageText(index, "String_Node_Str");
        }
    } catch (PartInitException e) {
        ExceptionHandler.process(e);
    } catch (PersistenceException e) {
        ExceptionHandler.process(e);
    } catch (CoreException e) {
        ExceptionHandler.process(e);
    }
}

Output:
         IEditorInput editorInput = new FileEditorInput(file);
-        IEditorDescriptor desc = WorkbenchPlugin.getDefault().getEditorRegistry().findEditor("String_Node_Str");
-        WorkbenchPage page = (WorkbenchPage) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
-        EditorReference ref = new EditorReference(page.getEditorManager(), new FileEditorInput(file), (EditorDescriptor) desc);
-        IEditorPart editorPart = ref.getEditor(true);
-        if (editorPart != null) {
-            int index = addPage(editorPart, editorInput);
-            setPageText(index, "String_Node_Str");
+        IExtensionPoint ep = RegistryFactory.getRegistry().getExtensionPoint("String_Node_Str");
+        IExtension[] extensions = ep.getExtensions();
+        IExtension ex;
+        IConfigurationElement confElem = null;
+        for (int i = 0; i < extensions.length; i++) {
+            ex = extensions[i];
+            if (ex.getContributor().getName().equals("String_Node_Str")) {
+                for (IConfigurationElement c : ex.getConfigurationElements()) {
+                    if (c.getName().equals("String_Node_Str") && c.getAttribute("String_Node_Str").equals(pointId)) {
+                        confElem = c;
+                        break;
+                    }
+                }
+            }
+        }
+        if (confElem != null) {
+            TextEditor editor = (TextEditor) confElem.createExecutableExtension("String_Node_Str");
+            if (editor != null) {
+                int index = addPage(editor, editorInput);
+                setPageText(index, "String_Node_Str");
+            }
         }


Input:
public VisitStatus acceptASTNode(ASTNode node, TypeLookupResult result, IJavaElement enclosingElement) {
    if (result.declaringType == null) {
        return VisitStatus.CONTINUE;
    }
    boolean isConstructorCall = false;
    boolean isDeclaration = (node instanceof MethodNode);
    int start = 0;
    int end = 0;
    if (result.declaration instanceof MethodNode) {
        if (methodName.equals(((MethodNode) result.declaration).getName())) {
            if (isDeclaration) {
                start = ((MethodNode) node).getNameStart();
                end = ((MethodNode) node).getNameEnd() + 1;
            } else if (node.getText().equals(methodName)) {
                start = node.getStart();
                end = node.getEnd();
            } else if (node instanceof StaticMethodCallExpression && node.getText().contains("String_Node_Str" + methodName + "String_Node_Str")) {
                start = ((StaticMethodCallExpression) node).getStart();
                end = start + methodName.length();
            }
        }
    }
    if (end > 0) {
        Position position = new Position(start, end - start);
        if (!acceptedPositions.contains(position)) {
            if (nameAndArgsMatch(GroovyUtils.getBaseType(result.declaringType), isDeclaration ? GroovyUtils.getParameterTypes(((MethodNode) node).getParameters()) : result.scope.getMethodCallArgumentTypes())) {
                if (enclosingElement.getOpenable() instanceof GroovyClassFileWorkingCopy) {
                    enclosingElement = ((GroovyClassFileWorkingCopy) enclosingElement.getOpenable()).convertToBinary(enclosingElement);
                }
                SearchMatch match = null;
                if (isDeclaration && findDeclarations) {
                    match = new MethodDeclarationMatch(enclosingElement, getAccuracy(result.confidence), start, end - start, participant, enclosingElement.getResource());
                } else if (!isDeclaration && findReferences) {
                    match = new MethodReferenceMatch(enclosingElement, getAccuracy(result.confidence), start, end - start, isConstructorCall, false, false, false, participant, enclosingElement.getResource());
                }
                if (match != null) {
                    try {
                        acceptedPositions.add(position);
                        requestor.acceptSearchMatch(match);
                    } catch (Exception e) {
                        Util.log(e, "String_Node_Str" + enclosingElement + "String_Node_Str" + enclosingElement.getResource());
                    }
                }
            }
        }
    }
    return VisitStatus.CONTINUE;
}

Output:
         if (methodName.equals(((MethodNode) result.declaration).getName())) {
-            if (isDeclaration) {
-                start = ((MethodNode) node).getNameStart();
-                end = ((MethodNode) node).getNameEnd() + 1;
-            } else if (node.getText().equals(methodName)) {
-                start = node.getStart();
-                end = node.getEnd();
-            } else if (node instanceof StaticMethodCallExpression && node.getText().contains("String_Node_Str" + methodName + "String_Node_Str")) {
-                start = ((StaticMethodCallExpression) node).getStart();
-                end = start + methodName.length();
+            if (isDeclaration || node instanceof StaticMethodCallExpression) {
+                start = ((AnnotatedNode) node).getNameStart();
+                end = ((AnnotatedNode) node).getNameEnd() + 1;
+            } else {
+                String text = node.getText();
+                if (methodName.equals(text) || result.declaringType.getField(text) != null) {
+                    start = node.getStart();
+                    end = node.getEnd();
+                }
             }


Input:
public void load(Class<?> mainModule) {
    try {
        if (log.isDebugEnabled())
            log.debug("String_Node_Str");
        IocBy ib = mainModule.getAnnotation(IocBy.class);
        SetupBy sb = mainModule.getAnnotation(SetupBy.class);
        Views vms = mainModule.getAnnotation(Views.class);
        Localization lc = mainModule.getAnnotation(Localization.class);
        if (null != ib) {
            if (log.isDebugEnabled())
                log.debugf("String_Node_Str", ib.type().getName());
            ioc = ib.type().newInstance().create(config, ib.args());
            config.getServletContext().setAttribute(Ioc.class.getName(), ioc);
        } else if (log.isDebugEnabled()) {
            log.debug("String_Node_Str");
        }
        ArrayList<ViewMaker> makers = new ArrayList<ViewMaker>();
        makers.add(new DefaultViewMaker());
        if (null != vms)
            for (Class<? extends ViewMaker> type : vms.value()) makers.add(type.newInstance());
        if (log.isDebugEnabled())
            log.debugf("String_Node_Str", mainModule.getName());
        urls = new UrlMapImpl(ioc, context);
        urls.setOk(mainModule.getAnnotation(Ok.class));
        urls.setFail(mainModule.getAnnotation(Fail.class));
        urls.setAdaptBy(mainModule.getAnnotation(AdaptBy.class));
        urls.setFilters(mainModule.getAnnotation(Filters.class));
        urls.setEncoding(mainModule.getAnnotation(Encoding.class));
        urls.add(makers, mainModule);
        Modules modules = mainModule.getAnnotation(Modules.class);
        if (null != modules)
            for (Class<?> module : modules.value()) {
                if (log.isDebugEnabled())
                    log.debugf("String_Node_Str", module.getName());
                urls.add(makers, module);
            }
        config.getServletContext().setAttribute(UrlMap.class.getName(), urls);
        if (null != lc) {
            if (log.isDebugEnabled())
                log.debugf("String_Node_Str", lc.value());
            msgss = Mirror.me(lc.type()).born(lc.value()).load();
        } else if (log.isDebugEnabled())
            log.debug("String_Node_Str");
        if (null != sb) {
            if (log.isInfoEnabled())
                log.info("String_Node_Str");
            Setup setup = sb.value().newInstance();
            config.getServletContext().setAttribute(Setup.class.getName(), setup);
            setup.init(config);
        }
    } catch (InstantiationException e) {
        throw Lang.wrapThrow(e);
    } catch (IllegalAccessException e) {
        throw Lang.wrapThrow(e);
    }
}

Output:
         Modules modules = mainModule.getAnnotation(Modules.class);
-        if (null != modules)
+        if (null != modules) {
             for (Class<?> module : modules.value()) {


Input:
public <T extends ConfigBeanProxy> NotProcessed changed(TYPE type, Class<T> changedType, T changedInstance) {
    NotProcessed np = null;
    switch(type) {
        case CHANGE:
            if (logger.isLoggable(Level.FINE)) {
                logger.fine("String_Node_Str" + changedType.getName() + "String_Node_Str" + changedInstance);
            }
            np = handleChangeEvent(changedInstance);
            break;
        default:
    }
    return np;
}

Output:
             if (logger.isLoggable(Level.FINE)) {
-                logger.fine("String_Node_Str" + changedType.getName() + "String_Node_Str" + changedInstance);
+                logger.fine(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", changedType.getName(), changedInstance));
             }


Input:
public int[] getColumnBreaks() {
    if (columnBreaks == null) {
        return new int[0];
    }
    int[] arr = new int[] { columnBreaks.size() };
    Iterator<Integer> iter = columnBreaks.iterator();
    for (int i = 0; i < arr.length; i++) {
        arr[i] = iter.next();
    }
    return arr;
}

Output:
     }
-    int[] arr = new int[] { columnBreaks.size() };
+    int[] arr = new int[columnBreaks.size()];
     Iterator<Integer> iter = columnBreaks.iterator();


Input:
public final void run() {
    if (callback != null) {
        callback.httpRequestStarted(apiRequestObject);
    }
    connectionTimeout = httpPeriProcessor.getConnectionTimeout();
    readTimeout = httpPeriProcessor.getReadTimeout();
    doRequest();
    if (httpPreProcessor != null) {
        httpPreProcessor.processApiRequestObject(apiRequestObject);
    }
    sendApiErrorIfExists();
    if (httpPostProcessor != null) {
        httpPostProcessor.processApiRequestObject(apiRequestObject);
    }
    if (callback != null) {
        callback.httpRequestFinished(apiRequestObject);
    }
}

Output:
 public final void run() {
-    if (callback != null) {
-        callback.httpRequestStarted(apiRequestObject);
-    }
-    connectionTimeout = httpPeriProcessor.getConnectionTimeout();
-    readTimeout = httpPeriProcessor.getReadTimeout();
+    notifyHttpRequestStarted();
+    setTimeouts();
+    doPreProcess();
     doRequest();


Input:
public void onUpdate() {
    if (this.setNormalExplode) {
        this.normalExplode();
        return;
    }
    if (this.setExplode) {
        this.explode();
        return;
    }
    super.onUpdate();
    try {
        if (this.worldObj.isRemote) {
            this.ticksInAir = this.dataWatcher.getWatchableObjectInt(16);
        } else {
            this.dataWatcher.updateObject(16, this.ticksInAir);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    if (this.ticksInAir >= 0) {
        System.out.println(this.chunkCoordX + "String_Node_Str" + this.chunkCoordZ);
        if (!this.worldObj.isRemote) {
            if (this.isCruise) {
                if (this.ticksInAir == 0) {
                    this.motionX = this.xDifference / (flightTime * 0.5);
                    this.motionY = this.yDifference / (flightTime * 0.5);
                    this.motionZ = this.zDifference / (flightTime * 0.5);
                }
                this.rotationPitch = (float) (Math.atan(this.motionY / (Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ))) * 180 / Math.PI);
                this.rotationYaw = (float) (Math.atan2(this.motionX, this.motionZ) * 180 / Math.PI);
                DaoDan.list[this.missileID].onTickFlight(this);
                this.noClip = false;
                this.moveEntity(this.motionX, this.motionY, this.motionZ);
                Vector3 position = Vector3.get(this);
                if ((this.isCollided && this.ticksInAir >= 20) || this.ticksInAir > 20 * 600) {
                    this.explode();
                }
            } else {
                if (this.ticksInAir < 20) {
                    this.motionY = this.launchAcceleration * this.ticksInAir * (this.ticksInAir / 2);
                    this.moveEntity(this.motionX, this.motionY, this.motionZ);
                } else if (this.ticksInAir == 20) {
                    this.motionY = this.acceleration * (this.flightTime / 2);
                    this.motionX = this.xDifference / flightTime;
                    this.motionZ = this.zDifference / flightTime;
                } else {
                    Vector3 currentPosition = new Vector3(this.posX, this.posY, this.posZ);
                    double currentDistance = Vector2.distance(currentPosition.toVector2(), this.muBiao.toVector2());
                    this.motionY -= this.acceleration;
                    this.rotationPitch = (float) (Math.atan(this.motionY / (Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ))) * 180 / Math.PI);
                    this.rotationYaw = (float) (Math.atan2(this.motionX, this.motionZ) * 180 / Math.PI);
                    DaoDan.list[this.missileID].onTickFlight(this);
                    this.moveEntity(this.motionX, this.motionY, this.motionZ);
                    this.lastTickPosX = this.posX;
                    this.lastTickPosY = this.posY;
                    this.lastTickPosZ = this.posZ;
                    if (this.isCollided) {
                        this.explode();
                    }
                    if (heightBeforeHit > 0 && this.motionY < 0) {
                        int blockBelowID = this.worldObj.getBlockId((int) this.posX, (int) this.posY - heightBeforeHit, (int) this.posZ);
                        if (blockBelowID > 0) {
                            heightBeforeHit = 0;
                            this.explode();
                        }
                    }
                }
            }
        }
        this.spawnMissileSmoke();
        this.protectionTime--;
        this.ticksInAir++;
    } else {
        if (this.missileLauncherPosition == null) {
            this.setDead();
            return;
        }
        TileEntity tileEntity = this.worldObj.getBlockTileEntity((int) missileLauncherPosition.x, (int) missileLauncherPosition.y, (int) missileLauncherPosition.z);
        if (tileEntity == null) {
            this.setDead();
            return;
        }
        if (tileEntity.isInvalid()) {
            this.setDead();
            return;
        }
        if (tileEntity instanceof TFaSheDi) {
            if (((TFaSheDi) tileEntity).eDaoDan == null) {
                ((TFaSheDi) tileEntity).eDaoDan = this;
            }
        } else if (tileEntity instanceof TXiaoFaSheQi) {
            if (((TXiaoFaSheQi) tileEntity).containingMissile == null) {
                ((TXiaoFaSheQi) tileEntity).containingMissile = this;
            }
            this.isCruise = true;
            this.noClip = true;
            this.xDifference = ((TXiaoFaSheQi) tileEntity).getTarget().x - this.startingPosition.x;
            this.yDifference = ((TXiaoFaSheQi) tileEntity).getTarget().y - this.startingPosition.y;
            this.zDifference = ((TXiaoFaSheQi) tileEntity).getTarget().z - this.startingPosition.z;
            this.flatDistance = Vector2.distance(this.startingPosition.toVector2(), ((TXiaoFaSheQi) tileEntity).getTarget().toVector2());
            this.skyLimit = 150 + (int) (this.flatDistance * 1.8);
            this.flightTime = (float) Math.max(100, 2.4 * flatDistance);
            this.acceleration = (float) skyLimit * 2 / (flightTime * flightTime);
            this.motionX = this.xDifference / (flightTime * 0.6);
            this.motionY = this.yDifference / (flightTime * 0.6);
            this.motionZ = this.zDifference / (flightTime * 0.6);
            float newRotationPitch = (float) (Math.atan(this.motionY / (Math.sqrt(this.motionX * this.motionX + this.motionZ * this.motionZ))) * 180 / Math.PI);
            float newRotationYaw = (float) (Math.atan2(this.motionX, this.motionZ) * 180 / Math.PI);
            if (newRotationYaw - this.rotationYaw != 0) {
                this.rotationYaw += (newRotationYaw - this.rotationYaw) * 0.1;
            }
            if (newRotationPitch - this.rotationPitch != 0) {
                this.rotationPitch += (newRotationPitch - this.rotationPitch) * 0.1;
            }
        }
    }
}

Output:
     if (this.ticksInAir >= 0) {
-        System.out.println(this.chunkCoordX + "String_Node_Str" + this.chunkCoordZ);
+        this.updateLoadChunk();
         if (!this.worldObj.isRemote) {


Input:
private boolean checkPage(SpaceContentEntityObject page) {
    if (page == null) {
        return false;
    }
    List<String> spaceKeys = pluginSettingsManager.getAllowedConfluenceSpaceKeysAsList();
    if (spaceKeys == null || spaceKeys.isEmpty()) {
        return true;
    }
    for (String spaceKey : spaceKeys) {
        if (page.getSpaceKey().equals(spaceKey)) {
            return true;
        }
    }
    return false;
}

Output:
     for (String spaceKey : spaceKeys) {
-        if (page.getSpaceKey().equals(spaceKey)) {
+        if (pageSpaceKey.equals(spaceKey)) {
             return true;


Input:
public E take(final K name) {
    final E oldItem = nameTable.remove(name);
    if (oldItem == null) {
        return null;
    }
    final int expectedLevel = getLevel(oldItem);
    if (!levelEmpty[expectedLevel]) {
        if (level[expectedLevel].remove(oldItem)) {
            removeMass(oldItem);
            return oldItem;
        }
    }
    for (int l = 0; l < levels; l++) {
        if ((!levelEmpty[l]) && (l != expectedLevel)) {
            if (level[l].remove(oldItem)) {
                removeMass(oldItem);
                return oldItem;
            }
        }
    }
    if (MiscFlags.DEBUG) {
        final int ns = nameTable.size();
        final int is = sizeItems();
        if (ns == is)
            return null;
        throw new IllegalStateException("String_Node_Str" + nameTable.size() + "String_Node_Str" + sizeItems() + "String_Node_Str" + oldItem + "String_Node_Str" + this.getClass().getSimpleName());
    }
    return oldItem;
}

Output:
     final int expectedLevel = getLevel(oldItem);
-    if (!levelEmpty[expectedLevel]) {
+    if (!levelEmpty(expectedLevel)) {
         if (level[expectedLevel].remove(oldItem)) {


Input:
public void set(T t, int time) {
    this.desiredValue = typeConverter.copyFromObject(t, desiredValue);
    this.totalTime = time;
    if (currentValue != null) {
        this.startValue = currentValue;
        this.currentValue = null;
    }
    this.currentTime = 0;
    if (time == 0)
        this.currentValue = interpolator.interpolate(startValue, desiredValue, 1f);
}

Output:
     this.totalTime = time;
-    if (currentValue != null) {
-        this.startValue = currentValue;
-        this.currentValue = null;
-    }
+    if (currentValue != null)
+        copyArray(startValue, currentValue);
     this.currentTime = 0;


Input:
public void drawText(String text, float textX, float textY, float width, float height, FontInfo fontInfo, Color color) {
    BaseFont baseFont = fontInfo.getBaseFont();
    String fontName = getFontName(baseFont);
    String red = Integer.toHexString(color.getRed());
    String green = Integer.toHexString(color.getGreen());
    String blue = Integer.toHexString(color.getBlue());
    red = red.length() == 1 ? "String_Node_Str" + red : red;
    green = green.length() == 1 ? "String_Node_Str" + green : green;
    blue = blue.length() == 1 ? "String_Node_Str" + blue : blue;
    println("String_Node_Str" + (++shapeCount) + "String_Node_Str");
    println("String_Node_Str" + textX + "String_Node_Str" + textY + "String_Node_Str" + width + "String_Node_Str" + height + "String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str" + shapeCount + "String_Node_Str");
    println("String_Node_Str" + 0 + "String_Node_Str" + "String_Node_Str" + fontName + "String_Node_Str" + fontInfo.getFontSize() + "String_Node_Str" + red + green + blue + "String_Node_Str");
    boolean isItalic = fontInfo != null && (fontInfo.getFontStyle() & Font.ITALIC) != 0;
    boolean isBold = fontInfo != null && (fontInfo.getFontStyle() & Font.BOLD) != 0;
    if (isItalic) {
        print("String_Node_Str");
    }
    if (isBold) {
        print("String_Node_Str");
    }
    print(getEscapedStr(text));
    if (isBold) {
        print("String_Node_Str");
    }
    if (isItalic) {
        print("String_Node_Str");
    }
    println("String_Node_Str");
    println("String_Node_Str");
}

Output:
     println("String_Node_Str" + shapeCount + "String_Node_Str");
-    println("String_Node_Str" + 0 + "String_Node_Str" + "String_Node_Str" + fontName + "String_Node_Str" + fontInfo.getFontSize() + "String_Node_Str" + red + green + blue + "String_Node_Str");
+    println("String_Node_Str" + 0 + "String_Node_Str" + "String_Node_Str" + fontName + "String_Node_Str" + fontInfo.getFontSize() + "String_Node_Str" + getColorString(color) + "String_Node_Str");
     boolean isItalic = fontInfo != null && (fontInfo.getFontStyle() & Font.ITALIC) != 0;


Input:
public void prepareExecution(FieldSelector selector, Map<Integer, List<Conversion<String, ?>>> conversionsByIndex, String[] values) {
    if (conversionsMap == null) {
        return;
    }
    Conversion<String, ?>[] conversions = conversionsMap.get(selector);
    if (conversions == null) {
        return;
    }
    int[] fieldIndexes = selector.getFieldIndexes(values);
    for (int fieldIndex : fieldIndexes) {
        List<Conversion<String, ?>> conversionsAtIndex = conversionsByIndex.get(fieldIndex);
        if (conversionsAtIndex == null) {
            conversionsAtIndex = new ArrayList<Conversion<String, ?>>();
            conversionsByIndex.put(fieldIndex, conversionsAtIndex);
        }
        validateDuplicates(selector, conversionsAtIndex, conversions);
        conversionsAtIndex.addAll(Arrays.asList(conversions));
    }
}

Output:
     for (int fieldIndex : fieldIndexes) {
-        List<Conversion<String, ?>> conversionsAtIndex = conversionsByIndex.get(fieldIndex);
+        List<Conversion<?, ?>> conversionsAtIndex = conversionsByIndex.get(fieldIndex);
         if (conversionsAtIndex == null) {


Input:
public static String[] tokenize(String input) throws NoSuchVerseException {
    String[] args = { null, null, null, null, null, null, null, null };
    int length = input.length();
    char[] normalized = new char[length * 2];
    char lastChar = '0';
    char curChar = ' ';
    int tokenCount = 0;
    int normalizedLength = 0;
    int startIndex = 0;
    String token = null;
    boolean foundBoundary = false;
    for (int i = 0; i < length; i++) {
        curChar = input.charAt(i);
        boolean charIsDigit = curChar == '$' || Character.isDigit(curChar) || (curChar == 'f' && (i + 1 < length ? input.charAt(i + 1) : ' ') == 'f');
        if (charIsDigit || Character.isLetter(curChar)) {
            foundBoundary = true;
            boolean charWasDigit = lastChar == '$' || Character.isDigit(lastChar) || (lastChar == 'f' && (i > 2 ? input.charAt(i - 2) : '0') == 'f');
            if (charWasDigit || Character.isLetter(lastChar)) {
                foundBoundary = false;
                if (normalizedLength > 0 && charWasDigit != charIsDigit) {
                    foundBoundary = true;
                }
            }
            if (foundBoundary) {
                if (charIsDigit) {
                    if (tokenCount >= args.length) {
                        throw new NoSuchVerseException(Msg.VERSE_PARTS, new Object[] { input });
                    }
                    token = new String(normalized, startIndex, normalizedLength - startIndex);
                    args[tokenCount++] = token;
                    normalizedLength = 0;
                } else {
                    normalized[normalizedLength++] = ' ';
                }
            }
            normalized[normalizedLength++] = curChar;
        }
        if (normalizedLength > 0) {
            lastChar = curChar;
        }
    }
    if (tokenCount >= args.length) {
        throw new NoSuchVerseException(Msg.VERSE_PARTS, new Object[] { input });
    }
    token = new String(normalized, startIndex, normalizedLength - startIndex);
    args[tokenCount++] = token;
    String[] results = new String[tokenCount];
    System.arraycopy(args, 0, results, 0, tokenCount);
    return results;
}

Output:
         curChar = input.charAt(i);
-        boolean charIsDigit = curChar == '$' || Character.isDigit(curChar) || (curChar == 'f' && (i + 1 < length ? input.charAt(i + 1) : ' ') == 'f');
+        boolean charIsDigit = curChar == '$' || Character.isDigit(curChar) || (curChar == 'f' && (i + 1 < length ? input.charAt(i + 1) : ' ') == 'f' && !Character.isLetter(lastChar));
         if (charIsDigit || Character.isLetter(curChar)) {


Input:
public static boolean doSupportSecurity(String hiveDistribution, String hiveVersion, String hiveMode, String hiveServerVersion, boolean byDisplay) {
    HiveModeInfo hiveModeInfo = byDisplay ? HiveModeInfo.getByDisplay(hiveMode) : HiveModeInfo.get(hiveMode);
    HiveServerVersionInfo hiveServerVersionInfo = byDisplay ? HiveServerVersionInfo.getByDisplay(hiveServerVersion) : HiveServerVersionInfo.valueOf(hiveServerVersion);
    boolean supportSecurity = doSupportMethod(hiveDistribution, hiveVersion, byDisplay, "String_Node_Str");
    if (supportSecurity && (HiveServerVersionInfo.HIVE_SERVER_2 == hiveServerVersionInfo || hiveModeInfo == HiveModeInfo.EMBEDDED)) {
        return true;
    }
    return false;
}

Output:
     HiveModeInfo hiveModeInfo = byDisplay ? HiveModeInfo.getByDisplay(hiveMode) : HiveModeInfo.get(hiveMode);
-    HiveServerVersionInfo hiveServerVersionInfo = byDisplay ? HiveServerVersionInfo.getByDisplay(hiveServerVersion) : HiveServerVersionInfo.valueOf(hiveServerVersion);
+    HiveServerVersionInfo hiveServerVersionInfo = byDisplay ? HiveServerVersionInfo.getByDisplay(hiveServerVersion) : HiveServerVersionInfo.getByKey(hiveServerVersion);
     boolean supportSecurity = doSupportMethod(hiveDistribution, hiveVersion, byDisplay, "String_Node_Str");


Input:
private void traverse(Node node) {
    if (!shouldVisit(node)) {
        return;
    }
    int visits = 0;
    do {
        for (Node c = node.getFirstChild(); c != null; c = c.getNext()) {
            traverse(c);
        }
        visit(node);
        visits++;
        Preconditions.checkState(visits < 10000, "String_Node_Str");
    } while (shouldRetraverse(node));
    exitNode(node);
}

Output:
     do {
-        for (Node c = node.getFirstChild(); c != null; c = c.getNext()) {
+        Node c = node.getFirstChild();
+        while (c != null) {
+            Node next = c.getNext();
             traverse(c);


Input:
private int dispatchPointer(QueuedEvent qev, MotionEvent ev, int pid, int uid) {
    if (DEBUG_INPUT || WindowManagerPolicy.WATCH_POINTER)
        Log.v(TAG, "String_Node_Str" + ev);
    Object targetObj = mKeyWaiter.waitForNextEventTarget(null, qev, ev, true, false);
    int action = ev.getAction();
    if (action == MotionEvent.ACTION_UP) {
        mKeyWaiter.mMotionTarget = null;
        mPowerManager.logPointerUpEvent();
    } else if (action == MotionEvent.ACTION_DOWN) {
        mPowerManager.logPointerDownEvent();
    }
    if (targetObj == null) {
        if (action != MotionEvent.ACTION_MOVE) {
            Log.w(TAG, "String_Node_Str" + ev.getAction());
        }
        if (qev != null) {
            mQueue.recycleEvent(qev);
        }
        ev.recycle();
        return INJECT_FAILED;
    }
    if (targetObj == mKeyWaiter.CONSUMED_EVENT_TOKEN) {
        if (qev != null) {
            mQueue.recycleEvent(qev);
        }
        ev.recycle();
        return INJECT_SUCCEEDED;
    }
    WindowState target = (WindowState) targetObj;
    final long eventTime = ev.getEventTime();
    if (uid != 0 && uid != target.mSession.mUid) {
        if (mContext.checkPermission(android.Manifest.permission.INJECT_EVENTS, pid, uid) != PackageManager.PERMISSION_GRANTED) {
            Log.w(TAG, "String_Node_Str" + pid + "String_Node_Str" + uid + "String_Node_Str" + target + "String_Node_Str" + target.mSession.mUid);
            if (qev != null) {
                mQueue.recycleEvent(qev);
            }
            ev.recycle();
            return INJECT_NO_PERMISSION;
        }
    }
    if ((target.mAttrs.flags & WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES) != 0) {
        boolean cheekPress = mPolicy.isCheekPressedAgainstScreen(ev);
        boolean returnFlag = false;
        if ((action == MotionEvent.ACTION_DOWN)) {
            mFatTouch = false;
            if (cheekPress) {
                mFatTouch = true;
                returnFlag = true;
            }
        } else {
            if (action == MotionEvent.ACTION_UP) {
                if (mFatTouch) {
                    mFatTouch = false;
                    returnFlag = true;
                } else if (cheekPress) {
                    ev.setAction(MotionEvent.ACTION_CANCEL);
                    action = MotionEvent.ACTION_CANCEL;
                }
            } else if (action == MotionEvent.ACTION_MOVE) {
                if (mFatTouch) {
                    returnFlag = true;
                } else if (cheekPress) {
                    ev.setAction(MotionEvent.ACTION_CANCEL);
                    action = MotionEvent.ACTION_CANCEL;
                    if (DEBUG_INPUT)
                        Log.v(TAG, "String_Node_Str");
                    mFatTouch = true;
                }
            }
        }
        if (returnFlag) {
            if (qev != null) {
                mQueue.recycleEvent(qev);
            }
            ev.recycle();
            return INJECT_FAILED;
        }
    }
    if (action == MotionEvent.ACTION_DOWN) {
        int max_events_per_sec = 35;
        try {
            max_events_per_sec = Integer.parseInt(SystemProperties.get("String_Node_Str"));
            if (max_events_per_sec < 1) {
                max_events_per_sec = 35;
            }
        } catch (NumberFormatException e) {
        }
        mMinWaitTimeBetweenTouchEvents = 1000 / max_events_per_sec;
    }
    if (action == MotionEvent.ACTION_MOVE) {
        long nextEventTime = mLastTouchEventTime + mMinWaitTimeBetweenTouchEvents;
        long now = SystemClock.uptimeMillis();
        if (now < nextEventTime) {
            try {
                Thread.sleep(nextEventTime - now);
            } catch (InterruptedException e) {
            }
            mLastTouchEventTime = nextEventTime;
        } else {
            mLastTouchEventTime = now;
        }
    }
    synchronized (mWindowMap) {
        if (qev != null && action == MotionEvent.ACTION_MOVE) {
            mKeyWaiter.bindTargetWindowLocked(target, KeyWaiter.RETURN_PENDING_POINTER, qev);
            ev = null;
        } else {
            if (action == MotionEvent.ACTION_DOWN) {
                WindowState out = mKeyWaiter.mOutsideTouchTargets;
                if (out != null) {
                    MotionEvent oev = MotionEvent.obtain(ev);
                    oev.setAction(MotionEvent.ACTION_OUTSIDE);
                    do {
                        final Rect frame = out.mFrame;
                        oev.offsetLocation(-(float) frame.left, -(float) frame.top);
                        try {
                            out.mClient.dispatchPointer(oev, eventTime);
                        } catch (android.os.RemoteException e) {
                            Log.i(TAG, "String_Node_Str" + out);
                        }
                        oev.offsetLocation((float) frame.left, (float) frame.top);
                        out = out.mNextOutsideTouch;
                    } while (out != null);
                    mKeyWaiter.mOutsideTouchTargets = null;
                }
            }
            final Rect frame = target.mFrame;
            ev.offsetLocation(-(float) frame.left, -(float) frame.top);
            mKeyWaiter.bindTargetWindowLocked(target);
        }
    }
    try {
        if (DEBUG_INPUT || DEBUG_FOCUS || WindowManagerPolicy.WATCH_POINTER) {
            Log.v(TAG, "String_Node_Str" + qev + "String_Node_Str" + target);
        }
        target.mClient.dispatchPointer(ev, eventTime);
        return INJECT_SUCCEEDED;
    } catch (android.os.RemoteException e) {
        Log.i(TAG, "String_Node_Str" + target);
        mKeyWaiter.mMotionTarget = null;
        try {
            removeWindow(target.mSession, target.mClient);
        } catch (java.util.NoSuchElementException ex) {
        }
    }
    return INJECT_FAILED;
}

Output:
         Log.v(TAG, "String_Node_Str" + ev);
-    Object targetObj = mKeyWaiter.waitForNextEventTarget(null, qev, ev, true, false);
+    Object targetObj = mKeyWaiter.waitForNextEventTarget(null, qev, ev, true, false, pid, uid);
     int action = ev.getAction();


Input:
public final static List readList(DataInputStream dis) throws IOException {
    if (readInt(dis) == TYPE_NULL)
        return null;
    List dataList = new ArrayList();
    int size = readInt(dis);
    if (size == 0)
        return dataList;
    for (int i = 0; i < size; i++) dataList.add(readObject(dis));
    return dataList;
}

Output:
         return dataList;
-    for (int i = 0; i < size; i++) dataList.add(readObject(dis));
+    for (int i = 0; i < size; i++) dataList.add(readObject(dis, classLoader));
     return dataList;


Input:
public Object apply(INDArray from, Object value, int i) {
    Object curr = getFromOrigin(from, i);
    double originValue = (double) (curr instanceof IComplexNDArray ? ((IComplexNumber) curr).absoluteValue() : (double) curr);
    double otherValue = (double) (value instanceof IComplexNDArray ? ((IComplexNumber) value).absoluteValue() : (double) value);
    if (originValue < otherValue) {
        if (value instanceof IComplexNumber)
            return Nd4j.createDouble(1, 0);
        else
            return 1;
    } else {
        if (value instanceof IComplexNDArray)
            return Nd4j.createDouble(0, 0);
        else
            return 0;
    }
}

Output:
     Object curr = getFromOrigin(from, i);
-    double originValue = (double) (curr instanceof IComplexNDArray ? ((IComplexNumber) curr).absoluteValue() : (double) curr);
-    double otherValue = (double) (value instanceof IComplexNDArray ? ((IComplexNumber) value).absoluteValue() : (double) value);
+    double originValue = (curr instanceof IComplexNDArray ? ((IComplexNumber) curr).absoluteValue().doubleValue() : (double) curr);
+    double otherValue = (value instanceof IComplexNDArray ? ((IComplexNumber) value).absoluteValue().doubleValue() : (double) value);
     if (originValue < otherValue) {


Input:
public void start(IReportContent report) {
    logger.log(Level.FINE, "String_Node_Str");
    this.report = report;
    writer.open(out, "String_Node_Str");
    if (htmlRtLFlag) {
        String reportStyleName = report == null ? null : report.getDesign().getRootStyleName();
        if (reportStyleName != null) {
            IStyle style = report.findStyle(reportStyleName);
            if (null != style) {
                style.setProperty(IStyle.STYLE_TEXT_ALIGN, IStyle.RIGHT_VALUE);
            }
        }
    }
    if (null == layoutPreference) {
        if (report != null) {
            Report reportDesign = report.getDesign();
            ReportDesignHandle designHandle = reportDesign.getReportDesign();
            String reportLayoutPreference = designHandle.getLayoutPreference();
            if (DesignChoiceConstants.REPORT_LAYOUT_PREFERENCE_FIXED_LAYOUT.equals(reportLayoutPreference)) {
                layoutPreference = HTMLRenderOption.LAYOUT_PREFERENCE_FIXED;
            } else if (DesignChoiceConstants.REPORT_LAYOUT_PREFERENCE_AUTO_LAYOUT.equals(reportLayoutPreference)) {
                layoutPreference = HTMLRenderOption.LAYOUT_PREFERENCE_AUTO;
            }
        }
    }
    if (enableAgentStyleEngine) {
        htmlEmitter = new HTMLPerformanceOptimize(this, writer, isEmbeddable, layoutPreference);
    } else {
        htmlEmitter = new HTMLVisionOptimize(this, writer, isEmbeddable, layoutPreference);
    }
    StringBuffer defaultStyleBuffer = new StringBuffer();
    if (report != null) {
        String reportStyleName = report.getDesign().getRootStyleName();
        if (reportStyleName != null) {
            IStyle style = report.findStyle(reportStyleName);
            htmlEmitter.buildDefaultStyle(defaultStyleBuffer, style);
        }
    }
    if (isEmbeddable) {
        fixTransparentPNG();
        fixRedirect();
        writer.openTag(HTMLTags.TAG_DIV);
        writer.attribute(HTMLTags.ATTR_STYLE, defaultStyleBuffer.toString());
        return;
    }
    writer.startWriter();
    writer.openTag(HTMLTags.TAG_HTML);
    writer.openTag(HTMLTags.TAG_HEAD);
    Report reportDesign = null;
    if (report != null) {
        reportDesign = report.getDesign();
        ReportDesignHandle designHandle = reportDesign.getReportDesign();
        String title = designHandle.getStringProperty(IModuleModel.TITLE_PROP);
        if (title == null) {
            if (renderOption != null) {
                HTMLRenderOption htmlOption = new HTMLRenderOption(renderOption);
                title = htmlOption.getHtmlTitle();
            }
        }
        if (title != null) {
            writer.openTag(HTMLTags.TAG_TITLE);
            writer.text(title);
            writer.closeTag(HTMLTags.TAG_TITLE);
        }
    }
    writer.openTag(HTMLTags.TAG_META);
    writer.attribute(HTMLTags.ATTR_HTTP_EQUIV, "String_Node_Str");
    writer.attribute(HTMLTags.ATTR_CONTENT, "String_Node_Str");
    writer.closeTag(HTMLTags.TAG_META);
    writer.openTag(HTMLTags.TAG_STYLE);
    writer.attribute(HTMLTags.ATTR_TYPE, "String_Node_Str");
    IStyle style;
    StringBuffer styleBuffer = new StringBuffer();
    String defaultStyleName = "String_Node_Str";
    if (report == null) {
        logger.log(Level.WARNING, "String_Node_Str");
    } else {
        writer.style('.' + defaultStyleName, defaultStyleBuffer.toString());
        Map styles = reportDesign.getStyles();
        Iterator iter = styles.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            String styleName = (String) entry.getKey();
            style = (IStyle) entry.getValue();
            styleBuffer.setLength(0);
            htmlEmitter.buildStyle(styleBuffer, style);
            if (styleBuffer.length() > 0) {
                writer.style('.' + styleName, styleBuffer.toString());
                outputtedStyles.add(styleName);
            }
        }
    }
    writer.closeTag(HTMLTags.TAG_STYLE);
    fixTransparentPNG();
    fixRedirect();
    writer.closeTag(HTMLTags.TAG_HEAD);
    writer.openTag(HTMLTags.TAG_BODY);
    if (defaultStyleBuffer.length() > 0) {
        writer.attribute(HTMLTags.ATTR_CLASS, defaultStyleName);
    }
    if (outputMasterPageContent) {
        writer.attribute(HTMLTags.ATTR_STYLE, "String_Node_Str");
    }
}

Output:
     if (null == layoutPreference) {
-        if (report != null) {
-            Report reportDesign = report.getDesign();
-            ReportDesignHandle designHandle = reportDesign.getReportDesign();
+        if (designHandle != null) {
             String reportLayoutPreference = designHandle.getLayoutPreference();


Input:
public int compare(InstituteStats inst1, InstituteStats inst2) {
    return Integer.valueOf(inst2.studentTotal).compareTo(Integer.valueOf(inst1.studentTotal));
}

Output:
 public int compare(InstituteStats inst1, InstituteStats inst2) {
-    return Integer.valueOf(inst2.studentTotal).compareTo(Integer.valueOf(inst1.studentTotal));
+    return Integer.compare(inst2.studentTotal, inst1.studentTotal);
 }


Input:
private void parseAttributes(AttributeSet attrs) {
    TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.CropImageView);
    final int crop = a.getInt(R.styleable.CropImageView_crop, CropType.NONE.getCrop());
    if (crop >= 0) {
        setScaleType(ScaleType.MATRIX);
        this.cropType = CropType.get(crop);
    }
    a.recycle();
}

Output:
 private void parseAttributes(AttributeSet attrs) {
-    TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.CropImageView);
+    final TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.CropImageView);
     final int crop = a.getInt(R.styleable.CropImageView_crop, CropType.NONE.getCrop());


Input:
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
    if (sender instanceof Player) {
        if (args.length == 0) {
            try {
                return commandMap.get("String_Node_Str").execute(plugin.wrapPlayer((Player) sender), args);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (args[0] == null) {
            api.getLogger().severe("String_Node_Str");
            return false;
        }
        PlotCommand _command = commandMap.get(args[0]);
        if (_command == null) {
            sender.sendMessage("String_Node_Str");
            return true;
        } else {
            try {
                return _command.execute(new BukkitPlayer((Player) sender), args);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    } else {
        return handleConsoleCommands(sender, args);
    }
    return false;
}

Output:
         if (args.length == 0) {
-            try {
-                return commandMap.get("String_Node_Str").execute(plugin.wrapPlayer((Player) sender), args);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
+            return commandMap.get("String_Node_Str").execute(plugin.wrapPlayer((Player) sender), args);
         }


Input:
public static int getCurrentFolding() {
    return currentFolding == 0 ? FOLDING_1 : currentFolding;
}

Output:
 public static int getCurrentFolding() {
-    return currentFolding == 0 ? FOLDING_1 : currentFolding;
+    int sectionFoldState = ResourcesPlugin.getPlugin().getPluginPreferences().getInt(EDITOR_MASTER_PAGE_FOLDING);
+    if (currentFolding == 0 && sectionFoldState != 0) {
+        currentFolding = sectionFoldState;
+    }
+    if (currentFolding == 0 && sectionFoldState == 0) {
+        currentFolding = FOLDING_1;
+    }
+    return currentFolding;
 }


Input:
private void showAgainAllHiddenCards() {
    cardsHidden.clear();
    draftPicks.loadCards(CardsViewUtil.convertSimple(pickedCards), bigCard, null);
}

Output:
     cardsHidden.clear();
-    draftPicks.loadCards(CardsViewUtil.convertSimple(pickedCards), bigCard, null);
+    draftPicks.loadCards(CardsViewUtil.convertSimple(pickedCardsShown), bigCard, null);
 }


Input:
public void addValue(double[] x) {
    Matrix point = doubleArrayToMatrix(x);
    points.add(point);
    if (points.size() > 100) {
        points.remove(0);
    }
    if (dimSet == false)
        initCovariance(x.length);
}

Output:
 public void addValue(double[] x) {
-    Matrix point = doubleArrayToMatrix(x);
-    points.add(point);
-    if (points.size() > 100) {
-        points.remove(0);
-    }
-    if (dimSet == false)
-        initCovariance(x.length);
+    points.add(x);
 }


Input:
private void setIndexLocation(File aFile) throws IOException {
    if (luceneIndexHandler != null) {
        shutdown();
    }
    luceneIndexHandler = new LuceneIndexHandler(aFile);
}

Output:
     }
-    luceneIndexHandler = new LuceneIndexHandler(aFile);
+    AnalyzerCache theCache = new AnalyzerCache(aConfiguration);
+    luceneIndexHandler = new LuceneIndexHandler(aConfiguration.getIndexDirectory(), theCache);
 }


Input:
public void handle(ParserContext parserContext, String attributeKey, String attributeValue, T view) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
        view.setAllCaps(ParseHelper.parseBoolean(attributeValue));
    }
}

Output:
 public void handle(ParserContext parserContext, String attributeKey, String attributeValue, T view) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
-        view.setAllCaps(ParseHelper.parseBoolean(attributeValue));
-    }
+    view.setHint(attributeValue);
 }


Input:
public void widgetSelected(final SelectionEvent e) {
    final ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), new WorkbenchLabelProvider(), new WorkbenchContentProvider());
    dialog.setInput(ResourcesPlugin.getWorkspace().getRoot());
    dialog.setTitle(LaunchMessages.getString(BROWSE_WORKSPACE_DIALOG_TITLE));
    dialog.setComparator(new ResourceComparator(ResourceComparator.NAME));
    dialog.setAllowMultiple(false);
    dialog.setValidator(new ISelectionStatusValidator() {
        public IStatus validate(Object[] selection) {
            if (selection.length == 1 && expectedType.isAssignableFrom(selection[0].getClass())) {
                return new Status(IStatus.OK, Activator.PLUGIN_ID, null);
            }
            return new Status(IStatus.ERROR, Activator.PLUGIN_ID, null);
        }
    });
    if (dialog.open() == IDialogConstants.OK_ID) {
        final IResource selection = (IResource) dialog.getFirstResult();
        pathText.setText(selection.getFullPath().toOSString());
        workspaceRelativePath.set(true);
    }
}

Output:
         pathText.setText(selection.getFullPath().toOSString());
-        workspaceRelativePath.set(true);
+        buildContextPathWorkspaceRelative = true;
     }


Input:
public void advanceStart(String vmUuid, Map<VirtualMachineProfile.Param, Object> params, DeploymentPlan planToDeploy, DeploymentPlanner planner) throws InsufficientCapacityException, ConcurrentOperationException, ResourceUnavailableException {
    AsyncJobExecutionContext jobContext = AsyncJobExecutionContext.getCurrentExecutionContext();
    if (!VmJobEnabled.value() || jobContext.isJobDispatchedBy(VmWorkConstants.VM_WORK_JOB_DISPATCHER)) {
        VmWorkJobVO placeHolder = null;
        if (VmJobEnabled.value()) {
            VirtualMachine vm = _vmDao.findByUuid(vmUuid);
            placeHolder = createPlaceHolderWork(vm.getId());
        }
        try {
            orchestrateStart(vmUuid, params, planToDeploy, planner);
        } finally {
            if (VmJobEnabled.value())
                _workJobDao.expunge(placeHolder.getId());
        }
    } else {
        Outcome<VirtualMachine> outcome = startVmThroughJobQueue(vmUuid, params, planToDeploy, planner);
        try {
            VirtualMachine vm = outcome.get();
        } catch (InterruptedException e) {
            throw new RuntimeException("String_Node_Str", e);
        } catch (java.util.concurrent.ExecutionException e) {
            throw new RuntimeException("String_Node_Str", e);
        }
        Object jobResult = _jobMgr.unmarshallResultObject(outcome.getJob());
        if (jobResult != null) {
            if (jobResult instanceof ConcurrentOperationException)
                throw (ConcurrentOperationException) jobResult;
            else if (jobResult instanceof ResourceUnavailableException)
                throw (ResourceUnavailableException) jobResult;
            else if (jobResult instanceof InsufficientCapacityException)
                throw (InsufficientCapacityException) jobResult;
            else if (jobResult instanceof RuntimeException)
                throw (RuntimeException) jobResult;
            else if (jobResult instanceof Throwable)
                throw new RuntimeException("String_Node_Str", (Throwable) jobResult);
        }
    }
}

Output:
         } finally {
-            if (VmJobEnabled.value())
+            if (placeHolder != null) {
                 _workJobDao.expunge(placeHolder.getId());


Input:
public static <T> ResponseWrapper<T> errorReturn(Status status, String... msgs) {
    String msg;
    if (msgs.length == 0) {
        msg = String.format(status.getMsg(), msgs);
    } else {
        msg = status.getMsg();
    }
    return new ResponseWrapper<T>(status.getCode(), msg);
}

Output:
     String msg;
-    if (msgs.length == 0) {
+    if (msgs.length > 0) {
         msg = String.format(status.getMsg(), msgs);


Input:
public void testInterceptSuccessForm() throws Exception {
    isInterceptedMethod = true;
    hamClass = FORM_CLASS;
    ltci.setMPP(mpp);
    Object expect = AuthenticationStatus.SUCCESS;
    Properties props = new Properties();
    String storedReq = "String_Node_Str";
    String requestUrl = "String_Node_Str";
    withInvocationContext(expect).withParams().withReferrer().withGetURL(storedReq, requestUrl);
    assertEquals("String_Node_Str", expect, ltci.intercept(icm));
}

Output:
     String requestUrl = "String_Node_Str";
-    withInvocationContext(expect).withParams().withReferrer().withGetURL(storedReq, requestUrl);
+    withInvocationContext(expect).withParams().withReferrer().withGetURL(storedReq, requestUrl).withAuthParams();
     assertEquals("String_Node_Str", expect, ltci.intercept(icm));


Input:
private void loadColumnsBasedOnSchema(Node nc, EList listParamType) {
    List<IMetadataTable> metadataList = nc.getMetadataList();
    if (listParamType == null || metadataList == null || metadataList.size() == 0) {
        return;
    }
    List<IMetadataColumn> listColumns = metadataList.get(0).getListColumns();
    if (listColumns == null) {
        return;
    }
    for (IElementParameter parameter : nc.getElementParameters()) {
        if (EParameterFieldType.TABLE.equals(parameter.getFieldType()) && parameter.isColumnsBasedOnSchema()) {
            String[] listItemsDisplayValue = new String[listColumns.size()];
            String[] listItemsDisplayCodeValue = new String[listColumns.size()];
            Object[] listItemsValue = new Object[listColumns.size()];
            ElementParameter newParam = null;
            for (int i = 0; i < listColumns.size(); i++) {
                IMetadataColumn column = listColumns.get(i);
                listItemsDisplayCodeValue[i] = column.getLabel();
                listItemsDisplayValue[i] = column.getLabel();
                newParam = new ElementParameter(nc);
                newParam.setName(column.getLabel());
                newParam.setDisplayName("String_Node_Str");
                newParam.setFieldType(EParameterFieldType.TEXT);
                newParam.setValue("String_Node_Str");
                listItemsValue[i] = newParam;
            }
            parameter.setListItemsDisplayName(listItemsDisplayValue);
            parameter.setListItemsDisplayCodeName(listItemsDisplayCodeValue);
            parameter.setListItemsValue(listItemsValue);
            for (int j = 0; j < listParamType.size(); j++) {
                ElementParameterType pType = (ElementParameterType) listParamType.get(j);
                if (pType != null) {
                    if (parameter.getFieldType().getName().equals(pType.getField()) && parameter.getName().equals(pType.getName())) {
                        List<Map<String, Object>> tableValues = new ArrayList<Map<String, Object>>();
                        String[] codeList = parameter.getListItemsDisplayCodeName();
                        Map<String, Object> lineValues = null;
                        for (ElementValueType elementValue : (List<ElementValueType>) pType.getElementValue()) {
                            boolean found = false;
                            for (int i = 0; i < codeList.length && !found; i++) {
                                if (codeList[i].equals(elementValue.getElementRef())) {
                                    found = true;
                                }
                            }
                            if (found) {
                                if ((lineValues == null) || (lineValues.get(elementValue.getElementRef()) != null)) {
                                    lineValues = new HashMap<String, Object>();
                                    tableValues.add(lineValues);
                                }
                                lineValues.put(elementValue.getElementRef(), elementValue.getValue());
                                if (elementValue.getType() != null) {
                                    lineValues.put(elementValue.getElementRef() + IEbcdicConstant.REF_TYPE, elementValue.getType());
                                }
                            }
                        }
                        for (Map<String, Object> line : tableValues) {
                            for (int i = 0; i < codeList.length; i++) {
                                if (!line.containsKey(codeList[i])) {
                                    IElementParameter itemParam = (IElementParameter) parameter.getListItemsValue()[i];
                                    line.put(codeList[i], itemParam.getValue());
                                }
                            }
                        }
                        nc.setPropertyValue(pType.getName(), tableValues);
                    }
                }
            }
        }
    }
}

Output:
                 if (pType != null) {
-                    if (parameter.getFieldType().getName().equals(pType.getField()) && parameter.getName().equals(pType.getName())) {
+                    if (parameter.getName().equals(pType.getName())) {
                         List<Map<String, Object>> tableValues = new ArrayList<Map<String, Object>>();


Input:
protected static double calculateDistance(int txPower, double rssi) {
    if (rssi == 0) {
        return -1.0;
    }
    BeaconManager.logDebug(TAG, "String_Node_Str" + rssi + "String_Node_Str" + txPower);
    double ratio = rssi * 1.0 / txPower;
    double distance;
    if (ratio < 1.0) {
        distance = Math.pow(ratio, 10);
    } else {
        distance = (0.42093) * Math.pow(ratio, 6.9476) + 0.54992;
        BeaconManager.logDebug(TAG, "String_Node_Str" + rssi + "String_Node_Str" + distance);
    }
    BeaconManager.logDebug(TAG, "String_Node_Str" + rssi + "String_Node_Str" + distance);
    return distance;
}

Output:
     } else {
-        distance = (0.42093) * Math.pow(ratio, 6.9476) + 0.54992;
-        BeaconManager.logDebug(TAG, "String_Node_Str" + rssi + "String_Node_Str" + distance);
+        Log.e(TAG, "String_Node_Str");
+        return -1.0;
     }


Input:
public void testCursorModel6() throws OLAPException, BirtException {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(CubeUtility.cubeName);
    cqd.createMeasure("String_Node_Str");
    IEdgeDefinition columnEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim = columnEdge.createDimension("String_Node_Str");
    IHierarchyDefinition dimHier = dim.createHierarchy("String_Node_Str");
    dimHier.createLevel("String_Node_Str");
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.COLUMN_EDGE);
    IDimensionDefinition geographyDim = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier = geographyDim.createHierarchy("String_Node_Str");
    geographyHier.createLevel("String_Node_Str");
    IDimensionDefinition geographyDim3 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition geographyHier3 = geographyDim3.createHierarchy("String_Node_Str");
    geographyHier3.createLevel("String_Node_Str");
    IBinding rowGrandTotal = new Binding("String_Node_Str");
    rowGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    rowGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    rowGrandTotal.addAggregateOn("String_Node_Str");
    IBinding columnGrandTotal = new Binding("String_Node_Str");
    columnGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_AVE_FUNC);
    columnGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    IBinding totalGrandTotal = new Binding("String_Node_Str");
    totalGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_COUNTDISTINCT_FUNC);
    totalGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    cqd.addBinding(rowGrandTotal);
    cqd.addBinding(columnGrandTotal);
    cqd.addBinding(totalGrandTotal);
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    List rowEdgeBindingNames = new ArrayList();
    rowEdgeBindingNames.add("String_Node_Str");
    List measureBindingNames = new ArrayList();
    measureBindingNames.add("String_Node_Str");
    List rowGrandTotalNames = new ArrayList();
    rowGrandTotalNames.add("String_Node_Str");
    try {
        testOut.print(creator.printCubeAlongEdge(dataCursor, columnEdgeBindingNames, rowEdgeBindingNames, measureBindingNames, rowGrandTotalNames, "String_Node_Str", "String_Node_Str", null));
        this.checkOutputFile();
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube, false);
     List columnEdgeBindingNames = new ArrayList();


Input:
public void removeMembershipListener(MembershipListener listener) {
    Set<MembershipListener> oldListeners = listeners.get();
    if (oldListeners == null || oldListeners.size() == 0)
        return;
    int size = oldListeners.size() - 1;
    Set<MembershipListener> newListeners = new LinkedHashSet<MembershipListener>(size);
    for (MembershipListener existingListener : oldListeners) {
        if (existingListener.equals(listener))
            newListeners.add(existingListener);
    }
    listeners.set(newListeners);
}

Output:
     for (MembershipListener existingListener : oldListeners) {
-        if (existingListener.equals(listener))
+        if (!existingListener.equals(listener)) {
             newListeners.add(existingListener);


Input:
protected void subscribeActual(MaybeObserver<? super T> observer) {
    AtomicBoolean disposed = new AtomicBoolean();
    observer.onSubscribe(new Disposable() {
        public void dispose() {
            disposed.set(true);
        }
        public boolean isDisposed() {
            return disposed.get();
        }
    });
    if (!disposed.get()) {
        method.handle(ar -> {
            if (!disposed.getAndSet(false)) {
                if (ar.succeeded()) {
                    try {
                        T val = ar.result();
                        if (val != null) {
                            observer.onSuccess(val);
                        } else {
                            observer.onComplete();
                        }
                    } catch (Throwable ignore) {
                    }
                } else if (ar.failed()) {
                    try {
                        observer.onError(ar.cause());
                    } catch (Throwable ignore) {
                    }
                }
            }
        });
    }
}

Output:
         method.handle(ar -> {
-            if (!disposed.getAndSet(false)) {
+            if (!disposed.getAndSet(true)) {
                 if (ar.succeeded()) {


Input:
public boolean startCompany(String playerName, StartCompany action) {
    PublicCompanyI company = action.getCertificate().getCompany();
    int price = action.getPrice();
    int shares = action.getNumberBought();
    String errMsg = null;
    StockSpaceI startSpace = null;
    int numberOfCertsToBuy = 0;
    PublicCertificateI cert = null;
    String companyName = company.getName();
    currentPlayer = getCurrentPlayer();
    while (true) {
        if (!playerName.equals(currentPlayer.getName())) {
            errMsg = LocalText.getText("String_Node_Str", playerName);
            break;
        }
        if (companyBoughtThisTurnWrapper.getObject() != null) {
            errMsg = LocalText.getText("String_Node_Str", playerName);
            break;
        }
        if (company == null) {
            errMsg = LocalText.getText("String_Node_Str", companyName);
            break;
        }
        if (company.hasStarted()) {
            errMsg = LocalText.getText("String_Node_Str", companyName);
            break;
        }
        cert = ipo.findCertificate(company, true);
        if (shares < cert.getShares())
            shares = cert.getShares();
        numberOfCertsToBuy = shares - (cert.getShares() - 1);
        if (!mayPlayerBuyCertificate(currentPlayer, company, numberOfCertsToBuy)) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        startSpace = company.getStartSpace();
        if (startSpace != null) {
            price = startSpace.getPrice();
        } else {
            if ((startSpace = stockMarket.getStartSpace(price)) == null) {
                errMsg = LocalText.getText("String_Node_Str", Bank.format(price), company.getName());
                break;
            }
        }
        if (currentPlayer.getCash() < shares * price) {
            errMsg = LocalText.getText("String_Node_Str");
            break;
        }
        break;
    }
    if (errMsg != null) {
        DisplayBuffer.add(LocalText.getText("String_Node_Str", playerName, companyName, Bank.format(price), errMsg));
        return false;
    }
    moveStack.start(true);
    company.start(startSpace);
    CashHolder priceRecipient = getSharePriceRecipient(cert, price);
    executeTradeCertificate(cert, currentPlayer.getPortfolio(), price * cert.getShares(), priceRecipient);
    for (int i = 1; i < numberOfCertsToBuy; i++) {
        cert = ipo.findCertificate(company, false);
        executeTradeCertificate(cert, currentPlayer.getPortfolio(), company.getIPOPrice(), priceRecipient);
    }
    ReportBuffer.add(LocalText.getText("String_Node_Str", playerName, companyName, Bank.format(price), Bank.format(shares * price), shares, cert.getShare(), priceRecipient.getName()));
    ReportBuffer.getAllWaiting();
    checkFlotation(company);
    companyBoughtThisTurnWrapper.set(company);
    hasActed.set(true);
    setPriority();
    gameSpecificChecks(ipo, company);
    return true;
}

Output:
         }
-        if (currentPlayer.getCash() < shares * price) {
+        cost = shares * price;
+        if (currentPlayer.getCash() < cost) {
             errMsg = LocalText.getText("String_Node_Str");


Input:
public void execute(Runnable runnable) {
    try {
        reentrantLock.lock();
        while (threadAlive >= threadNum) {
            try {
                condition.await();
            } catch (InterruptedException e) {
            }
        }
        threadAlive++;
        System.out.println(threadAlive);
        executorService.execute(runnable);
    } finally {
        threadAlive--;
        condition.signal();
        reentrantLock.unlock();
    }
}

Output:
     try {
-        reentrantLock.lock();
-        while (threadAlive >= threadNum) {
-            try {
-                condition.await();
-            } catch (InterruptedException e) {
+        if (threadAlive.get() >= threadNum) {
+            reentrantLock.lock();
+            while (threadAlive.get() >= threadNum) {
+                try {
+                    condition.await();
+                } catch (InterruptedException e) {
+                }
             }


Input:
private StandardJavaFileManager getFileManager() {
    if (fileManager == null) {
        fileManager = getJavaCompiler().getStandardFileManager(diagnosticListener, locale, charset);
        try {
            fileManager.setLocation(StandardLocation.CLASS_PATH, classPathLoader.getFiles());
            Iterable<File> outputFolders = outputFolder.getFolders();
            if (null != outputFolders) {
                Iterable<File> existedFolders = Iterables.filter(outputFolders, new Predicate<File>() {
                    public boolean apply(File input) {
                        return input.exists();
                    }
                });
                if (existedFolders.iterator().hasNext()) {
                    fileManager.setLocation(StandardLocation.SOURCE_OUTPUT, outputFolders);
                }
            }
            fileManager.setLocation(StandardLocation.SOURCE_PATH, sourceFolders.getFolders());
        } catch (IOException e) {
            throw new CdkException("String_Node_Str", e);
        }
    }
    return fileManager;
}

Output:
     if (fileManager == null) {
-        fileManager = getJavaCompiler().getStandardFileManager(diagnosticListener, locale, charset);
+        fileManager = getJavaCompiler().getStandardFileManager(new DiagnosticListenerImplementation(log, locale), locale, charset);
         try {


Input:
public synchronized void shutdown() throws GlassFishException {
    for (Object gf : gfMap.values()) {
        try {
            ((GlassFish) gf).dispose();
        } catch (IllegalStateException ex) {
        }
    }
    gfMap.clear();
    try {
        shutdownInternal();
    } catch (GlassFishException ex) {
        logger.info(ex.getMessage());
    }
}

Output:
     } catch (GlassFishException ex) {
-        logger.info(ex.getMessage());
+        logger.log(Level.WARNING, LogFacade.CAUGHT_EXCEPTION, ex.getMessage());
     }


Input:
protected MessagesComposite createMessagesComposite() {
    return new MessagesWithActionComposite(getComposite(), SWT.NONE);
}

Output:
 protected MessagesComposite createMessagesComposite() {
-    return new MessagesWithActionComposite(getComposite(), SWT.NONE);
+    MessagesWithActionComposite messagesComposite = new MessagesWithActionComposite(getComposite(), SWT.NONE) {
+        protected void changeBackgroundColor(int status) {
+            switch(status) {
+                case IStatus.WARNING:
+                    CoreUIPlugin.setCSSId(this, CSS_MESSAGES_WITH_ACTION_COMPOSITE_WARN);
+                    break;
+                case IStatus.ERROR:
+                    CoreUIPlugin.setCSSId(this, CSS_MESSAGES_WITH_ACTION_COMPOSITE_ERROR);
+                    break;
+                default:
+            }
+        }
+    };
+    CoreUIPlugin.setCSSClass(messagesComposite, MessagesWithActionComposite.class.getSimpleName());
+    return messagesComposite;
 }


Input:
public void initializeModule(Map properties) throws SemanticException {
    if (isInitialized)
        return;
    String name = null;
    Object value = null;
    Module root = (Module) getElement();
    Set propNames = properties.keySet();
    Iterator itre = propNames.iterator();
    while (itre.hasNext()) {
        name = (String) itre.next();
        value = PropertyValueValidationUtil.validateProperty(this, name, properties.get(name));
        root.setProperty(name, value);
    }
    isInitialized = true;
}

Output:
         name = (String) itre.next();
-        value = PropertyValueValidationUtil.validateProperty(this, name, properties.get(name));
-        root.setProperty(name, value);
+        try {
+            value = PropertyValueValidationUtil.validateProperty(this, name, properties.get(name));
+            root.setProperty(name, value);
+        } catch (SemanticException e) {
+        }
     }


Input:
public void addMana(Mana mana, Game game, Ability source) {
    if (mana instanceof ConditionalMana) {
        this.manaItems.add(new ManaPoolItem((ConditionalMana) mana, source.getSourceId()));
    } else {
        this.manaItems.add(new ManaPoolItem(mana.getRed(), mana.getGreen(), mana.getBlue(), mana.getWhite(), mana.getBlack(), mana.getColorless(), source.getSourceId()));
    }
    GameEvent event = GameEvent.getEvent(GameEvent.EventType.MANA_ADDED, source.getSourceId(), source.getId(), source.getControllerId());
    event.setData(mana.toString());
    game.fireEvent(event);
}

Output:
     } else {
-        this.manaItems.add(new ManaPoolItem(mana.getRed(), mana.getGreen(), mana.getBlue(), mana.getWhite(), mana.getBlack(), mana.getColorless(), source.getSourceId()));
+        this.manaItems.add(new ManaPoolItem(mana.getRed(), mana.getGreen(), mana.getBlue(), mana.getWhite(), mana.getBlack(), mana.getColorless(), source.getSourceId(), mana.getFlag()));
     }


Input:
public void testAttachDetachOrder() {
    HasWidgetsTester.testAttachDetachOrder(new StackPanel(), new Adder());
}

Output:
 public void testAttachDetachOrder() {
-    HasWidgetsTester.testAttachDetachOrder(new StackPanel(), new Adder());
+    HasWidgetsTester.testAll(new StackPanel(), new Adder());
 }


Input:
public static List<Map<Integer, Double>> getArtifactMaps(BookmarkReader reader, List<Bookmark> userLines, List<Bookmark> testLines, boolean resource, List<Long> timestampList, List<Double> denomList, double dVal, boolean normalize) {
    List<Map<Integer, Double>> maps = new ArrayList<Map<Integer, Double>>();
    for (Bookmark data : userLines) {
        int refID = 0;
        if (resource) {
            refID = data.getWikiID();
        } else {
            refID = data.getUserID();
        }
        long baselineTimestamp = -1;
        if (refID >= maps.size()) {
            if (resource) {
                baselineTimestamp = 1;
            } else {
                baselineTimestamp = Utilities.getBaselineTimestamp(testLines, refID, false);
            }
            timestampList.add(baselineTimestamp);
            if (baselineTimestamp != -1) {
                maps.add(addActValue(data, new LinkedHashMap<Integer, Double>(), baselineTimestamp, resource, dVal));
            } else {
                maps.add(null);
            }
        } else {
            baselineTimestamp = timestampList.get(refID);
            if (baselineTimestamp != -1) {
                addActValue(data, maps.get(refID), baselineTimestamp, resource, dVal);
            }
        }
    }
    for (Map<Integer, Double> map : maps) {
        double denom = 0.0;
        if (map != null) {
            for (Map.Entry<Integer, Double> entry : map.entrySet()) {
                if (entry != null) {
                    double actVal = Math.log(entry.getValue());
                    denom += Math.exp(actVal);
                    entry.setValue(actVal);
                }
            }
            denomList.add(denom);
            if (normalize) {
                for (Map.Entry<Integer, Double> entry : map.entrySet()) {
                    if (entry != null) {
                        double actVal = Math.exp(entry.getValue());
                        entry.setValue(actVal / denom);
                    }
                }
            }
        }
    }
    return maps;
}

Output:
         if (resource) {
-            refID = data.getWikiID();
+            refID = data.getResourceID();
         } else {


Input:
protected void initView(Bundle savedInstanceState) {
    super.initView(savedInstanceState);
    setToolbarScrollAble(true);
    setToolbarBackEnable();
    setToolbarTitle(getString(R.string.issues));
    addBn.setVisibility(IssuesFilter.Type.Repo.equals(issuesType) ? View.VISIBLE : View.GONE);
    if (IssuesFilter.Type.User.equals(issuesType)) {
        pagerAdapter.setPagerList(FragmentPagerModel.createUserIssuesPagerList(getActivity()));
    } else {
        pagerAdapter.setPagerList(FragmentPagerModel.createRepoIssuesPagerList(getActivity(), userId, repoName));
        navView.getMenu().findItem(R.id.nav_type_chooser).setVisible(false);
    }
    listeners = new ArrayList<>();
    for (FragmentPagerModel pagerModel : pagerAdapter.getPagerList()) {
        listeners.add((IssuesListListener) pagerModel.getFragment());
    }
    tabLayout.setVisibility(View.VISIBLE);
    tabLayout.setupWithViewPager(viewPager);
    viewPager.setAdapter(pagerAdapter);
    showFirstPager();
}

Output:
     if (IssuesFilter.Type.User.equals(issuesType)) {
-        pagerAdapter.setPagerList(FragmentPagerModel.createUserIssuesPagerList(getActivity()));
+        pagerAdapter.setPagerList(FragmentPagerModel.createUserIssuesPagerList(getActivity(), getFragments()));
     } else {


Input:
public static MergedAndroidResources mergeFrom(RuleContext ruleContext, ParsedAndroidResources parsed, boolean neverlink) throws InterruptedException {
    AndroidConfiguration androidConfiguration = AndroidCommon.getAndroidConfig(ruleContext);
    boolean useCompiledMerge = androidConfiguration.getAndroidAaptVersion().equals(AndroidAaptVersion.AAPT2) && androidConfiguration.skipParsingAction();
    Preconditions.checkState(!useCompiledMerge || parsed.getCompiledSymbols() != null, "String_Node_Str");
    AndroidResourceMergingActionBuilder builder = new AndroidResourceMergingActionBuilder(ruleContext).setJavaPackage(parsed.getJavaPackage()).withDependencies(ResourceDependencies.fromRuleDeps(ruleContext, neverlink)).setThrowOnResourceConflict(androidConfiguration.throwOnResourceConflict()).setUseCompiledMerge(useCompiledMerge);
    if (DataBinding.isEnabled(ruleContext)) {
        builder.setDataBindingInfoZip(DataBinding.getLayoutInfoFile(ruleContext));
    }
    return builder.setManifestOut(ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_PROCESSED_MANIFEST)).setMergedResourcesOut(ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_RESOURCES_ZIP)).setClassJarOut(ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_RESOURCES_CLASS_JAR)).build(ruleContext, parsed);
}

Output:
     AndroidConfiguration androidConfiguration = AndroidCommon.getAndroidConfig(ruleContext);
-    boolean useCompiledMerge = androidConfiguration.getAndroidAaptVersion().equals(AndroidAaptVersion.AAPT2) && androidConfiguration.skipParsingAction();
+    boolean useCompiledMerge = AndroidAaptVersion.chooseTargetAaptVersion(ruleContext) == AndroidAaptVersion.AAPT2 && androidConfiguration.skipParsingAction();
     Preconditions.checkState(!useCompiledMerge || parsed.getCompiledSymbols() != null, "String_Node_Str");


Input:
public void setFixed(String value) throws InPUTException {
    if (value != null) {
        setAttribute(Q.FIXED_ATTR, value);
    } else
        removeAttribute(Q.FIXED_ATTR);
    generator = initGenerator(true);
}

Output:
 public void setFixed(String value) throws InPUTException {
-    if (value != null) {
-        setAttribute(Q.FIXED_ATTR, value);
-    } else
+    if (value == null)
         removeAttribute(Q.FIXED_ATTR);


Input:
public void run() {
    NetUtils net = new NetUtils(mContext);
    try {
        final Optional<Bitmap> bmp = net.downloadImageToBitmap(url);
        if (!bmp.isPresent()) {
            return;
        }
        mContext.runOnUiThread(new Runnable() {
            public void run() {
                pref.setIcon(new BitmapDrawable(getResources(), bmp.get()));
            }
        });
    } catch (NullPointerException e) {
    }
}

Output:
             }
-        });
-    } catch (NullPointerException e) {
-    }
+        }
+    });
 }


Input:
public double toDouble() throws IOException {
    if (property.isList) {
        throw new UnsupportedOperationException("String_Node_Str");
    }
    return get(0).toDouble();
}

Output:
     }
-    return get(0).toDouble();
+    if (super.isEmpty() != false) {
+        return get(0).toDouble();
+    }
+    return 0;
 }


Input:
public void parse(IParserManager pm, IToken token) throws SyntaxError {
    int type = token.type();
    if (this.mode == 0) {
        if (this.value != null) {
            this.field.setValue(this.value);
        }
        pm.popParser(true);
        return;
    }
    switch(type) {
        case Symbols.SEMICOLON:
        case Symbols.COMMA:
        case Tokens.STRING_PART:
        case Tokens.STRING_END:
            if (this.value != null) {
                this.field.setValue(this.value);
            }
            pm.popParser(true);
            return;
    }
    switch(this.mode) {
        case VALUE:
            if (type == Symbols.OPEN_PARENTHESIS) {
                int nextType = token.next().type();
                if (nextType == Symbols.CLOSE_PARENTHESIS) {
                    this.value = new VoidValue(token.to(token.next()));
                    pm.skip();
                    this.mode = 0;
                    return;
                }
                pm.pushParser(new LambdaOrTupleParser(this), true);
                this.mode = ACCESS;
                return;
            }
            if (type == Symbols.OPEN_SQUARE_BRACKET) {
                this.mode = ARRAY_END;
                Array vl = new Array(token);
                this.value = vl;
                int nextType = token.next().type();
                if (nextType != Symbols.CLOSE_SQUARE_BRACKET) {
                    pm.pushParser(new ExpressionListParser(vl));
                }
                return;
            }
            if (type == Symbols.OPEN_CURLY_BRACKET) {
                this.mode = LIST_END;
                StatementList sl = new StatementList(token);
                this.value = sl;
                int nextType = token.next().type();
                if (nextType != Symbols.CLOSE_CURLY_BRACKET) {
                    pm.pushParser(new StatementListParser(sl));
                }
                return;
            }
            if (type == Tokens.SYMBOL_IDENTIFIER) {
                if (token.nameValue() == Name.at && token.next().type() == Symbols.OPEN_CURLY_BRACKET) {
                    Bytecode bc = new Bytecode(token);
                    pm.skip();
                    pm.pushParser(new BytecodeParser(bc));
                    this.mode = BYTECODE_END;
                    this.value = bc;
                    return;
                }
                this.getAccess(pm, token.nameValue(), token, type);
                return;
            }
            if ((type & Tokens.IDENTIFIER) != 0) {
                this.getAccess(pm, token.nameValue(), token, type);
                return;
            }
            if (this.parseKeyword(pm, token, type)) {
                return;
            }
            this.mode = ACCESS;
            pm.reparse();
            return;
        case PATTERN_IF:
            this.mode = PATTERN_END;
            if (type == Keywords.IF) {
                pm.pushParser(new ExpressionParser(this));
                return;
            }
        case PATTERN_END:
            if (type == Symbols.COLON) {
                this.field.setValue(this.value);
                pm.popParser();
                if (token.next().type() != Keywords.CASE) {
                    pm.pushParser(new ExpressionParser((IValued) this.value));
                }
                return;
            }
            throw new SyntaxError(token, "String_Node_Str");
        case ARRAY_END:
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                this.mode = ACCESS;
                return;
            }
            this.field.setValue(this.value);
            pm.popParser();
            throw new SyntaxError(token, "String_Node_Str");
        case LIST_END:
            this.field.setValue(this.value);
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_CURLY_BRACKET) {
                if (token.next().type() == Symbols.DOT) {
                    this.mode = ACCESS_2;
                    this.dotless = false;
                    pm.skip();
                    return;
                }
                pm.popParser();
                return;
            }
            pm.popParser(true);
            throw new SyntaxError(token, "String_Node_Str");
        case PARAMETERS_END:
            this.mode = ACCESS;
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_PARENTHESIS) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case SUBSCRIPT_END:
            this.mode = ACCESS;
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case CONSTRUCTOR:
            {
                ConstructorCall cc = (ConstructorCall) this.value;
                if (type == Symbols.OPEN_CURLY_BRACKET) {
                    this.createBody(cc.toClassConstructor(), pm);
                    return;
                }
                if (type == Symbols.OPEN_PARENTHESIS) {
                    ArgumentList list = new ArgumentList();
                    cc.arguments = list;
                    pm.pushParser(new ExpressionListParser(list));
                    this.mode = CONSTRUCTOR_END;
                    return;
                }
                if (ParserUtil.isTerminator2(type)) {
                    this.mode = ACCESS;
                    pm.reparse();
                    return;
                }
                SingleArgument sa = new SingleArgument();
                cc.arguments = sa;
                pm.pushParser(new ExpressionParser(sa), true);
                this.mode = 0;
                return;
            }
        case CONSTRUCTOR_END:
            this.mode = ACCESS;
            if (token.next().type() == Symbols.OPEN_CURLY_BRACKET) {
                this.createBody(((ConstructorCall) this.value).toClassConstructor(), pm);
                return;
            }
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_PARENTHESIS) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case BYTECODE_END:
            this.field.setValue(this.value);
            pm.popParser();
            this.value.expandPosition(token);
            if (type == Symbols.CLOSE_CURLY_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str", true);
        case TYPE_ARGUMENTS_END:
            MethodCall mc = (MethodCall) this.value;
            IToken next = token.next();
            if (next.type() == Symbols.OPEN_PARENTHESIS) {
                pm.skip();
                mc.arguments = this.getArguments(pm, next.next());
            } else {
                mc.arguments = EmptyArguments.INSTANCE;
            }
            this.mode = ACCESS;
            if (type == Symbols.CLOSE_SQUARE_BRACKET) {
                return;
            }
            throw new SyntaxError(token, "String_Node_Str");
    }
    if (ParserUtil.isCloseBracket(type)) {
        if (this.value != null) {
            this.field.setValue(this.value);
        }
        pm.popParser(true);
        return;
    }
    if (this.mode == ACCESS) {
        if (type == Symbols.DOT) {
            this.mode = ACCESS_2;
            this.dotless = false;
            return;
        }
        this.dotless = true;
        this.mode = ACCESS_2;
        if (type == Keywords.ELSE) {
            this.field.setValue(this.value);
            pm.popParser(true);
            return;
        }
        if (type == Symbols.EQUALS) {
            this.getAssign(pm, token);
            return;
        }
        if (type == Keywords.AS) {
            CastOperator co = new CastOperator(token.raw(), this.value);
            pm.pushParser(new TypeParser(co));
            this.value = co;
            return;
        }
        if (type == Keywords.IS) {
            InstanceOfOperator io = new InstanceOfOperator(token.raw(), this.value);
            pm.pushParser(new TypeParser(io));
            this.value = io;
            return;
        }
        if (type == Symbols.OPEN_SQUARE_BRACKET) {
            SubscriptGetter getter = new SubscriptGetter(token, this.value);
            this.value = getter;
            this.mode = SUBSCRIPT_END;
            pm.pushParser(new ExpressionListParser(getter.getArguments()));
            return;
        }
        if (type == Symbols.OPEN_PARENTHESIS) {
            IToken prev = token.prev();
            IToken next = token.next();
            IArguments args;
            args = this.getArguments(pm, next);
            int prevType = prev.type();
            if (ParserUtil.isIdentifier(prevType)) {
                MethodCall mc = new MethodCall(prev, null, prev.nameValue());
                mc.arguments = args;
                this.value = mc;
            } else if (prevType == Symbols.CLOSE_SQUARE_BRACKET) {
                MethodCall mc;
                if (this.value.valueTag() == IValue.FIELD_ACCESS) {
                    mc = ((FieldAccess) this.value).toMethodCall(null);
                } else {
                    mc = (MethodCall) this.value;
                }
                mc.arguments = args;
                this.value = mc;
            } else {
                ApplyMethodCall amc = new ApplyMethodCall(this.value.getPosition());
                amc.instance = this.value;
                amc.arguments = args;
                this.value = amc;
            }
            this.mode = PARAMETERS_END;
            return;
        }
    }
    if (this.mode == ACCESS_2) {
        if (ParserUtil.isIdentifier(type)) {
            Name name = token.nameValue();
            if (this.prefix) {
                this.field.setValue(this.value);
                pm.popParser(true);
                return;
            }
            if (this.dotless && this.operator != null) {
                Operator operator = pm.getOperator(name);
                int p;
                if (operator == null || (p = this.operator.precedence) > operator.precedence) {
                    this.field.setValue(this.value);
                    pm.popParser(true);
                    return;
                }
                if (p == operator.precedence) {
                    switch(operator.type) {
                        case Operator.INFIX_LEFT:
                            this.field.setValue(this.value);
                            pm.popParser(true);
                            return;
                        case Operator.INFIX_NONE:
                            throw new SyntaxError(token, "String_Node_Str" + name + "String_Node_Str");
                        case Operator.INFIX_RIGHT:
                    }
                }
            }
            this.getAccess(pm, name, token, type);
            return;
        }
        if (ParserUtil.isTerminator(type)) {
            this.field.setValue(this.value);
            pm.popParser(true);
            return;
        }
        IToken prev = token.prev();
        if (ParserUtil.isIdentifier(prev.type())) {
            this.value = null;
            pm.reparse();
            this.getAccess(pm, prev.nameValue(), prev, type);
            return;
        }
        if (this.value != null) {
            ApplyMethodCall call = new ApplyMethodCall(token.raw());
            call.instance = this.value;
            SingleArgument sa = new SingleArgument();
            call.arguments = sa;
            this.value = call;
            this.mode = 0;
            pm.pushParser(new ExpressionParser(sa), true);
            return;
        }
        throw new SyntaxError(token, "String_Node_Str" + token);
    }
    if (this.value != null) {
        this.value.expandPosition(token);
        this.field.setValue(this.value);
        pm.popParser(true);
        return;
    }
    throw new SyntaxError(token, "String_Node_Str" + token);
}

Output:
             if (type == Symbols.COLON) {
-                this.field.setValue(this.value);
-                pm.popParser();
+                this.mode = 0;
                 if (token.next().type() != Keywords.CASE) {


Input:
public void onMouseMove(MouseMoveEvent event) {
    event.stopPropagation();
    if (mouseState == MOUSE.NULL || mouseState == MOUSE.MOVED) {
        mouseState = MOUSE.MOVED;
        executeEvent(eventThis, mouseMoved, null);
    } else if (mouseState == MOUSE.PRESSED || mouseState == MOUSE.DRAGGED) {
        mouseState = MOUSE.DRAGGED;
        executeEvent(eventThis, mouseDragged, JSEvents.publishMouseMoveEvent(event));
    }
}

Output:
 public void onMouseMove(MouseMoveEvent event) {
-    event.stopPropagation();
-    if (mouseState == MOUSE.NULL || mouseState == MOUSE.MOVED) {
-        mouseState = MOUSE.MOVED;
-        executeEvent(eventThis, mouseMoved, null);
-    } else if (mouseState == MOUSE.PRESSED || mouseState == MOUSE.DRAGGED) {
-        mouseState = MOUSE.DRAGGED;
-        executeEvent(eventThis, mouseDragged, JSEvents.publishMouseMoveEvent(event));
+    if (mouseMoved != null || mouseDragged != null) {
+        event.stopPropagation();
+        if (mouseState == MOUSE.NULL || mouseState == MOUSE.MOVED) {
+            mouseState = MOUSE.MOVED;
+            executeEvent(eventThis, mouseMoved, null);
+        } else if (mouseState == MOUSE.PRESSED || mouseState == MOUSE.DRAGGED) {
+            mouseState = MOUSE.DRAGGED;
+            executeEvent(eventThis, mouseDragged, JSEvents.publishMouseMoveEvent(event));
+        }
     }


Input:
private void updateName(Session session, Topic topic, Node topicJcrNode, Context context) throws RepositoryException {
    if (StringUtils.isBlank(topic.getName())) {
        String possibleSystemName = null;
        if (topic.hasLocalizedLabels()) {
            possibleSystemName = topic.getLocalizedLabelForLocale(Locale.ENGLISH.toString());
            if (StringUtils.isBlank(possibleSystemName)) {
                for (String label : topic.getLocalizedLabels().values()) {
                    possibleSystemName = cmsRepositoryEntityUtils.fixSystemName(label);
                    if (StringUtils.isNotBlank(possibleSystemName)) {
                        break;
                    }
                }
            } else {
                possibleSystemName = cmsRepositoryEntityUtils.fixSystemName(possibleSystemName);
            }
        }
        if (StringUtils.isBlank(possibleSystemName)) {
            logger.warn("String_Node_Str" + topic.getId() + "String_Node_Str");
        } else {
            topic.setName(possibleSystemName);
        }
    }
    if (topic.getName() != null) {
        if (!cmsRepositoryEntityUtils.isValidSystemName(topic.getName())) {
            throw new RepositoryException("String_Node_Str" + topic.getName() + "String_Node_Str" + CmsConstants.SYSTEM_NAME_REG_EXP);
        }
        TopicCriteria topicCriteria = CmsCriteriaFactory.newTopicCriteria();
        topicCriteria.addNameEqualsCriterion(topic.getName());
        if (topic.getId() != null) {
            topicCriteria.addIdNotEqualsCriterion(topic.getId());
        }
        topicCriteria.setOffsetAndLimit(0, 2);
        CmsQueryResult sameNameTopicsInTaxonomy = cmsQueryHandler.getNodesFromXPathQuery(session, topicCriteria);
        if (sameNameTopicsInTaxonomy.getTotalRowCount() != 0) {
            StringBuilder topicPaths = new StringBuilder();
            NodeIterator nodeIterator = sameNameTopicsInTaxonomy.getNodeIterator();
            while (nodeIterator.hasNext()) {
                topicPaths.append("String_Node_Str");
                topicPaths.append(nodeIterator.nextNode().getPath());
            }
            throw new RepositoryException("String_Node_Str" + topic.getName() + "String_Node_Str" + topicPaths.toString());
        } else {
            Node cachedTopicNode = context.getNodeFromCache(topic.getName());
            if (cachedTopicNode != null && !cachedTopicNode.isSame(topicJcrNode)) {
                throw new RepositoryException("String_Node_Str" + topic.getName() + "String_Node_Str" + "String_Node_Str" + topic.getName());
            }
        }
        topicJcrNode.setProperty(CmsBuiltInItem.Name.getJcrName(), topic.getName());
    } else
        topicJcrNode.setProperty(CmsBuiltInItem.Name.getJcrName(), JcrValueUtils.getJcrNull());
}

Output:
         }
-        if (StringUtils.isBlank(possibleSystemName)) {
-            logger.warn("String_Node_Str" + topic.getId() + "String_Node_Str");
-        } else {
+        if (StringUtils.isNotBlank(possibleSystemName)) {
             topic.setName(possibleSystemName);