Input:
public void run() {
    try {
        HashMapVirtualObject next;
        next = objectProvider.next();
        Query query = new Query("String_Node_Str", packageMetaData);
        QueryPart queryPart = query.createQueryPart();
        while (next != null) {
            queryPart.addOid(next.getOid());
            next = objectProvider.next();
        }
        objectProvider = new QueryObjectProvider(databaseSession, bimServer, query, Collections.singleton(queryContext.getRoid()), packageMetaData);
    } catch (BimserverDatabaseException | IOException | QueryException e1) {
        e1.printStackTrace();
    }
    StreamingSerializer ifcSerializer = ifcSerializerPlugin.createSerializer(new PluginConfiguration());
    RenderEngine renderEngine = null;
    try {
        renderEngine = renderEnginePool.borrowObject();
        final Set<HashMapVirtualObject> oids = new HashSet<>();
        ObjectProviderProxy proxy = new ObjectProviderProxy(objectProvider, new ObjectListener() {
            public void newObject(HashMapVirtualObject next) {
                if (eClass.isSuperTypeOf(next.eClass())) {
                    oids.add(next);
                }
            }
        });
        ifcSerializer.init(proxy, null, null, bimServer.getPluginManager(), packageMetaData);
        boolean debug = true;
        InputStream in = null;
        if (debug) {
            String basefilenamename = "String_Node_Str";
            if (eClass != null) {
                basefilenamename = eClass.getName();
            }
            File file = new File(basefilenamename + "String_Node_Str");
            int i = 0;
            while (file.exists()) {
                file = new File(basefilenamename + "String_Node_Str" + i + "String_Node_Str");
                i++;
            }
            FileOutputStream fos = new FileOutputStream(file);
            IOUtils.copy(ifcSerializer.getInputStream(), fos);
            fos.close();
            in = new FileInputStream(file);
        } else {
            in = ifcSerializer.getInputStream();
        }
        RenderEngineModel renderEngineModel = renderEngine.openModel(in);
        try {
            renderEngineModel.setSettings(renderEngineSettings);
            renderEngineModel.setFilter(renderEngineFilter);
            try {
                renderEngineModel.generateGeneralGeometry();
            } catch (RenderEngineException e) {
                if (e.getCause() instanceof java.io.EOFException) {
                    if (oids.isEmpty() || eClass.getName().equals("String_Node_Str")) {
                    } else {
                        LOGGER.error("String_Node_Str" + eClass.getName(), e);
                    }
                }
            }
            OidConvertingSerializer oidConvertingSerializer = (OidConvertingSerializer) ifcSerializer;
            Map<Long, Integer> oidToEid = oidConvertingSerializer.getOidToEid();
            for (HashMapVirtualObject ifcProduct : oids) {
                Integer expressId = oidToEid.get(ifcProduct.getOid());
                if (ifcProduct.eGet(representationFeature) != null) {
                    try {
                        RenderEngineInstance renderEngineInstance = renderEngineModel.getInstanceFromExpressId(expressId);
                        RenderEngineGeometry geometry = renderEngineInstance.generateGeometry();
                        boolean translate = true;
                        if (geometry != null && geometry.getNrIndices() > 0) {
                            VirtualObject geometryInfo = new HashMapVirtualObject(queryContext, GeometryPackage.eINSTANCE.getGeometryInfo());
                            WrappedVirtualObject minBounds = new HashMapWrappedVirtualObject(queryContext, GeometryPackage.eINSTANCE.getVector3f());
                            WrappedVirtualObject maxBounds = new HashMapWrappedVirtualObject(queryContext, GeometryPackage.eINSTANCE.getVector3f());
                            minBounds.set("String_Node_Str", Double.POSITIVE_INFINITY);
                            minBounds.set("String_Node_Str", Double.POSITIVE_INFINITY);
                            minBounds.set("String_Node_Str", Double.POSITIVE_INFINITY);
                            maxBounds.set("String_Node_Str", -Double.POSITIVE_INFINITY);
                            maxBounds.set("String_Node_Str", -Double.POSITIVE_INFINITY);
                            maxBounds.set("String_Node_Str", -Double.POSITIVE_INFINITY);
                            geometryInfo.setAttribute(GeometryPackage.eINSTANCE.getGeometryInfo_MinBounds(), minBounds);
                            geometryInfo.setAttribute(GeometryPackage.eINSTANCE.getGeometryInfo_MaxBounds(), maxBounds);
                            VirtualObject geometryData = new HashMapVirtualObject(queryContext, GeometryPackage.eINSTANCE.getGeometryData());
                            geometryData.setAttribute(GeometryPackage.eINSTANCE.getGeometryData_Indices(), intArrayToByteArray(geometry.getIndices()));
                            geometryData.setAttribute(GeometryPackage.eINSTANCE.getGeometryData_Vertices(), floatArrayToByteArray(geometry.getVertices()));
                            geometryData.setAttribute(GeometryPackage.eINSTANCE.getGeometryData_MaterialIndices(), intArrayToByteArray(geometry.getMaterialIndices()));
                            geometryData.setAttribute(GeometryPackage.eINSTANCE.getGeometryData_Normals(), floatArrayToByteArray(geometry.getNormals()));
                            geometryInfo.setAttribute(GeometryPackage.eINSTANCE.getGeometryInfo_PrimitiveCount(), geometry.getIndices().length / 3);
                            if (geometry.getMaterialIndices() != null && geometry.getMaterialIndices().length > 0) {
                                boolean hasMaterial = false;
                                float[] vertex_colors = new float[geometry.getVertices().length / 3 * 4];
                                for (int i = 0; i < geometry.getMaterialIndices().length; ++i) {
                                    int c = geometry.getMaterialIndices()[i];
                                    for (int j = 0; j < 3; ++j) {
                                        int k = geometry.getIndices()[i * 3 + j];
                                        if (c > -1) {
                                            hasMaterial = true;
                                            for (int l = 0; l < 4; ++l) {
                                                vertex_colors[4 * k + l] = geometry.getMaterials()[4 * c + l];
                                            }
                                        }
                                    }
                                }
                                if (hasMaterial) {
                                    geometryData.setAttribute(GeometryPackage.eINSTANCE.getGeometryData_Materials(), floatArrayToByteArray(vertex_colors));
                                }
                            }
                            double[] tranformationMatrix = new double[16];
                            if (translate && renderEngineInstance.getTransformationMatrix() != null) {
                                tranformationMatrix = renderEngineInstance.getTransformationMatrix();
                            } else {
                                Matrix.setIdentityM(tranformationMatrix, 0);
                            }
                            for (int i = 0; i < geometry.getIndices().length; i++) {
                                processExtends(geometryInfo, tranformationMatrix, geometry.getVertices(), geometry.getIndices()[i] * 3, generateGeometryResult);
                            }
                            calculateObb(geometryInfo, tranformationMatrix, geometry.getIndices(), geometry.getVertices(), generateGeometryResult);
                            geometryInfo.setReference(GeometryPackage.eINSTANCE.getGeometryInfo_Data(), geometryData.getOid(), 0);
                            long size = getSize(geometryData);
                            setTransformationMatrix(geometryInfo, tranformationMatrix);
                            if (bimServer.getServerSettingsCache().getServerSettings().isReuseGeometry()) {
                                int hash = hash(geometryData);
                                if (hashes.containsKey(hash)) {
                                    geometryInfo.setReference(GeometryPackage.eINSTANCE.getGeometryInfo_Data(), hashes.get(hash), 0);
                                    bytesSaved.addAndGet(size);
                                } else {
                                    hashes.put(hash, geometryData.getOid());
                                    geometryData.save();
                                }
                            } else {
                                geometryData.save();
                            }
                            geometryInfo.save();
                            totalBytes.addAndGet(size);
                            ifcProduct.setReference(geometryFeature, geometryInfo.getOid(), 0);
                            ifcProduct.saveOverwrite();
                        }
                    } catch (EntityNotFoundException e) {
                        boolean ignoreNotFound = eClass.getName().equals("String_Node_Str");
                        if (!ignoreNotFound) {
                            LOGGER.info("String_Node_Str" + ifcProduct.eClass().getName() + "String_Node_Str" + (expressId) + "String_Node_Str" + ifcProduct.getOid());
                        }
                    } catch (BimserverDatabaseException | RenderEngineException e) {
                        LOGGER.error("String_Node_Str", e);
                    }
                }
            }
        } finally {
            in.close();
            renderEngineModel.close();
            if (renderEngine != null) {
                renderEnginePool.returnObject(renderEngine);
            }
            jobsDone.incrementAndGet();
            updateProgress();
        }
    } catch (Exception e) {
        LOGGER.error("String_Node_Str", e);
    }
}

Output:
         objectProvider = new QueryObjectProvider(databaseSession, bimServer, query, Collections.singleton(queryContext.getRoid()), packageMetaData);
-    } catch (BimserverDatabaseException | IOException | QueryException e1) {
-        e1.printStackTrace();
-    }
-    StreamingSerializer ifcSerializer = ifcSerializerPlugin.createSerializer(new PluginConfiguration());
-    RenderEngine renderEngine = null;
-    try {
-        renderEngine = renderEnginePool.borrowObject();
-        final Set<HashMapVirtualObject> oids = new HashSet<>();
-        ObjectProviderProxy proxy = new ObjectProviderProxy(objectProvider, new ObjectListener() {
-            public void newObject(HashMapVirtualObject next) {
-                if (eClass.isSuperTypeOf(next.eClass())) {
-                    oids.add(next);
-                }
-            }
-        });
-        ifcSerializer.init(proxy, null, null, bimServer.getPluginManager(), packageMetaData);
-        boolean debug = true;
-        InputStream in = null;
-        if (debug) {
-            String basefilenamename = "String_Node_Str";
-            if (eClass != null) {
-                basefilenamename = eClass.getName();
-            }
-            File file = new File(basefilenamename + "String_Node_Str");
-            int i = 0;
-            while (file.exists()) {
-                file = new File(basefilenamename + "String_Node_Str" + i + "String_Node_Str");
-                i++;
-            }
-            FileOutputStream fos = new FileOutputStream(file);
-            IOUtils.copy(ifcSerializer.getInputStream(), fos);
-            fos.close();
-            in = new FileInputStream(file);
-        } else {
-            in = ifcSerializer.getInputStream();
-        }
-        RenderEngineModel renderEngineModel = renderEngine.openModel(in);
+        StreamingSerializer ifcSerializer = ifcSerializerPlugin.createSerializer(new PluginConfiguration());
+        RenderEngine renderEngine = null;
+        byte[] bytes = null;
         try {


Input:
private void resetPostAdapter(ReaderPostListType postListType) {
    mPostListType = postListType;
    mPostAdapter = null;
    mRecyclerView.setAdapter(null);
    mHasUpdatedPosts = false;
    checkPostAdapter();
}

Output:
     mRecyclerView.setAdapter(null);
-    mHasUpdatedPosts = false;
-    checkPostAdapter();
+    mRecyclerView.setAdapter(getPostAdapter());
 }


Input:
private void setRowHover(TableRowElement tr, boolean isHovering) {
    setRowStyleName(tr, style.hoveredRow(), style.hoveredRowCell(), isHovering);
    RowHoverEvent.fire(this, tr, isHovering);
}

Output:
     setRowStyleName(tr, style.hoveredRow(), style.hoveredRowCell(), isHovering);
-    RowHoverEvent.fire(this, tr, isHovering);
+    RowHoverEvent.fire(this, tr, !isHovering);
 }


Input:
public void operationComplete(ChannelFuture future) throws Exception {
    if (future.isSuccess()) {
        logger.debug("String_Node_Str" + barrier);
        final NotifiedMessage notified = new NotifiedMessage();
        notified.setBarrier(barrier);
        Channels.write(ctx, Channels.future(null), notified);
    }
}

Output:
 public void operationComplete(ChannelFuture future) throws Exception {
-    if (future.isSuccess()) {
-        logger.debug("String_Node_Str" + barrier);
-        final NotifiedMessage notified = new NotifiedMessage();
-        notified.setBarrier(barrier);
-        Channels.write(ctx, Channels.future(null), notified);
+    try {
+        if (future.isSuccess()) {
+            logger.debug("String_Node_Str" + barrier);
+            final NotifiedMessage notified = new NotifiedMessage();
+            notified.setBarrier(barrier);
+            Channels.write(ctx, Channels.future(null), notified);
+        }
+    } finally {
+        latch.countDown();
     }


Input:
private static void setDatabaseValueForOracleSid(DatabaseConnection connection, INode node, String repositoryValue) {
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        String dbVersionName = EDatabaseVersion4Drivers.getDbVersionName(EDatabaseTypeName.ORACLEFORSID, value);
        if (value != null) {
            connection.setDbVersionString(dbVersionName);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        IElementParameter param = node.getElementParameter("String_Node_Str");
        if (param != null && "String_Node_Str".equals(param.getValue())) {
            String value = getParameterValue(connection, node, "String_Node_Str");
            if (value != null) {
                connection.setSID(value);
            }
        } else {
            String value = getParameterValue(connection, node, "String_Node_Str");
            if (value != null) {
                connection.setSID(value);
            }
        }
    }
}

Output:
     }
-    if ("String_Node_Str".equals(repositoryValue)) {
-        IElementParameter param = node.getElementParameter("String_Node_Str");
+    if ("String_Node_Str".equals(param.getRepositoryValue())) {
         if (param != null && "String_Node_Str".equals(param.getValue())) {


Input:
public HandlerProcessingResult processAnnotation(AnnotationInfo annInfo) throws AnnotationProcessorException {
    AnnotatedElementHandler annCtx = annInfo.getProcessingContext().getHandler();
    AnnotatedElement annElem = annInfo.getAnnotatedElement();
    AnnotatedElement origAnnElem = annElem;
    boolean ejbInWar = ignoreWebserviceAnnotations(annElem, annCtx);
    if (ejbInWar) {
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    if (!(annElem instanceof Class)) {
        AnnotationProcessorException ape = new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str"), annInfo);
        annInfo.getProcessingContext().getErrorHandler().error(ape);
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.FAILED);
    }
    if (((Class) annElem).isInterface()) {
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    if (isJaxwsRIDeployment(annInfo)) {
        conLogger.log(Level.INFO, LogUtils.DEPLOYMENT_DISABLED, new Object[] { annInfo.getProcessingContext().getArchive().getName(), "String_Node_Str" });
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    javax.jws.WebService ann = (javax.jws.WebService) annInfo.getAnnotation();
    BundleDescriptor bundleDesc = null;
    try {
        if ((ejbProvider != null) && ejbProvider.getType("String_Node_Str") != null && (annCtx instanceof EjbContext)) {
            EjbContext ctx = (EjbContext) annCtx;
            bundleDesc = ctx.getDescriptor().getEjbBundleDescriptor();
            bundleDesc.setSpecVersion("String_Node_Str");
        } else {
            if (annCtx instanceof WebComponentContext) {
                bundleDesc = ((WebComponentContext) annCtx).getDescriptor().getWebBundleDescriptor();
            } else if (!(annCtx instanceof WebBundleContext)) {
                return getInvalidAnnotatedElementHandlerResult(annInfo.getProcessingContext().getHandler(), annInfo);
            }
            bundleDesc = ((WebBundleContext) annCtx).getDescriptor();
            bundleDesc.setSpecVersion("String_Node_Str");
        }
    } catch (Exception e) {
        throw new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str", e.getMessage()));
    }
    String portComponentName = ann.name();
    String svcNameFromImplClass = ann.serviceName();
    String implClassName = ((Class) annElem).getSimpleName();
    String implClassFullName = ((Class) annElem).getName();
    String targetNameSpace = ann.targetNamespace();
    String portNameFromImplClass = ann.portName();
    if ((portNameFromImplClass == null) || (portNameFromImplClass.length() == 0)) {
        if ((portComponentName != null) && (portComponentName.length() != 0)) {
            portNameFromImplClass = portComponentName + "String_Node_Str";
        } else {
            portNameFromImplClass = implClassName + "String_Node_Str";
        }
    }
    String userSpecifiedBinding = null;
    javax.xml.ws.BindingType bindingAnn = (javax.xml.ws.BindingType) ((Class) annElem).getAnnotation(javax.xml.ws.BindingType.class);
    if (bindingAnn != null) {
        userSpecifiedBinding = bindingAnn.value();
    }
    String wsdlLocation = null;
    if (ann.wsdlLocation() != null && ann.wsdlLocation().length() != 0) {
        wsdlLocation = ann.wsdlLocation();
    }
    if (ann.endpointInterface() != null && ann.endpointInterface().length() > 0) {
        Class endpointIntf;
        try {
            endpointIntf = ((Class) annElem).getClassLoader().loadClass(ann.endpointInterface());
        } catch (java.lang.ClassNotFoundException cfne) {
            throw new AnnotationProcessorException(localStrings.getLocalString("String_Node_Str", "String_Node_Str", new Object[] { ann.endpointInterface() }), annInfo);
        }
        annElem = endpointIntf;
        ann = annElem.getAnnotation(javax.jws.WebService.class);
        if (ann == null) {
            throw new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str", ((javax.jws.WebService) annInfo.getAnnotation()).endpointInterface(), ((Class) annElem).getName()));
        }
        if (annElem.getAnnotation(javax.xml.ws.BindingType.class) != null) {
            throw new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str", ((javax.jws.WebService) annInfo.getAnnotation()).endpointInterface()));
        }
    }
    WebServicesDescriptor wsDesc = bundleDesc.getWebServices();
    if (portComponentName == null || portComponentName.length() == 0) {
        portComponentName = implClassName;
    }
    WebServiceEndpoint wep = wsDesc.getEndpointByName(portComponentName);
    if (wep != null) {
        if ((wep.getServiceEndpointInterface() != null) && (wep.getServiceEndpointInterface().length() != 0) && (!((Class) annElem).getName().equals(wep.getServiceEndpointInterface()))) {
            portComponentName = implClassFullName;
        }
    }
    WebServiceEndpoint endpoint = wsDesc.getEndpointByName(portComponentName);
    WebService newWS;
    if (endpoint == null) {
        if (DOLUtils.warType().equals(bundleDesc.getModuleType())) {
            WebComponentDescriptor[] wcByImplName = ((WebBundleDescriptor) bundleDesc).getWebComponentByImplName(implClassFullName);
            for (WebComponentDescriptor wc : wcByImplName) {
                for (WebServiceEndpoint wse : wsDesc.getEndpointsImplementedBy(wc)) {
                    logger.log(Level.SEVERE, LogUtils.WS_URLMAPPING_EXISTS, new Object[] { implClassFullName });
                    break;
                }
            }
        }
        if (svcNameFromImplClass != null && svcNameFromImplClass.length() != 0) {
            newWS = wsDesc.getWebServiceByName(svcNameFromImplClass);
        } else {
            newWS = wsDesc.getWebServiceByName(implClassName + "String_Node_Str");
        }
        if (newWS == null) {
            newWS = new WebService();
            if (svcNameFromImplClass != null && svcNameFromImplClass.length() != 0) {
                newWS.setName(svcNameFromImplClass);
            } else {
                newWS.setName(implClassName + "String_Node_Str");
            }
            wsDesc.addWebService(newWS);
        }
        endpoint = new WebServiceEndpoint();
        if (portComponentName != null && portComponentName.length() != 0) {
            endpoint.setEndpointName(portComponentName);
        } else {
            endpoint.setEndpointName(((Class) annElem).getName());
        }
        newWS.addEndpoint(endpoint);
        wsDesc.setSpecVersion(WebServicesDescriptorNode.SPEC_VERSION);
    } else {
        newWS = endpoint.getWebService();
    }
    if (endpoint.getWsdlService() != null) {
        if ((targetNameSpace != null) && (targetNameSpace.length() != 0) && (!endpoint.getWsdlService().getNamespaceURI().equals(targetNameSpace))) {
            AnnotationProcessorException ape = new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str"), annInfo);
            annInfo.getProcessingContext().getErrorHandler().error(ape);
            return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.FAILED);
        }
        targetNameSpace = endpoint.getWsdlService().getNamespaceURI();
    }
    if ((endpoint.getWsdlService() != null) && (endpoint.getWsdlPort() != null)) {
        if (!endpoint.getWsdlService().getNamespaceURI().equals(endpoint.getWsdlPort().getNamespaceURI())) {
            AnnotationProcessorException ape = new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str"), annInfo);
            annInfo.getProcessingContext().getErrorHandler().error(ape);
            return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.FAILED);
        }
    }
    if (newWS.getWsdlFileUri() == null) {
        if (wsdlLocation != null) {
            newWS.setWsdlFileUri(wsdlLocation);
        } else {
            if (ann.wsdlLocation() != null && ann.wsdlLocation().length() != 0) {
                newWS.setWsdlFileUri(ann.wsdlLocation());
            }
        }
    }
    if ((!endpoint.hasUserSpecifiedProtocolBinding()) && (userSpecifiedBinding != null) && (userSpecifiedBinding.length() != 0)) {
        endpoint.setProtocolBinding(userSpecifiedBinding);
    }
    if (endpoint.getServiceEndpointInterface() == null) {
        if (ann.endpointInterface() != null && ann.endpointInterface().length() != 0) {
            endpoint.setServiceEndpointInterface(ann.endpointInterface());
        } else {
            endpoint.setServiceEndpointInterface(((Class) annElem).getName());
        }
    }
    annElem = annInfo.getAnnotatedElement();
    if (DOLUtils.warType().equals(bundleDesc.getModuleType())) {
        if (endpoint.getServletImplClass() == null) {
            endpoint.setServletImplClass(((Class) annElem).getName());
        }
        WebBundleDescriptor webBundle = (WebBundleDescriptor) bundleDesc;
        if (endpoint.getWebComponentLink() == null) {
            endpoint.setWebComponentLink(implClassFullName);
        }
        if (endpoint.getWebComponentImpl() == null) {
            WebComponentDescriptor webComponent = (WebComponentDescriptor) webBundle.getWebComponentByCanonicalName(endpoint.getWebComponentLink());
            if (webComponent == null) {
                webComponent = new WebComponentDescriptorImpl();
                webComponent.setServlet(true);
                webComponent.setWebComponentImplementation(((Class) annElem).getCanonicalName());
                webComponent.setName(endpoint.getEndpointName());
                webComponent.addUrlPattern("String_Node_Str" + newWS.getName());
                webBundle.addWebComponentDescriptor(webComponent);
            }
            endpoint.setWebComponentImpl(webComponent);
        }
    } else {
        Stateless stateless = null;
        try {
            stateless = annElem.getAnnotation(javax.ejb.Stateless.class);
        } catch (Exception e) {
            if (logger.isLoggable(Level.FINE)) {
                conLogger.log(Level.FINE, LogUtils.EXCEPTION_THROWN, e);
            }
        }
        Singleton singleton = null;
        try {
            singleton = annElem.getAnnotation(javax.ejb.Singleton.class);
        } catch (Exception e) {
            if (logger.isLoggable(Level.FINE)) {
                conLogger.log(Level.FINE, LogUtils.EXCEPTION_THROWN, e);
            }
        }
        String name;
        if ((stateless != null) && ((stateless).name() == null || stateless.name().length() > 0)) {
            name = stateless.name();
        } else if ((singleton != null) && ((singleton).name() == null || singleton.name().length() > 0)) {
            name = singleton.name();
        } else {
            name = ((Class) annElem).getSimpleName();
        }
        EjbDescriptor ejb = ((EjbBundleDescriptor) bundleDesc).getEjbByName(name);
        endpoint.setEjbComponentImpl(ejb);
        ejb.setWebServiceEndpointInterfaceName(endpoint.getServiceEndpointInterface());
        if (endpoint.getEjbLink() == null)
            endpoint.setEjbLink(ejb.getName());
    }
    if (endpoint.getWsdlPort() == null) {
        if (targetNameSpace == null || targetNameSpace.length() == 0) {
            if (((Class) annElem).getPackage() != null) {
                StringTokenizer tokens = new StringTokenizer(((Class) annElem).getPackage().getName(), "String_Node_Str", false);
                if (tokens.hasMoreElements()) {
                    while (tokens.hasMoreElements()) {
                        if (targetNameSpace == null || targetNameSpace.length() == 0) {
                            targetNameSpace = tokens.nextElement().toString();
                        } else {
                            targetNameSpace = tokens.nextElement().toString() + "String_Node_Str" + targetNameSpace;
                        }
                    }
                } else {
                    targetNameSpace = ((Class) annElem).getPackage().getName();
                }
            } else {
                throw new AnnotationProcessorException(wsLocalStrings.getLocalString("String_Node_Str", "String_Node_Str"));
            }
            targetNameSpace = "String_Node_Str" + (targetNameSpace == null ? "String_Node_Str" : targetNameSpace + "String_Node_Str");
        }
        endpoint.setWsdlPort(new QName(targetNameSpace, portNameFromImplClass, "String_Node_Str"));
    }
    if (endpoint.getWsdlService() == null) {
        String serviceNameSpace = endpoint.getWsdlPort().getNamespaceURI();
        String serviceName = null;
        if ((svcNameFromImplClass != null) && (svcNameFromImplClass.length() != 0)) {
            serviceName = svcNameFromImplClass;
        } else {
            serviceName = newWS.getName();
        }
        endpoint.setWsdlService(new QName(serviceNameSpace, serviceName, "String_Node_Str"));
    }
    if ((((Class) origAnnElem).getAnnotation(javax.jws.HandlerChain.class)) == null) {
        return (new HandlerChainHandler()).processHandlerChainAnnotation(annInfo, annCtx, origAnnElem, (Class) origAnnElem, true);
    }
    return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
}

Output:
             for (WebComponentDescriptor wc : wcByImplName) {
-                for (WebServiceEndpoint wse : wsDesc.getEndpointsImplementedBy(wc)) {
+                if (!wsDesc.getEndpointsImplementedBy(wc).isEmpty()) {
                     logger.log(Level.SEVERE, LogUtils.WS_URLMAPPING_EXISTS, new Object[] { implClassFullName });


Input:
public void storeDescriptor(Map<String, String> props, String namePrefix) {
    if (namePrefix == null)
        namePrefix = "String_Node_Str";
    props.put(namePrefix + STUN_ADDRESS, getAddress());
    if (getPort() != -1)
        props.put(namePrefix + STUN_PORT, Integer.toString(getPort()));
    if (getUsername() != null && getUsername().length > 0)
        props.put(namePrefix + STUN_USERNAME, getUTF8String(getUsername()));
    if (getPassword() != null && getPassword().length > 0)
        props.put(namePrefix + STUN_PASSWORD, new String(getPassword()));
    props.put(namePrefix + STUN_IS_TURN_SUPPORTED, Boolean.toString(isTurnSupported()));
}

Output:
     if (getUsername() != null && getUsername().length > 0)
-        props.put(namePrefix + STUN_USERNAME, getUTF8String(getUsername()));
+        props.put(namePrefix + STUN_USERNAME, StringUtils.getUTF8String(getUsername()));
     if (getPassword() != null && getPassword().length > 0)


Input:
private void visitExtern(Node nameNode, Node parent) {
    String name = nameNode.getString();
    if (globalSymbolNamespace.equals(name) || SPECIAL_EXTERNS.contains(name)) {
        return;
    }
    Node windowPropAccess = IR.getprop(IR.name(WINDOW), IR.string(name));
    if (NodeUtil.isNameDeclaration(parent) && nameNode.hasOneChild()) {
        Node assign = IR.assign(windowPropAccess, nameNode.removeFirstChild());
        assign.setJSDocInfo(parent.getJSDocInfo());
        parent.replaceChild(nameNode, assign.srcrefTree(parent));
    } else {
        parent.replaceChild(nameNode, windowPropAccess.srcrefTree(nameNode));
    }
    compiler.reportChangeToEnclosingScope(parent);
}

Output:
     Node windowPropAccess = IR.getprop(IR.name(WINDOW), IR.string(name));
-    if (NodeUtil.isNameDeclaration(parent) && nameNode.hasOneChild()) {
-        Node assign = IR.assign(windowPropAccess, nameNode.removeFirstChild());
-        assign.setJSDocInfo(parent.getJSDocInfo());
-        parent.replaceChild(nameNode, assign.srcrefTree(parent));
-    } else {
-        parent.replaceChild(nameNode, windowPropAccess.srcrefTree(nameNode));
-    }
+    parent.replaceChild(nameNode, windowPropAccess.srcrefTree(nameNode));
     compiler.reportChangeToEnclosingScope(parent);


Input:
private void importConfiguration(ConfigData configData) {
    ImportConfigData importData = new ImportConfigData(configData);
    ISqlTransaction transaction = databasePlatform.getSqlTemplate().startSqlTransaction();
    if (importData.getProjectData().size() > 0 && importData.getProjectData().get(0).rows.size() > 0) {
        importProjectConfiguration(importData, transaction);
    }
    if (importData.getResourceData().size() > 0 && importData.getResourceData().get(0).rows.size() > 0) {
        importResourceConfiguration(importData, transaction);
    }
    if (importData.getModelData().size() > 0 && importData.getModelData().get(0).rows.size() > 0) {
        importModelConfiguration(importData, transaction);
    }
    if (importData.getFlowData().size() > 0 && importData.getFlowData().get(0).rows.size() > 0) {
        importFlowConfiguration(importData, transaction);
    }
    processDeletes(importData, transaction);
    transaction.commit();
}

Output:
     ISqlTransaction transaction = databasePlatform.getSqlTemplate().startSqlTransaction();
-    if (importData.getProjectData().size() > 0 && importData.getProjectData().get(0).rows.size() > 0) {
+    if (importData.getProjectData().size() > 0 && importData.getProjectData().get(PROJECT_IDX).rows.size() > 0) {
         importProjectConfiguration(importData, transaction);


Input:
public void clear() {
    this.previousCall = null;
    this.parameters.clear();
    this.statementCount = 0;
    this.executionCount = 0;
    this.queryTimeoutCache = DescriptorQueryManager.NoTimeout;
    this.lastCallAppended = null;
}

Output:
     this.previousCall = null;
-    this.parameters.clear();
+    this.parameters = new ArrayList();
     this.statementCount = 0;


Input:
public void setValue(String value) {
    if (nonNull(value) && !value.isEmpty())
        focus();
    inputElement.value = value;
}

Output:
         focus();
-    inputElement.value = value;
+    else
+        unfocus();
 }


Input:
private static String removeTimestamp(final String locationHeader) {
    int timestampIndex = getTimestampIndex(locationHeader);
    if (timestampIndex != -1) {
        return locationHeader.substring(0, timestampIndex);
    }
    return locationHeader.trim();
}

Output:
 private static String removeTimestamp(final String locationHeader) {
-    int timestampIndex = getTimestampIndex(locationHeader);
-    if (timestampIndex != -1) {
-        return locationHeader.substring(0, timestampIndex);
+    StringTokenizer st = new StringTokenizer(locationHeader);
+    int numToks = st.countTokens();
+    if (numToks == 1 || numToks == 2 || numToks == 3) {
+        return st.nextToken();
+    } else {
+        return null;
     }


Input:
public void beginDraw() {
    VERTEXCOUNT = 0;
    TRIANGLECOUNT = 0;
    FACECOUNT = 0;
    if (!primarySurface) {
        PGraphicsAndroid3D a3d = (PGraphicsAndroid3D) parent.g;
        a3d.saveGLState();
        for (int i = 0; i < a3d.lightCount; i++) {
            a3d.glLightDisable(i);
        }
        gl = a3d.gl;
        gl11 = a3d.gl11;
        gl11x = a3d.gl11x;
        gl11xp = a3d.gl11xp;
        OPENGL_VENDOR = a3d.OPENGL_VENDOR;
        OPENGL_RENDERER = a3d.OPENGL_RENDERER;
        OPENGL_VERSION = a3d.OPENGL_VERSION;
        npotTexSupported = a3d.npotTexSupported;
        mipmapSupported = a3d.mipmapSupported;
        matrixGetSupported = a3d.matrixGetSupported;
        vboSupported = a3d.vboSupported;
        fboSupported = a3d.fboSupported;
        maxTextureSize = a3d.maxTextureSize;
        maxPointSize = a3d.maxPointSize;
    }
    if (!settingsInited)
        defaultSettings();
    resetMatrix();
    report("String_Node_Str");
    vertexBuffer.rewind();
    colorBuffer.rewind();
    texCoordBuffer.rewind();
    normalBuffer.rewind();
    textureImage = null;
    textureImagePrev = null;
    blend(BLEND);
    if (hints[DISABLE_DEPTH_TEST]) {
        gl.glDisable(GL10.GL_DEPTH_TEST);
    } else {
        gl.glEnable(GL10.GL_DEPTH_TEST);
    }
    gl.glDepthFunc(GL10.GL_LEQUAL);
    gl.glFrontFace(GL10.GL_CW);
    gl.glViewport(0, 0, width, height);
    camera();
    perspective();
    lightCount = 0;
    lightFalloff(1, 0, 0);
    lightSpecular(0, 0, 0);
    gl.glEnable(GL10.GL_COLOR_MATERIAL);
    gl.glEnable(GL10.GL_NORMALIZE);
    gl.glEnable(GL10.GL_RESCALE_NORMAL);
    shapeFirst = 0;
    if (fbStack == null) {
        fbStack = new Stack<PFramebuffer>();
        screenFramebuffer = new PFramebuffer(parent, width, height, true);
        setFramebuffer(screenFramebuffer);
    }
    if (clear && primarySurface) {
        gl.glClearColor(0, 0, 0, 0);
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
    } else {
        if (fboSupported) {
            if (drawFramebuffer == null) {
                createDrawFramebuffer();
            }
            pushFramebuffer();
            setFramebuffer(drawFramebuffer);
            drawFramebuffer.addColorBuffer(drawTextures[drawIndex]);
            gl.glClearColor(0, 0, 0, 0);
            if (clear) {
                gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
            } else {
                gl.glClear(GL10.GL_DEPTH_BUFFER_BIT);
            }
            renderDrawTexture((drawIndex + 1) % 2);
        } else {
            if (screenTexID[0] == 0) {
                createScreenTexture();
            }
            gl.glClearColor(0, 0, 0, 0);
            gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
            drawScreenTexture();
        }
    }
    report("String_Node_Str");
}

Output:
     }
-    if (!settingsInited)
+    if (!settingsInited) {
         defaultSettings();


Input:
private Object txnalRemove(ClusterOperation operation, String name, Object key, Object value, long timeout) {
    ThreadContext threadContext = ThreadContext.get();
    TransactionImpl txn = threadContext.getCallContext().getTransaction();
    if (txn != null && txn.getStatus() == Transaction.TXN_STATUS_ACTIVE) {
        if (!txn.has(name, key)) {
            MLock mlock = new MLock();
            boolean locked = mlock.lockAndGetValue(name, key, timeout);
            if (!locked) {
                throwCME(key);
            }
            Object oldObject = null;
            Data oldValue = mlock.oldValue;
            if (oldValue != null) {
                oldObject = threadContext.toObject(oldValue);
            }
            int removedValueCount = 0;
            if (oldObject != null) {
                if (oldObject instanceof DistributedTimeoutException) {
                    return oldObject;
                }
                if (oldObject instanceof CMap.Values) {
                    CMap.Values values = (CMap.Values) oldObject;
                    removedValueCount = values.size();
                } else {
                    removedValueCount = 1;
                }
            }
            txn.attachRemoveOp(name, key, value, (oldObject == null), removedValueCount);
            return oldObject;
        } else {
            return txn.attachRemoveOp(name, key, value, false);
        }
    } else {
        Object oldValue = objectCall(operation, name, key, value, timeout, -1);
        if (oldValue != null) {
            if (oldValue instanceof AddressAwareException) {
                rethrowException(operation, (AddressAwareException) oldValue);
            }
            if (!(oldValue instanceof DistributedTimeoutException)) {
                backup(CONCURRENT_MAP_BACKUP_REMOVE);
            }
        }
        return oldValue;
    }
}

Output:
             if (oldValue != null) {
-                oldObject = threadContext.toObject(oldValue);
+                oldObject = threadContext.isClient() ? oldValue : threadContext.toObject(oldValue);
             }


Input:
public static URL resourceToURL(String location) throws MalformedURLException, ClassNotFoundException {
    Matcher jarMatcher = jarPattern.matcher(location);
    if (jarMatcher.matches()) {
        String resourceName = jarMatcher.group(1);
        return Object.class.getResource(resourceName);
    } else {
        if (location.indexOf(':') == -1) {
            location = "String_Node_Str" + location;
        }
        return new URL(location);
    }
}

Output:
         String resourceName = jarMatcher.group(1);
-        return Object.class.getResource(resourceName);
+        return ConfigurationManagerUtils.class.getResource(resourceName);
     } else {


Input:
public void createView() {
    if (prompt.isRequired()) {
        cg = new ChoiceGroup("String_Node_Str" + prompt.getLongText(), ChoiceGroup.MULTIPLE);
    } else {
        cg = new ChoiceGroup(prompt.getLongText(), ChoiceGroup.MULTIPLE);
    }
    Vector<SelectChoice> choices = prompt.getSelectChoices();
    Enumeration itr = choices.elements();
    int i = 0;
    boolean[] selectedFlags = new boolean[choices.size()];
    IAnswerData data = this.prompt.getAnswerValue();
    Vector<Selection> selected = null;
    if (data != null) {
        selected = (Vector<Selection>) data;
    }
    while (itr.hasMoreElements()) {
        SelectChoice choice = (SelectChoice) itr.nextElement();
        selectedFlags[i] = false;
        if (selected != null) {
            for (Selection s : selected) {
                if (s.xmlValue.equals(choice.selection().xmlValue)) {
                    selectedFlags[i] = true;
                }
            }
        }
        String label = this.prompt.getSelectChoiceText(choice);
        cg.append(label, null);
        i++;
    }
    cg.setSelectedFlags(selectedFlags);
    this.append(cg);
    this.addNavigationWidgets();
    if (prompt.getHelpText() != null) {
        setHint(prompt.getHelpText());
    }
}

Output:
     if (data != null) {
-        selected = (Vector<Selection>) data;
+        selected = (Vector<Selection>) new SelectMultiData().cast(data.uncast()).getValue();
     }


Input:
public Expression modelGroup(XSModelGroup group) {
    XSModelGroup.Compositor comp = group.getCompositor();
    if (comp == XSModelGroup.CHOICE) {
        Expression e = null;
        for (XSParticle p : group.getChildren()) {
            if (e == null)
                e = particle(p);
            else
                e = new Choice(e, particle(p));
        }
        return e;
    } else {
        Expression e = null;
        for (XSParticle p : group.getChildren()) {
            if (e == null)
                e = particle(p);
            else
                e = new Sequence(e, particle(p));
        }
        return e;
    }
}

Output:
     if (comp == XSModelGroup.CHOICE) {
-        Expression e = null;
+        Expression e = Expression.EPSILON;
         for (XSParticle p : group.getChildren()) {


Input:
protected void paintTag(GL gl, Tag tag, TaggedAxis1D taggedAxis, GlimpseBounds bounds) {
    int width = bounds.getWidth();
    int y = taggedAxis.valueToScreenPixel(tag.getValue());
    int xMin = getTagMinX(width);
    int xMid = getTagPointerMaxX(width);
    int xMax = getTagMaxX(width);
    float[] color = tagColor;
    Object colorValue = tag.getAttribute(Tag.TAG_COLOR_ATTR);
    if (colorValue != null && colorValue instanceof float[]) {
        color = (float[]) colorValue;
    }
    GL3 gl3 = gl.getGL3();
    FloatBuffer xy = tagXyVbo.mapFloats(gl, 18);
    xy.put(xMin).put(y);
    xy.put(xMid).put(y - tagHalfWidth);
    xy.put(xMid).put(y + tagHalfWidth);
    xy.put(xMax).put(y - tagHalfWidth);
    xy.put(xMid).put(y - tagHalfWidth);
    xy.put(xMid).put(y + tagHalfWidth);
    xy.put(xMid).put(y + tagHalfWidth);
    xy.put(xMax).put(y + tagHalfWidth);
    xy.put(xMax).put(y - tagHalfWidth);
    tagXyVbo.seal(gl);
    GLUtils.enableStandardBlending(gl);
    flatColorProg.begin(gl3);
    try {
        flatColorProg.setPixelOrtho(gl3, bounds);
        flatColorProg.setColor(gl3, color[0], color[1], color[2], 0.3f);
        flatColorProg.draw(gl3, GL.GL_TRIANGLES, tagXyVbo, 0, 9);
    } finally {
        flatColorProg.end(gl3);
        gl.glDisable(GL.GL_BLEND);
    }
    tagStyle.rgba = color;
    tagStyle.thickness_PX = tagPointerOutlineWidth;
    pathOutline.clear();
    pathOutline.moveTo(xMin, y);
    pathOutline.lineTo(xMid, y + tagHalfWidth);
    pathOutline.lineTo(xMax, y + tagHalfWidth);
    pathOutline.lineTo(xMax, y - tagHalfWidth);
    pathOutline.lineTo(xMid, y - tagHalfWidth);
    pathOutline.lineTo(xMin, y);
    progOutline.begin(gl3);
    try {
        progOutline.draw(gl3, tagStyle, pathOutline);
    } finally {
        progOutline.end(gl3);
    }
}

Output:
     try {
-        flatColorProg.setPixelOrtho(gl3, bounds);
-        flatColorProg.setColor(gl3, color[0], color[1], color[2], 0.3f);
-        flatColorProg.draw(gl3, GL.GL_TRIANGLES, tagXyVbo, 0, 9);
+        flatColorProg.begin(gl3);
+        try {
+            flatColorProg.setPixelOrtho(gl3, bounds);
+            flatColorProg.setColor(gl3, color[0], color[1], color[2], 0.3f);
+            flatColorProg.draw(gl3, GL.GL_TRIANGLES, tagXyVbo, 0, 9);
+        } finally {
+            flatColorProg.end(gl3);
+        }
+        tagStyle.rgba = color;
+        tagStyle.rgba[3] = 1.0f;
+        tagStyle.thickness_PX = tagPointerOutlineWidth;
+        pathOutline.clear();
+        pathOutline.moveTo(xMin, y);
+        pathOutline.lineTo(xMid, y + tagHalfWidth);
+        pathOutline.lineTo(xMax, y + tagHalfWidth);
+        pathOutline.lineTo(xMax, y - tagHalfWidth);
+        pathOutline.lineTo(xMid, y - tagHalfWidth);
+        pathOutline.closeLoop();
+        progOutline.begin(gl3);
+        try {
+            progOutline.setPixelOrtho(gl3, bounds);
+            progOutline.setViewport(gl3, bounds);
+            progOutline.draw(gl3, tagStyle, pathOutline);
+        } finally {
+            progOutline.end(gl3);
+        }
     } finally {


Input:
public void onBind(ChatMessage message) {
    super.onBind(message);
    String author;
    if (TextUtils.isEmpty(author = message.getActorDisplayName())) {
        messageAuthor.setText(author);
    } else {
        messageAuthor.setText(R.string.nc_nick_guest);
    }
}

Output:
     String author;
-    if (TextUtils.isEmpty(author = message.getActorDisplayName())) {
+    if (!TextUtils.isEmpty(author = message.getActorDisplayName())) {
         messageAuthor.setText(author);


Input:
public int getErrorCellValue() {
    ErrorValue errorValue = cell.getErrorValue();
    switch(errorValue.getCode()) {
        case ErrorValue.INVALID_FORMULA:
            return FormulaError.NA.getCode();
        case ErrorValue.INVALID_NAME:
            return FormulaError.NAME.getCode();
        case ErrorValue.INVALID_VALUE:
            return FormulaError.VALUE.getCode();
        default:
            return FormulaError.VALUE.getCode();
    }
}

Output:
         default:
-            return FormulaError.VALUE.getCode();
+            return errorValue.getCode();
     }


Input:
public void run() {
    double j = Math.random() * 20;
    int z = Long.valueOf((Math.round(j))).intValue();
    try {
        Thread.sleep(z);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    ImPrefsManager mgr = ImPrefsManager.getInstance();
    ImPreferences prefs = mgr.loadOrCreatePropertiesFor(ident);
    prefs.setAwarenessVisible(false);
    prefs.setOnlineTimeVisible(false);
    prefs.setRosterDefaultStatus(Presence.Mode.away.toString());
    prefs.setVisibleToOthers(false);
    mgr.updatePropertiesFor(ident, prefs);
    double rand = Math.random() * 3;
    int i = Long.valueOf((Math.round(rand))).intValue();
    if (i == 1) {
        PropertyManager.getInstance().deleteProperty(prefs.getDbProperty());
        System.out.println("String_Node_Str" + ident.getName());
    }
    DBFactory.getInstance().closeSession();
    System.out.println("String_Node_Str" + ident.getName());
}

Output:
     } catch (InterruptedException e) {
-        e.printStackTrace();
+        log.error("String_Node_Str", e);
     }


Input:
public void setColor(float[] color) {
    this.color = color;
    setDisplayListDirty();
}

Output:
     this.color = color;
-    setDisplayListDirty();
+    setDisplayListDirty(true);
 }


Input:
public boolean importData(JComponent comp, Transferable t) {
    boolean local = t.isDataFlavorSupported(LOCAL_NODE_TRANSFER_FLAVOR);
    DataFlavor flavor = local ? LOCAL_NODE_TRANSFER_FLAVOR : ToolUtil.SERIALIZED_WRAPPED_FLAVOR;
    Object data;
    try {
        data = t.getTransferData(local ? LOCAL_NODE_TRANSFER_FLAVOR : ToolUtil.SERIALIZED_WRAPPED_FLAVOR);
    } catch (Exception e) {
        log.warning("String_Node_Str", e);
        return false;
    }
    ConfigTreeNode node, onode = null;
    if (local) {
        NodeTransfer transfer = (NodeTransfer) data;
        node = transfer.cnode;
        onode = transfer.onode;
    } else {
        data = ((SerializableWrapper) data).getObject();
        if (!(data instanceof ConfigTreeNode)) {
            return false;
        }
        node = (ConfigTreeNode) data;
    }
    if (!node.verifyConfigClass(group.getConfigClass())) {
        return false;
    }
    ConfigTreeNode snode = getSelectedNode();
    if (onode != null && onode == snode) {
        return false;
    }
    ConfigTreeNode parent = (ConfigTreeNode) tree.getModel().getRoot();
    int index = parent.getChildCount();
    if (snode != null && snode.getParent() != null) {
        if (snode.getAllowsChildren()) {
            parent = snode;
            index = snode.getChildCount();
        } else {
            parent = (ConfigTreeNode) snode.getParent();
            int oidx = (onode == null) ? -1 : parent.getIndex(onode);
            int sidx = parent.getIndex(snode);
            index = sidx + ((oidx >= 0 && sidx > oidx) ? 1 : 0);
        }
    }
    node = (ConfigTreeNode) node.clone();
    ((DefaultTreeModel) tree.getModel()).insertNodeInto(node, parent, index);
    tree.setSelectionPath(new TreePath(node.getPath()));
    return true;
}

Output:
     ConfigTreeNode parent = (ConfigTreeNode) tree.getModel().getRoot();
-    int index = parent.getChildCount();
-    if (snode != null && snode.getParent() != null) {
-        if (snode.getAllowsChildren()) {
-            parent = snode;
-            index = snode.getChildCount();
-        } else {
-            parent = (ConfigTreeNode) snode.getParent();
-            int oidx = (onode == null) ? -1 : parent.getIndex(onode);
-            int sidx = parent.getIndex(snode);
-            index = sidx + ((oidx >= 0 && sidx > oidx) ? 1 : 0);
-        }
+    if (snode != null) {
+        parent = snode.getAllowsChildren() ? snode : (ConfigTreeNode) snode.getParent();
+    }
+    if (onode != null && onode.getParent() == parent) {
+        return false;
     }


Input:
private void showNearbyBeaconsFragment() {
    getFragmentManager().beginTransaction().add(R.id.homeScreen_container, NearbyDevicesFragment.newInstance()).commit();
}

Output:
 private void showNearbyBeaconsFragment() {
-    getFragmentManager().beginTransaction().add(R.id.homeScreen_container, NearbyDevicesFragment.newInstance()).commit();
+    getFragmentManager().beginTransaction().add(R.id.main_activity_container, NearbyDevicesFragment.newInstance()).commit();
 }


Input:
public HashMap<java.lang.reflect.Type, QName> getTypeToSchemaType() {
    HashMap<TypeMappingInfo, QName> typeMappingInfoToSchemaType = (HashMap) getTypeMappingInfoToSchemaType();
    HashMap<Type, QName> typeToSchemaTypeMap = new HashMap<Type, QName>(typeMappingInfoToSchemaType.size());
    java.util.Set<Entry<TypeMappingInfo, QName>> entrySet = typeMappingInfoToSchemaType.entrySet();
    for (Entry<TypeMappingInfo, QName> entry : entrySet) {
        typeToSchemaTypeMap.put(entry.getKey().getType(), entry.getValue());
    }
    return typeToSchemaTypeMap;
}

Output:
 public HashMap<java.lang.reflect.Type, QName> getTypeToSchemaType() {
-    HashMap<TypeMappingInfo, QName> typeMappingInfoToSchemaType = (HashMap) getTypeMappingInfoToSchemaType();
-    HashMap<Type, QName> typeToSchemaTypeMap = new HashMap<Type, QName>(typeMappingInfoToSchemaType.size());
-    java.util.Set<Entry<TypeMappingInfo, QName>> entrySet = typeMappingInfoToSchemaType.entrySet();
-    for (Entry<TypeMappingInfo, QName> entry : entrySet) {
-        typeToSchemaTypeMap.put(entry.getKey().getType(), entry.getValue());
+    if (typeToSchemaType == null) {
+        initTypeToSchemaType();
     }


Input:
protected OQueryContextNative query(OQueryContextNative record, QNPC e) {
    return record;
}

Output:
 protected OQueryContextNative query(OQueryContextNative record, QNPC e) {
-    return record;
+    return null;
 }


Input:
public void array_of_objects_should_be_read_and_tranformed_to_instance() {
    KeyValueObjectMapper keyValueObjectMapper = new KeyValueObjectMapper();
    Map<String, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(ARRAY_OF_OBJECTS_DATA.getBytes()));
    Set<User> readElements = (Set<User>) elements.get("String_Node_Str");
    assertThat(readElements, containsInAnyOrder(new User("String_Node_Str", "String_Node_Str"), new User("String_Node_Str", "String_Node_Str")));
}

Output:
     KeyValueObjectMapper keyValueObjectMapper = new KeyValueObjectMapper();
-    Map<String, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(ARRAY_OF_OBJECTS_DATA.getBytes()));
+    Map<Object, Object> elements = keyValueObjectMapper.readValues(new ByteArrayInputStream(ARRAY_OF_OBJECTS_DATA.getBytes()));
     Set<User> readElements = (Set<User>) elements.get("String_Node_Str");


Input:
public void subProductAttributesCopiedOntoPoolWhenCreatingNewPool() {
    Product product = TestUtil.createProduct(owner);
    Product subProduct = TestUtil.createProduct(owner);
    Subscription sub = TestUtil.createSubscription(owner, product);
    sub.setDerivedProduct(subProduct);
    String testAttributeKey = "String_Node_Str";
    String expectedAttributeValue = "String_Node_Str";
    subProduct.setAttribute(testAttributeKey, expectedAttributeValue);
    when(this.productAdapterMock.getProductById(anyString())).thenReturn(product);
    when(this.productAdapterMock.getProductById(anyString())).thenReturn(subProduct);
    List<Pool> pools = this.poolRules.createPools(sub);
    assertEquals(1, pools.size());
    Pool resultPool = pools.get(0);
    assertNotNull(resultPool.getDerivedProduct());
    assertTrue(resultPool.getDerivedProduct().hasAttribute(testAttributeKey));
    assertEquals(expectedAttributeValue, resultPool.getDerivedProduct().getAttributeValue(testAttributeKey));
}

Output:
     subProduct.setAttribute(testAttributeKey, expectedAttributeValue);
-    when(this.productAdapterMock.getProductById(anyString())).thenReturn(product);
-    when(this.productAdapterMock.getProductById(anyString())).thenReturn(subProduct);
+    when(this.productAdapterMock.getProductById(product.getOwner(), product.getId())).thenReturn(product);
+    when(this.productAdapterMock.getProductById(subProduct.getOwner(), subProduct.getId())).thenReturn(subProduct);
     List<Pool> pools = this.poolRules.createPools(sub);


Input:
public void testRequiresFromQueryAlias() {
    if (getDialect().requiresAliasForFromQuery()) {
        assertTrue(getDialect().allowsFromQuery());
    }
    if (!getDialect().allowsFromQuery()) {
        return;
    }
    String sql = dialectize("String_Node_Str");
    if (getDialect().requiresAliasForFromQuery()) {
        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", NEOVIEW_SYNTAX_ERROR, "String_Node_Str" };
        assertQueryFails(sql, errs);
    } else {
        assertQuerySucceeds(sql);
    }
}

Output:
     if (getDialect().requiresAliasForFromQuery()) {
-        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", NEOVIEW_SYNTAX_ERROR, "String_Node_Str" };
+        String[] errs = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", NEOVIEW_SYNTAX_ERROR, "String_Node_Str", "String_Node_Str" };
         assertQueryFails(sql, errs);


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
    setContentView(R.layout.conversation_list_screen);
    mQueryHandler = new ThreadListQueryHandler(getContentResolver());
    ListView listView = getListView();
    LayoutInflater inflater = LayoutInflater.from(this);
    ConversationHeaderView headerView = (ConversationHeaderView) inflater.inflate(R.layout.conversation_header, listView, false);
    headerView.bind(getString(R.string.new_message), getString(R.string.create_new_message));
    listView.addHeaderView(headerView, null, true);
    listView.setOnCreateContextMenuListener(mConvListOnCreateContextMenuListener);
    listView.setOnKeyListener(mThreadListKeyListener);
    initListAdapter();
    handleCreationIntent(getIntent());
    mHandler = new Handler();
    mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
    boolean checkedMessageLimits = mPrefs.getBoolean(CHECKED_MESSAGE_LIMITS, false);
    if (DEBUG)
        Log.v(TAG, "String_Node_Str" + checkedMessageLimits);
    if (!checkedMessageLimits || DEBUG) {
        runOneTimeStorageLimitCheckForLegacyMessages();
    }
}

Output:
     initListAdapter();
-    handleCreationIntent(getIntent());
+    mTitle = getString(R.string.app_label);
     mHandler = new Handler();


Input:
public String formatToCSV() {
    try {
        StringWriter sw = new StringWriter();
        CSVWriter writer = new CSVWriter(sw, ',', '"', '"', "String_Node_Str");
        for (String[] rows : rows) {
            writer.writeNext(rows);
        }
        writer.close();
        return sw.toString();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

Output:
         CSVWriter writer = new CSVWriter(sw, ',', '"', '"', "String_Node_Str");
-        for (String[] rows : rows) {
-            writer.writeNext(rows);
+        for (String[] row : rows) {
+            writer.writeNext(row);
         }


Input:
private String format(String string) {
    if (canBeNull() && string == null) {
        return LABEL_NULL;
    }
    if (StringUtil.isBlank(string) || formatCategroy == null) {
        return string;
    }
    try {
        String pattern = formatPattern;
        if (formatPattern == null) {
            if (DesignChoiceConstants.STRING_FORMAT_TYPE_CUSTOM.equals(formatCategroy) || DesignChoiceConstants.DATETIEM_FORMAT_TYPE_CUSTOM.equals(formatCategroy) || DesignChoiceConstants.NUMBER_FORMAT_TYPE_CUSTOM.equals(formatCategroy)) {
                return string;
            }
            pattern = formatCategroy;
        }
        if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(getSelectedDataType())) {
            DateFormatter formatter = new DateFormatter(STANDARD_DATE_TIME_PATTERN);
            Date date = formatter.parse(string);
            formatter.applyPattern(pattern);
            string = formatter.format(date);
        } else if (DesignChoiceConstants.PARAM_TYPE_FLOAT.equals(getSelectedDataType())) {
            string = new NumberFormatter(pattern).format(DataTypeUtil.toDouble(string).doubleValue());
        } else if (DesignChoiceConstants.PARAM_TYPE_DECIMAL.equals(getSelectedDataType())) {
            string = new NumberFormatter(pattern).format(DataTypeUtil.toBigDecimal(string));
        } else if (DesignChoiceConstants.PARAM_TYPE_STRING.equals(getSelectedDataType())) {
            string = new StringFormatter(pattern).format(string);
        }
    } catch (BirtException e) {
    } catch (ParseException e) {
    }
    return string;
}

Output:
         if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(getSelectedDataType())) {
-            DateFormatter formatter = new DateFormatter(STANDARD_DATE_TIME_PATTERN);
-            Date date = formatter.parse(string);
-            formatter.applyPattern(pattern);
+            Date date = DataTypeUtil.toDate(string, ULocale.US);
+            DateFormatter formatter = new DateFormatter(pattern);
             string = formatter.format(date);


Input:
private String _linkMoML(NamedObj container, StringBuffer moml, StringBuffer failmoml, NamedObj linkHead, NamedObj linkTail) throws Exception {
    if (linkHead != null && linkTail != null) {
        NamedObj head = (NamedObj) getSemanticObject(linkHead);
        NamedObj tail = (NamedObj) getSemanticObject(linkTail);
        if (head instanceof ComponentPort && tail instanceof ComponentPort) {
            ComponentPort headPort = (ComponentPort) head;
            ComponentPort tailPort = (ComponentPort) tail;
            String relationName = getToplevel().uniqueName("String_Node_Str");
            if (getToplevel() != container) {
                String contextString = "String_Node_Str" + getToplevel().getName(container) + "String_Node_Str";
                moml.append(contextString);
                failmoml.append(contextString);
            }
            moml.append("String_Node_Str" + relationName + "String_Node_Str");
            moml.append("String_Node_Str" + headPort.getName(getToplevel()) + "String_Node_Str" + relationName + "String_Node_Str");
            moml.append("String_Node_Str" + tailPort.getName(getToplevel()) + "String_Node_Str" + relationName + "String_Node_Str");
            failmoml.append("String_Node_Str" + headPort.getName(getToplevel()) + "String_Node_Str" + relationName + "String_Node_Str");
            failmoml.append("String_Node_Str" + tailPort.getName(getToplevel()) + "String_Node_Str" + relationName + "String_Node_Str");
            failmoml.append("String_Node_Str" + relationName + "String_Node_Str");
            if (getToplevel() != container) {
                moml.append("String_Node_Str");
                failmoml.append("String_Node_Str");
            }
            return relationName;
        } else if (head instanceof ComponentPort && linkTail instanceof Vertex) {
            moml.append("String_Node_Str" + head.getName(container) + "String_Node_Str" + tail.getName(container) + "String_Node_Str");
            return tail.getName(container);
        } else if (tail instanceof ComponentPort && linkHead instanceof Vertex) {
            moml.append("String_Node_Str" + tail.getName(container) + "String_Node_Str" + head.getName(container) + "String_Node_Str");
            return head.getName(container);
        } else {
            throw new RuntimeException("String_Node_Str" + "String_Node_Str" + head + "String_Node_Str" + tail);
        }
    } else {
        return null;
    }
}

Output:
             }
-            return relationName;
+            if (getToplevel() != container) {
+                return getToplevel().getName(container) + "String_Node_Str" + relationName;
+            } else {
+                return relationName;
+            }
         } else if (head instanceof ComponentPort && linkTail instanceof Vertex) {


Input:
public String applyColour(Color[] palette, Color oldBackground, Color oldForeground, boolean[] oldFormat, Color newBackground, Color newForeground, boolean[] newFormat) {
    StringBuilder rc = new StringBuilder();
    int colourindex1back = -1, colourindex2back = -1;
    int colourindex1fore = -1, colourindex2fore = -1;
    if ((oldBackground != null) && (newBackground == null))
        rc.append("String_Node_Str");
    else if ((oldBackground == null) || (oldBackground.equals(newBackground) == false))
        if (newBackground != null) {
            colourindex1back = matchColour(newBackground, palette, 16, 256, this.chroma);
            if (this.fullcolour)
                colourindex2back = this.colourful ? matchColour(this.fullcolour ? newBackground : palette[colourindex1back], this.palette, 1, 6, this.chroma) : 7;
            else
                colourindex2back = colourindex1back;
        }
    if ((oldForeground != null) && (newForeground == null))
        rc.append("String_Node_Str");
    else if ((oldForeground == null) || (oldForeground.equals(newForeground) == false))
        if (newForeground != null) {
            colourindex1fore = matchColour(newForeground, palette, 16, 256, this.chroma);
            if (this.fullcolour) {
                int s = ((newFormat.length > 9) && newFormat[9]) ? 0 : (newFormat[0] ? 9 : 1);
                int e = ((newFormat.length > 9) && newFormat[9]) ? 16 : (s + 5);
                colourindex2fore = this.colourful ? matchColour(this.fullcolour ? newForeground : palette[colourindex1fore], this.palette, s, e, this.chroma) : 15;
                if (((colourindex2fore == 0) && (newBackground == null)) || (colourindex2fore == colourindex2back))
                    colourindex2fore ^= 8;
            } else
                colourindex2fore = colourindex1fore;
        }
    if (colourindex2back != -1)
        if (this.fullcolour) {
            Color colour = newBackground;
            rc.append("String_Node_Str");
            rc.append(colourindex2back);
            rc.append("String_Node_Str");
            rc.append("String_Node_Str".charAt(colour.getRed() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getRed() & 15));
            rc.append('/');
            rc.append("String_Node_Str".charAt(colour.getGreen() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getGreen() & 15));
            rc.append('/');
            rc.append("String_Node_Str".charAt(colour.getBlue() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getBlue() & 15));
            rc.append("String_Node_Str");
            rc.append(colourindex2back);
            palette[colourindex2back] = colour;
        } else if (colourindex2back < 16) {
            rc.append("String_Node_Str");
            rc.append(colourindex2back);
        } else {
            rc.append("String_Node_Str");
            rc.append(colourindex2back);
        }
    if (colourindex2fore != -1)
        if (this.fullcolour) {
            Color colour = newForeground;
            rc.append("String_Node_Str");
            rc.append(colourindex2fore);
            rc.append("String_Node_Str");
            rc.append("String_Node_Str".charAt(colour.getRed() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getRed() & 15));
            rc.append('/');
            rc.append("String_Node_Str".charAt(colour.getGreen() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getGreen() & 15));
            rc.append('/');
            rc.append("String_Node_Str".charAt(colour.getBlue() >>> 4));
            rc.append("String_Node_Str".charAt(colour.getBlue() & 15));
            rc.append("String_Node_Str");
            rc.append(colourindex2fore & 7);
            palette[colourindex2fore] = colour;
        } else if (colourindex2fore < 16) {
            rc.append("String_Node_Str");
            rc.append(colourindex2fore);
        } else {
            rc.append("String_Node_Str");
            rc.append(colourindex2fore);
        }
    boolean _ = newFormat[0];
    newFormat[0] = (colourindex2fore == -1) ? oldFormat[0] : ((8 <= colourindex2fore) && (colourindex2fore < 16));
    for (int i = 0; i < 9; i++) if (newFormat[i] ^ oldFormat[i])
        if ((oldFormat[i] = newFormat[i])) {
            rc.append("String_Node_Str");
            rc.append(i + 1);
        } else {
            rc.append("String_Node_Str");
            rc.append(i + 1);
        }
    newFormat[0] = _;
    String _rc = rc.toString();
    if (_rc.isEmpty())
        return "String_Node_Str";
    return ("String_Node_Str" + _rc.substring(1)).replace("String_Node_Str", "String_Node_Str") + "String_Node_Str";
}

Output:
             rc.append("String_Node_Str");
-            rc.append(colourindex2fore);
+            rc.append(colourindex2fore & 7);
         } else {


Input:
public static Exporter<RegistryService> export(int port) {
    RegistryService registryService = new SimpleRegistryService();
    return protocol.export(proxyFactory.getInvoker(registryService, RegistryService.class, new URL("String_Node_Str", NetUtils.getLocalHost(), port, RegistryService.class.getName()).setPath(RegistryService.class.getName()).addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName()).addParameter(Constants.VERSION_KEY, "String_Node_Str").addParameter(RpcConstants.CLUSTER_STICKY_KEY, "String_Node_Str").addParameter(RpcConstants.CALLBACK_INSTANCES_LIMIT_KEY, "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str")));
}

Output:
     RegistryService registryService = new SimpleRegistryService();
-    return protocol.export(proxyFactory.getInvoker(registryService, RegistryService.class, new URL("String_Node_Str", NetUtils.getLocalHost(), port, RegistryService.class.getName()).setPath(RegistryService.class.getName()).addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName()).addParameter(Constants.VERSION_KEY, "String_Node_Str").addParameter(RpcConstants.CLUSTER_STICKY_KEY, "String_Node_Str").addParameter(RpcConstants.CALLBACK_INSTANCES_LIMIT_KEY, "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str")));
+    return protocol.export(proxyFactory.getInvoker(registryService, RegistryService.class, new URL("String_Node_Str", NetUtils.getLocalHost(), port, RegistryService.class.getName()).setPath(RegistryService.class.getName()).addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName()).addParameter(RpcConstants.CLUSTER_STICKY_KEY, "String_Node_Str").addParameter(RpcConstants.CALLBACK_INSTANCES_LIMIT_KEY, "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str").addParameter("String_Node_Str", "String_Node_Str")));
 }


Input:
public void collect(JSModule module, Scope scope, Node n) {
    Node parent = n.getParent();
    String name;
    boolean isSet = false;
    Name.Type type = Name.Type.OTHER;
    boolean isPropAssign = false;
    switch(n.getType()) {
        case Token.GETTER_DEF:
        case Token.SETTER_DEF:
        case Token.STRING_KEY:
            name = null;
            if (parent != null && parent.isObjectLit()) {
                name = getNameForObjLitKey(n);
            }
            if (name == null) {
                return;
            }
            isSet = true;
            switch(n.getType()) {
                case Token.STRING_KEY:
                    type = getValueType(n.getFirstChild());
                    break;
                case Token.GETTER_DEF:
                    type = Name.Type.GET;
                    break;
                case Token.SETTER_DEF:
                    type = Name.Type.SET;
                    break;
                default:
                    throw new IllegalStateException("String_Node_Str" + n);
            }
            break;
        case Token.NAME:
            if (parent != null) {
                switch(parent.getType()) {
                    case Token.VAR:
                        isSet = true;
                        Node rvalue = n.getFirstChild();
                        type = rvalue == null ? Name.Type.OTHER : getValueType(rvalue);
                        break;
                    case Token.ASSIGN:
                        if (parent.getFirstChild() == n) {
                            isSet = true;
                            type = getValueType(n.getNext());
                        }
                        break;
                    case Token.GETPROP:
                        return;
                    case Token.FUNCTION:
                        Node gramps = parent.getParent();
                        if (gramps == null || NodeUtil.isFunctionExpression(parent)) {
                            return;
                        }
                        isSet = true;
                        type = Name.Type.FUNCTION;
                        break;
                    case Token.CATCH:
                    case Token.INC:
                    case Token.DEC:
                        isSet = true;
                        type = Name.Type.OTHER;
                        break;
                    default:
                        if (NodeUtil.isAssignmentOp(parent) && parent.getFirstChild() == n) {
                            isSet = true;
                            type = Name.Type.OTHER;
                        }
                }
            }
            name = n.getString();
            break;
        case Token.GETPROP:
            if (parent != null) {
                switch(parent.getType()) {
                    case Token.ASSIGN:
                        if (parent.getFirstChild() == n) {
                            isSet = true;
                            type = getValueType(n.getNext());
                            isPropAssign = true;
                        }
                        break;
                    case Token.INC:
                    case Token.DEC:
                        isSet = true;
                        type = Name.Type.OTHER;
                        break;
                    case Token.GETPROP:
                        return;
                    default:
                        if (NodeUtil.isAssignmentOp(parent) && parent.getFirstChild() == n) {
                            isSet = true;
                            type = Name.Type.OTHER;
                        }
                }
            }
            name = n.getQualifiedName();
            if (name == null) {
                return;
            }
            break;
        default:
            return;
    }
    if (!isGlobalNameReference(name, scope)) {
        return;
    }
    if (isSet) {
        if (isGlobalScope(scope)) {
            handleSetFromGlobal(module, scope, n, parent, name, isPropAssign, type);
        } else {
            handleSetFromLocal(module, scope, n, parent, name);
        }
    } else {
        handleGet(module, scope, n, parent, name);
    }
}

Output:
                 case Token.STRING_KEY:
-                    type = getValueType(n.getFirstChild());
+                    if (n.isQuotedString()) {
+                        return;
+                    } else {
+                        type = getValueType(n.getFirstChild());
+                    }
                     break;


Input:
private void onCatchFirePreCheckOther(World world, BlockPos pos, int chance, Random random, int age, EnumFacing facing, CallbackInfo callbackInfo) {
    if (!world.isRemote) {
        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos, NamedCause.of(NamedCause.FIRE_SPREAD, world)).isCancelled()) {
            callbackInfo.cancel();
        }
    }
}

Output:
     if (!world.isRemote) {
-        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos, NamedCause.of(NamedCause.FIRE_SPREAD, world)).isCancelled()) {
+        Sponge.getCauseStackManager().addContext(EventContextKeys.FIRE_SPREAD, (org.spongepowered.api.world.World) world);
+        if (SpongeCommonEventFactory.callChangeBlockEventPre((IMixinWorldServer) world, pos).isCancelled()) {
             callbackInfo.cancel();


Input:
protected float sdsdot(int N, float alpha, INDArray X, int incX, INDArray Y, int incY) {
    return 0;
}

Output:
 protected float sdsdot(int N, float alpha, INDArray X, int incX, INDArray Y, int incY) {
-    return 0;
+    throw new UnsupportedOperationException();
 }


Input:
protected void generateXMLSchema(ITypeModel t, String collectionTag) {
    if (t instanceof ReflectionType) {
        Class<?> element = ((ReflectionType) t).getElement();
        generateXSDForClass(element);
    } else if (t.getFullyQualifiedName() != null && classLoader != null) {
        try {
            Class<?> element = classLoader.loadClass(t.getFullyQualifiedName());
            generateXSDForClass(element);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    afterSchemaGen(t, collectionTag);
}

Output:
         Class<?> element = ((ReflectionType) t).getElement();
-        generateXSDForClass(element);
+        xsdSchema = generateXSDForClass(element);
     } else if (t.getFullyQualifiedName() != null && classLoader != null) {


Input:
public boolean apply(Game game, Ability source) {
    Permanent target = game.getPermanent(getTargetPointer().getFirst(game, source));
    Player controller = game.getPlayer(source.getControllerId());
    if (target != null && controller != null) {
        int toughness = target.getToughness().getValue();
        target.destroy(source.getSourceId(), game, false);
        if (toughness > 0) {
            controller.loseLife(toughness, game);
        }
        return true;
    }
    return false;
}

Output:
         if (toughness > 0) {
-            controller.loseLife(toughness, game);
+            controller.loseLife(toughness, game, false);
         }


Input:
public Collection<String> getKeyPropertyNames() throws EdmException {
    return entityType.getKey().getKeys().keySet();
}

Output:
 public Collection<String> getKeyPropertyNames() throws EdmException {
-    return entityType.getKey().getKeys().keySet();
+    if (entityType.getKey() == null)
+        return Collections.<String>emptyList();
+    else
+        return entityType.getKey().getKeys().keySet();
 }


Input:
public List<Category> parseCategories(String categoryRespStr) throws JSONException {
    List<Category> resultList = null;
    JSONObject categories = new JSONObject(categoryRespStr);
    resultList = new ArrayList<Category>();
    Category tempCategory = null;
    JSONArray dishArray = categories.getJSONArray("String_Node_Str");
    for (int i = 0; i < dishArray.length(); i++) {
        tempCategory = new Category();
        JSONObject dishObj = dishArray.getJSONObject(i);
        tempCategory.setId(Integer.parseInt(dishObj.getString("String_Node_Str")));
        tempCategory.setName(dishObj.getString("String_Node_Str"));
        tempCategory.setDescription(dishObj.getString("String_Node_Str"));
        tempCategory.setSortOrder(Integer.parseInt(dishObj.getString("String_Node_Str")));
        resultList.add(tempCategory);
    }
    return resultList;
}

Output:
         JSONObject dishObj = dishArray.getJSONObject(i);
-        tempCategory.setId(Integer.parseInt(dishObj.getString("String_Node_Str")));
+        tempCategory.setId(dishObj.getInt("String_Node_Str"));
         tempCategory.setName(dishObj.getString("String_Node_Str"));


Input:
public void addNetTotalOutMegs(Long netExternalOutMegs) {
    if (netExternalOutMegs != null) {
        this.netExternalOutMegs = this.netExternalOutMegs + netExternalOutMegs;
    }
}

Output:
 public void addNetTotalOutMegs(Long netExternalOutMegs) {
-    if (netExternalOutMegs != null) {
-        this.netExternalOutMegs = this.netExternalOutMegs + netExternalOutMegs;
-    }
+    this.netTotalOutMegs = plus(this.netTotalOutMegs, netTotalOutMegs);
 }


Input:
public File getResourceFile(String filename) {
    File f = null;
    logSpecial("String_Node_Str" + filename, null);
    if (filename == null)
        return null;
    f = new File(customDirectory, filename);
    if (customDirectory != null && f.canRead()) {
        logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
        return f;
    } else {
        logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
    }
    URL fileUrl = ClassLoader.getSystemResource(DefaultSecurityConfiguration.resourceDirectory + "String_Node_Str" + filename);
    if (fileUrl != null) {
        String fileLocation = fileUrl.getFile();
        f = new File(fileLocation);
        if (f.exists()) {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
            return f;
        } else {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
        }
    } else {
        logSpecial("String_Node_Str" + DefaultSecurityConfiguration.resourceDirectory + "String_Node_Str" + filename, null);
    }
    fileUrl = ClassLoader.getSystemResource("String_Node_Str" + filename);
    if (fileUrl != null) {
        String fileLocation = fileUrl.getFile();
        f = new File(fileLocation);
        if (f.exists()) {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
            return f;
        } else {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
        }
    } else {
        logSpecial("String_Node_Str" + "String_Node_Str" + filename, null);
    }
    fileUrl = ClassLoader.getSystemResource(filename);
    if (fileUrl != null) {
        String fileLocation = fileUrl.getFile();
        f = new File(fileLocation);
        if (f.exists()) {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
            return f;
        } else {
            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
        }
    } else {
        logSpecial("String_Node_Str" + filename, null);
    }
    f = new File(userDirectory, filename);
    if (userDirectory != null && f.exists()) {
        logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
        return f;
    } else {
        logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
    }
    return null;
}

Output:
     if (fileUrl != null) {
-        String fileLocation = fileUrl.getFile();
-        f = new File(fileLocation);
-        if (f.exists()) {
-            logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
-            return f;
+        String resource = fileUrl.getFile();
+        logSpecial("String_Node_Str" + resource, null);
+        URI uri = null;
+        try {
+            uri = new URI("String_Node_Str" + resource);
+        } catch (Exception e) {
+        }
+        if (uri != null) {
+            f = new File(uri);
+            if (f.exists()) {
+                logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
+                return f;
+            } else {
+                logSpecial("String_Node_Str" + f.getAbsolutePath(), null);
+            }
         } else {


Input:
private boolean route(BlockBuffer buffer, Net net, Net.Terminal source, Net.Terminal dest, boolean reverse) {
    if (source.x == dest.x && source.y == dest.y && source.z == dest.z) {
        return true;
    }
    HashMap<Long, Node> explored = new HashMap<Long, Node>();
    PriorityQueue<Node> queue = new PriorityQueue<Node>();
    queue.add(new Node(0, new Net.Wire(source.x, source.y, source.z, false, 0), null));
    int count = 0;
    while (!queue.isEmpty()) {
        Node node = queue.remove();
        if (isDest(node.wire.x, node.wire.y, node.wire.z, buffer, net, dest)) {
            commitRoute(buffer, net, node);
            return true;
        }
        boolean needRepeater = false;
        count++;
        if (count == 1000) {
            log2("String_Node_Str");
            commitRoute(buffer, net, node);
            return true;
        }
        if (queue.size() > 2000000) {
            log2("String_Node_Str");
            return false;
        }
        for (int i = 0; i < 12; i++) {
            int x = node.wire.x;
            int y = node.wire.y;
            int z = node.wire.z;
            switch(i) {
                case 0:
                    x++;
                    break;
                case 1:
                    x--;
                    break;
                case 2:
                    z++;
                    break;
                case 3:
                    z--;
                    break;
                case 4:
                    if (needRepeater) {
                        break;
                    }
                    x++;
                    y++;
                    break;
                case 5:
                    x--;
                    y++;
                    break;
                case 6:
                    z++;
                    y++;
                    break;
                case 7:
                    z--;
                    y++;
                    break;
                case 8:
                    x++;
                    y--;
                    break;
                case 9:
                    x--;
                    y--;
                    break;
                case 10:
                    z++;
                    y--;
                    break;
                case 11:
                    z--;
                    y--;
                    break;
            }
            if (y != node.wire.y && isDest(x, y, z, buffer, net, dest)) {
                break;
            }
            if (canPlaceWire(buffer, net, node, dest, x, y, z)) {
                int g;
                if (i >= 4) {
                    g = 1;
                } else {
                    g = 1;
                }
                long hash = getCoordinateHash(buffer, x, y, z);
                Node child = explored.get(hash);
                if (child != null) {
                    if (child.cost > node.cost + g) {
                        queue.remove(child);
                        child.cost = node.cost + g;
                        queue.add(child);
                    }
                } else {
                    child = new Node(node.cost + g, new Wire(x, y, z, false, 0), node);
                    queue.add(child);
                    explored.put(hash, child);
                }
            }
        }
    }
    return false;
}

Output:
         if (isDest(node.wire.x, node.wire.y, node.wire.z, buffer, net, dest)) {
-            commitRoute(buffer, net, node);
+            commitRoute(buffer, net, node, true);
             return true;


Input:
private File createZipFileIfNeeded(ArrayList<String> binDirFiles) throws IOException, ZipFileException {
    String baseRootValue = getSystemProperty(SystemPropertyConstants.PRODUCT_ROOT_PROPERTY);
    File installRoot = new File(baseRootValue);
    File zipFileLocation = null;
    File glassFishZipFile = null;
    if (archive != null) {
        archive = archive.replace('\\', '/');
        archiveName = archive.substring(archive.lastIndexOf("String_Node_Str") + 1, archive.length());
        zipFileLocation = new File(archive.substring(0, archive.lastIndexOf("String_Node_Str")));
        glassFishZipFile = new File(archive);
        if (glassFishZipFile.exists() && !create) {
            logger.finer("String_Node_Str" + archive);
            delete = false;
            return glassFishZipFile;
        } else if (!zipFileLocation.canWrite()) {
            throw new IOException("String_Node_Str" + archive);
        }
    } else {
        zipFileLocation = new File("String_Node_Str");
        if (!zipFileLocation.canWrite()) {
            zipFileLocation = new File(System.getProperty("String_Node_Str"));
        }
        glassFishZipFile = File.createTempFile("String_Node_Str", "String_Node_Str", zipFileLocation);
        String filePath = glassFishZipFile.getCanonicalPath();
        filePath = filePath.replaceAll("String_Node_Str", "String_Node_Str");
        archiveName = filePath.substring(filePath.lastIndexOf("String_Node_Str") + 1, filePath.length());
    }
    FileListerRelative lister = new FileListerRelative(installRoot);
    lister.keepEmptyDirectories();
    String[] files = lister.getFiles();
    List<String> resultFiles1 = Arrays.asList(files);
    ArrayList<String> resultFiles = new ArrayList<String>(resultFiles1);
    logger.finer("String_Node_Str" + resultFiles.size());
    Iterator<String> iter = resultFiles.iterator();
    while (iter.hasNext()) {
        String fileName = iter.next();
        String fPath = fileName.substring(fileName.lastIndexOf("String_Node_Str") + 1);
        if (fPath.equals(glassFishZipFile.getName())) {
            logger.finer("String_Node_Str" + fileName);
            iter.remove();
            continue;
        }
        if (fileName.contains("String_Node_Str") || fileName.contains("String_Node_Str")) {
            iter.remove();
        } else if (isFileWithinBinDirectory(fileName)) {
            binDirFiles.add(fileName);
        }
    }
    logger.finer("String_Node_Str" + resultFiles.size());
    String[] filesToZip = new String[resultFiles.size()];
    filesToZip = resultFiles.toArray(filesToZip);
    ZipWriter writer = new ZipWriter(FileUtils.safeGetCanonicalPath(glassFishZipFile), installRoot.toString(), filesToZip);
    writer.safeWrite();
    logger.info("String_Node_Str" + FileUtils.safeGetCanonicalPath(glassFishZipFile));
    return glassFishZipFile;
}

Output:
         if (glassFishZipFile.exists() && !create) {
-            logger.finer("String_Node_Str" + archive);
+            if (logger.isLoggable(Level.FINER))
+                logger.finer("String_Node_Str" + archive);
             delete = false;


Input:
public String getContent(ActionReportResult proxy) {
    RestActionReporter ar = (RestActionReporter) proxy.getActionReport();
    StringBuilder result = new StringBuilder(ProviderUtil.getHtmlHeader(getBaseUri()));
    String message = ar.getCombinedMessage();
    if (message != null) {
        result.append("String_Node_Str").append(message).append("String_Node_Str");
    }
    if (proxy.isError()) {
        result.append("String_Node_Str").append(ar.getActionDescription()).append("String_Node_Str").append(proxy.getErrorMessage());
    } else {
        final Map<String, String> childResources = (Map<String, String>) ar.getExtraProperties().get("String_Node_Str");
        final List<Map<String, String>> commands = (List<Map<String, String>>) ar.getExtraProperties().get("String_Node_Str");
        final MethodMetaData postMetaData = proxy.getMetaData().getMethodMetaData("String_Node_Str");
        final MethodMetaData deleteMetaData = proxy.getMetaData().getMethodMetaData("String_Node_Str");
        final MethodMetaData getMetaData = proxy.getMetaData().getMethodMetaData("String_Node_Str");
        final ConfigBean entity = proxy.getEntity();
        if ((proxy.getCommandDisplayName() != null) && (getMetaData != null)) {
            if (entity == null) {
                result.append(processReport(ar));
            }
        }
        if ((postMetaData != null) && (entity == null)) {
            String postCommand = getHtmlRespresentationsForCommand(postMetaData, "String_Node_Str", (proxy.getCommandDisplayName() == null) ? "String_Node_Str" : proxy.getCommandDisplayName(), uriInfo.get());
            result.append(getHtmlForComponent(postCommand, "String_Node_Str" + ar.getActionDescription(), "String_Node_Str"));
        }
        if ((deleteMetaData != null) && (entity == null)) {
            String deleteCommand = getHtmlRespresentationsForCommand(deleteMetaData, "String_Node_Str", (proxy.getCommandDisplayName() == null) ? "String_Node_Str" : proxy.getCommandDisplayName(), uriInfo.get());
            result.append(getHtmlForComponent(deleteCommand, "String_Node_Str" + ar.getActionDescription(), "String_Node_Str"));
        }
        if ((getMetaData != null) && (entity == null) && (proxy.getCommandDisplayName() != null)) {
            String getCommand = getHtmlRespresentationsForCommand(getMetaData, "String_Node_Str", (proxy.getCommandDisplayName() == null) ? "String_Node_Str" : proxy.getCommandDisplayName(), uriInfo.get());
            result.append(getHtmlForComponent(getCommand, "String_Node_Str" + ar.getActionDescription(), "String_Node_Str"));
        }
        if (entity != null) {
            String attributes = ProviderUtil.getHtmlRepresentationForAttributes(proxy.getEntity(), uriInfo.get());
            result.append(ProviderUtil.getHtmlForComponent(attributes, ar.getActionDescription() + "String_Node_Str", "String_Node_Str"));
            String deleteCommand = ProviderUtil.getHtmlRespresentationsForCommand(proxy.getMetaData().getMethodMetaData("String_Node_Str"), "String_Node_Str", (proxy.getCommandDisplayName() == null) ? "String_Node_Str" : proxy.getCommandDisplayName(), uriInfo.get());
            result.append(ProviderUtil.getHtmlForComponent(deleteCommand, "String_Node_Str" + entity.model.getTagName(), "String_Node_Str"));
        } else if (proxy.getLeafContent() != null) {
            String content = "String_Node_Str" + uriInfo.get().getAbsolutePath().toString() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + proxy.getLeafContent().name + "String_Node_Str" + proxy.getLeafContent().name + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + proxy.getLeafContent().name + "String_Node_Str" + proxy.getLeafContent().value + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
            result.append(content);
        } else {
            final Map vals = (Map) ar.getExtraProperties().get("String_Node_Str");
            if ((vals != null) && (!vals.isEmpty())) {
                result.append("String_Node_Str");
                for (Map.Entry entry : (Set<Map.Entry>) vals.entrySet()) {
                    Object object = entry.getValue();
                    if (object == null) {
                    } else if (object instanceof Collection) {
                        if (!((Collection) object).isEmpty()) {
                            Collection c = ((Collection) object);
                            Iterator i = c.iterator();
                            result.append("String_Node_Str").append(entry.getKey());
                            result.append("String_Node_Str");
                            while (i.hasNext()) {
                                result.append("String_Node_Str").append(getHtmlRepresentation(i.next())).append("String_Node_Str");
                            }
                            result.append("String_Node_Str");
                            result.append("String_Node_Str");
                        }
                    } else if (object instanceof Map) {
                        if (!((Map) object).isEmpty()) {
                            Map m = (Map) object;
                            if (vals.size() != 1) {
                                result.append("String_Node_Str").append("String_Node_Str" + uriInfo.get().getAbsolutePath().toString() + "String_Node_Str" + entry.getKey() + "String_Node_Str" + entry.getKey() + "String_Node_Str");
                            } else {
                                result.append("String_Node_Str").append(entry.getKey());
                            }
                            result.append("String_Node_Str");
                            for (Map.Entry anEntry : (Set<Map.Entry>) m.entrySet()) {
                                final String htmlRepresentation = getHtmlRepresentation(anEntry.getValue());
                                if (htmlRepresentation != null) {
                                    result.append("String_Node_Str").append(anEntry.getKey()).append("String_Node_Str").append(htmlRepresentation).append("String_Node_Str");
                                }
                            }
                            result.append("String_Node_Str");
                            result.append("String_Node_Str");
                        }
                    } else {
                        result.append("String_Node_Str").append(entry.getKey()).append("String_Node_Str").append(object.toString()).append("String_Node_Str");
                    }
                }
                result.append("String_Node_Str");
            } else {
                if ((childResources == null) || (childResources.isEmpty())) {
                    if ((uriInfo != null) && (uriInfo.get().getPath().equalsIgnoreCase("String_Node_Str"))) {
                        result.append(getHint(uriInfo.get(), MediaType.TEXT_HTML));
                    }
                }
            }
        }
        if ((childResources != null) && (!childResources.isEmpty())) {
            String childResourceLinks = getResourcesLinks(childResources);
            result.append(ProviderUtil.getHtmlForComponent(childResourceLinks, "String_Node_Str", "String_Node_Str"));
        }
        if ((commands != null) && (!commands.isEmpty())) {
            String commandLinks = getCommandLinks(commands);
            result.append(ProviderUtil.getHtmlForComponent(commandLinks, "String_Node_Str", "String_Node_Str"));
        }
    }
    return result.append("String_Node_Str").toString();
}

Output:
     StringBuilder result = new StringBuilder(ProviderUtil.getHtmlHeader(getBaseUri()));
-    String message = ar.getCombinedMessage();
-    if (message != null) {
+    final String message = ResourceUtil.encodeString(ar.getCombinedMessage());
+    if (!message.isEmpty()) {
         result.append("String_Node_Str").append(message).append("String_Node_Str");


Input:
public static String generateImagePath(CardDownloadData card) {
    String useDefault = PreferencesDialog.getCachedValue(PreferencesDialog.KEY_CARD_IMAGES_USE_DEFAULT, "String_Node_Str");
    String imagesPath = Objects.equals(useDefault, "String_Node_Str") ? null : PreferencesDialog.getCachedValue(PreferencesDialog.KEY_CARD_IMAGES_PATH, null);
    String imageDir = getImageDir(card, imagesPath);
    String imageName;
    String type = card.getType() != 0 ? ' ' + Integer.toString(card.getType()) : "String_Node_Str";
    String name = card.getFileName().isEmpty() ? card.getName().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str") : card.getFileName();
    if (card.getUsesVariousArt()) {
        imageName = name + '.' + card.getCollectorId() + "String_Node_Str";
    } else {
        imageName = name + type + "String_Node_Str";
    }
    if (new TFile(imageDir).exists() && !new TFile(imageDir + TFile.separator + imageName).exists()) {
        for (String fileName : new TFile(imageDir).list()) {
            if (fileName.toLowerCase().equals(imageName.toLowerCase())) {
                imageName = fileName;
                break;
            }
        }
    }
    return imageDir + TFile.separator + imageName;
}

Output:
     String type = card.getType() != 0 ? ' ' + Integer.toString(card.getType()) : "String_Node_Str";
-    String name = card.getFileName().isEmpty() ? card.getName().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str") : card.getFileName();
+    String name = card.getFileName().isEmpty() ? card.getName().replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str") : card.getFileName();
     if (card.getUsesVariousArt()) {


Input:
public static String hash(String input) {
    MessageDigest digest = null;
    try {
        digest = java.security.MessageDigest.getInstance("String_Node_Str");
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    try {
        digest.update(input.getBytes("String_Node_Str"));
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    byte[] hash = digest.digest();
    return byteArrayToString(hash);
}

Output:
     }
-    byte[] hash = digest.digest();
+    if (digest != null) {
+        hash = digest.digest();
+    }
     return byteArrayToString(hash);