From 1e69d7aedc3537a9a5c7e5c6c61806a5206e5e66 Mon Sep 17 00:00:00 2001 From: "LAPTOP-SB56SG4Q\\86185" Date: Tue, 24 May 2022 12:51:00 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E5=BC=80=E6=BA=90=E4=BB=BB?= =?UTF-8?q?=E5=8A=A1=E6=9D=90=E6=96=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 5 +- plugin.xml | 44 ++ .../sxka/sso/CustomLogInOutEventProvider.java | 95 +++ .../plugin/sxka/sso/RoleDBAccessProvider.java | 74 ++ .../com/fr/plugin/sxka/sso/SsoFilter.java | 703 ++++++++++++++++++ .../sxka/sso/SxKaPerformanceMonitor.java | 101 +++ .../sxka/sso/beans/DecryptParamBean.java | 13 + .../plugin/sxka/sso/beans/SxkaConfigBean.java | 23 + .../sxka/sso/beans/UserRoleTypeParamBean.java | 50 ++ .../plugin/sxka/sso/conf/RoleConfigBean.java | 96 +++ .../sxka/sso/conf/RoleXmlConfigReader.java | 74 ++ .../sxka/sso/conf/UrlFilterConfigReader.java | 49 ++ .../java/com/fr/plugin/sxka/sso/conf/aaa.xml | 9 + .../sxka/sso/controller/SxKaController.java | 389 ++++++++++ .../controller/SxKaControllerProvider.java | 12 + .../sxka/sso/dao/FineLogRegisterDao.java | 41 + .../fr/plugin/sxka/sso/dao/UserInfoDao.java | 21 + .../plugin/sxka/sso/dao/UserRoleTypeDao.java | 78 ++ .../sso/entity/FineLogRegisterEntity.java | 132 ++++ .../sxka/sso/entity/UserInfoEntity.java | 310 ++++++++ .../sxka/sso/entity/UserRoleTypeDBAUtil.java | 108 +++ .../sxka/sso/entity/UserRoleTypeEntity.java | 45 ++ .../com/fr/plugin/sxka/sso/js/FileDef.java | 54 ++ .../fr/plugin/sxka/sso/js/JSCSSBridge.java | 25 + .../sxka/sso/service/UserRoleTypeService.java | 57 ++ .../sxka/sso/registe/css/app.24a019f4.css | 1 + .../registe/css/chunk-vendors.a16c4353.css | 1 + .../fr/plugin/sxka/sso/registe/favicon.ico | Bin 0 -> 4286 bytes .../registe/fonts/element-icons.535877f5.woff | Bin 0 -> 28200 bytes .../registe/fonts/element-icons.732389de.ttf | Bin 0 -> 55956 bytes .../com/fr/plugin/sxka/sso/registe/index.html | 25 + .../sxka/sso/registe/js/app.6d7e7596.js | 2 + .../sxka/sso/registe/js/app.6d7e7596.js.map | 1 + .../sso/registe/js/chunk-vendors.98ebceb7.js | 47 ++ .../registe/js/chunk-vendors.98ebceb7.js.map | 1 + .../resources/com/fr/plugin/sxka/sso/theme.js | 5 + src/main/resources/conf.properties | 23 + 插件交接文档.docx | Bin 0 -> 176998 bytes 38 files changed, 2713 insertions(+), 1 deletion(-) create mode 100644 plugin.xml create mode 100644 src/main/java/com/fr/plugin/sxka/sso/CustomLogInOutEventProvider.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/RoleDBAccessProvider.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/SsoFilter.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/SxKaPerformanceMonitor.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/beans/DecryptParamBean.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/beans/SxkaConfigBean.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/beans/UserRoleTypeParamBean.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/conf/RoleConfigBean.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/conf/RoleXmlConfigReader.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/conf/UrlFilterConfigReader.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/conf/aaa.xml create mode 100644 src/main/java/com/fr/plugin/sxka/sso/controller/SxKaController.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/controller/SxKaControllerProvider.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/dao/FineLogRegisterDao.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/dao/UserInfoDao.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/dao/UserRoleTypeDao.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/entity/FineLogRegisterEntity.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/entity/UserInfoEntity.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeDBAUtil.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeEntity.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/js/FileDef.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/js/JSCSSBridge.java create mode 100644 src/main/java/com/fr/plugin/sxka/sso/service/UserRoleTypeService.java create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/css/app.24a019f4.css create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/css/chunk-vendors.a16c4353.css create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/favicon.ico create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/fonts/element-icons.535877f5.woff create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/fonts/element-icons.732389de.ttf create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/index.html create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/js/app.6d7e7596.js create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/js/app.6d7e7596.js.map create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/js/chunk-vendors.98ebceb7.js create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/registe/js/chunk-vendors.98ebceb7.js.map create mode 100644 src/main/resources/com/fr/plugin/sxka/sso/theme.js create mode 100644 src/main/resources/conf.properties create mode 100644 插件交接文档.docx diff --git a/README.md b/README.md index ebb51ab..96fadfa 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,6 @@ # open-JSD-9466 -JSD-9466 单点登录+用户角色接口 \ No newline at end of file +JSD-9466 单点登录+用户角色接口\ +免责说明：该源码为第三方爱好者提供，不保证源码和方案的可靠性，也不提供任何形式的源码教学指导和协助！\ +仅作为开发者学习参考使用！禁止用于任何商业用途！\ +为保护开发者隐私，开发者信息已隐去！若原开发者希望公开自己的信息，可联系hugh处理。 \ No newline at end of file diff --git a/plugin.xml b/plugin.xml new file mode 100644 index 0000000..8539dbc --- /dev/null +++ b/plugin.xml @@ -0,0 +1,44 @@ + + com.fr.plugin.sxka.sso + + yes + 1.20 + 10.0 + 2018-07-31 + fr.open + + + [2021-05-17]【1.1】增加更新用户信息的机制。
+ [2021-06-01]【1.2】增加用户信息存储到外置数据库表中（plugin_sxka_user_info）。
+ [2021-06-01]【1.3】增加返回到填报页面的参数username,id。
+ [2021-06-01]【1.4】增加返回到填报页面的参数op_name。
+ [2021-06-01]【1.5】status状态字段类型修改Int。
+ [2021-06-01]【1.6】status状态字段修改成String。
+ [2021-06-07]【1.7】尝试修改客户单点回传state为空的问题。
+ [2021-06-09]【1.8】切换无权限页面为指定报表模板
+ [2021-06-09]【1.9】无权限页面增加参数。
+ [2021-06-16]【1.10】增加注册时间字段。
+ [2021-06-17]【1.11】无权限页面增加参数。
+ [2021-06-17]【1.12】增加注册时间默认值。
+ [2021-06-25]【1.13】放行无权限模板页面引用的资源。
+ [2021-06-30]【1.14】尝试解决多次跳转单点问题。bug
+ [2021-06-30]【1.15】放行报表所有资源请求。bug
+ [2021-06-30]【1.16】解决多次跳转单点问题。bug
+ [2021-08-09]【1.17】修改密码新增为UUID，屏蔽展示ID，新增模板放行。
+ [2021-08-16]【1.18】放行登录页面的/login/config和login/slider bug
+ [2021-08-16]【1.19】兼容放行登录页面的/login bug
+ [2022-01-09]【1.20】增加权限多选
+ ]]> + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/com/fr/plugin/sxka/sso/CustomLogInOutEventProvider.java b/src/main/java/com/fr/plugin/sxka/sso/CustomLogInOutEventProvider.java new file mode 100644 index 0000000..8e0d4ce --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/CustomLogInOutEventProvider.java @@ -0,0 +1,95 @@ +package com.fr.plugin.sxka.sso; + +import com.fr.decision.authority.data.User; +import com.fr.decision.fun.impl.AbstractLogInOutEventProvider; +import com.fr.decision.webservice.login.LogInOutResultInfo; +import com.fr.decision.webservice.utils.DecisionStatusService; +import com.fr.decision.webservice.v10.login.LoginService; +import com.fr.decision.webservice.v10.user.UserService; +import com.fr.general.PropertiesUtils; +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.dao.UserInfoDao; +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.stable.db.action.DBAction; +import com.fr.stable.db.dao.DAOContext; +import com.fr.stable.db.dao.DAOProvider; +import com.fr.stable.query.QueryFactory; +import com.fr.stable.query.condition.QueryCondition; +import com.fr.stable.query.restriction.RestrictionFactory; + +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletRequest; +import java.net.URLEncoder; +import java.util.List; + +/** + * @Author fr.open + * @Date 2021/5/18 + * @Description + **/ +public class CustomLogInOutEventProvider extends AbstractLogInOutEventProvider { + @Override + public String logoutAction(LogInOutResultInfo result) { + String state = getUserStateFromCookie(result.getRequest()); + FineLoggerFactory.getLogger().info("state为:" + state); + if (state != null) { + try { + DecisionStatusService.loginStatusService().delete(state); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + } + String logout_redirect_uri =URLEncoder.encode(PropertiesUtils.getProperties("conf").getProperty("logout_redirect_uri")); + String currentLoginName = LoginService.getInstance().getCurrentUserNameFromRequestCookie(result.getRequest()); + FineLoggerFactory.getLogger().info("当前登录人为:" + currentLoginName); + try { + int count = RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public Integer run(DAOContext daoContext) throws Exception { + UserInfoDao dao = daoContext.getDAO(UserInfoDao.class); + UserInfoEntity byId = dao.getById(currentLoginName); + + if(byId == null){ + FineLoggerFactory.getLogger().info("当前外置表有0个登陆人"); + return 0; + } + else{ + FineLoggerFactory.getLogger().info("当前外置表有1个登陆人:"+byId.getAccount_type()); + return 1; + } + } + }); + + if(count == 0){ + FineLoggerFactory.getLogger().info("外置表有没这个人了，再去fine_user看下"); + User user = UserService.getInstance().getUserByUserName(currentLoginName); + if(user != null){ + FineLoggerFactory.getLogger().info("fine_user里有这个人:id="+user.getId()); + logout_redirect_uri = logout_redirect_uri+"/webroot/decision/admin/login"; + } + + } + } catch (Exception e) { + e.printStackTrace(); + FineLoggerFactory.getLogger().info(""); + } + + FineLoggerFactory.getLogger().info("logout_redirect_uri为:" + logout_redirect_uri); + + String logout = PropertiesUtils.getProperties("conf").getProperty("logout"); + String format = "%s?client_id=%s&callback=%s?state=%s"; + String gotoUrl = String.format(format, logout, PropertiesUtils.getProperties("conf").getProperty("client_id"),logout_redirect_uri , state); + FineLoggerFactory.getLogger().info("登出拼接url为:" + gotoUrl); + return gotoUrl; + } + + private String getUserStateFromCookie(HttpServletRequest request) { + if (request.getCookies() == null) return null; + + for (Cookie cookie : request.getCookies()) { + if ("uid_state".equals(cookie.getName())) return cookie.getValue(); + } + return null; + } + +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/RoleDBAccessProvider.java b/src/main/java/com/fr/plugin/sxka/sso/RoleDBAccessProvider.java new file mode 100644 index 0000000..85d094a --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/RoleDBAccessProvider.java @@ -0,0 +1,74 @@ +package com.fr.plugin.sxka.sso; + +import com.fr.db.fun.impl.AbstractDBAccessProvider; +import com.fr.decision.webservice.bean.user.UserBean; +import com.fr.decision.webservice.v10.user.UserService; +import com.fr.json.JSONObject; +import com.fr.json.revise.EmbedJson; +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.conf.RoleXmlConfigReader; +import com.fr.plugin.sxka.sso.controller.SxKaController; +import com.fr.plugin.sxka.sso.dao.FineLogRegisterDao; +import com.fr.plugin.sxka.sso.dao.UserInfoDao; +import com.fr.plugin.sxka.sso.dao.UserRoleTypeDao; +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.plugin.sxka.sso.service.UserRoleTypeService; +import com.fr.security.encryption.transmission.TransmissionEncryptors; +import com.fr.stable.db.accessor.DBAccessor; +import com.fr.stable.db.action.DBAction; +import com.fr.stable.db.dao.BaseDAO; +import com.fr.stable.db.dao.DAOContext; +import com.fr.stable.db.dao.DAOProvider; +import com.fr.third.fasterxml.jackson.databind.DeserializationFeature; +import com.fr.third.fasterxml.jackson.databind.ObjectMapper; + +import java.util.Date; +import java.util.UUID; + +/** + * @Author fr.open + * @Date 2021/5/13 + * @Description + **/ +public class RoleDBAccessProvider extends AbstractDBAccessProvider { + + private static DBAccessor dbAccessor = null; + + public static DBAccessor getDbAccessor() { + return dbAccessor; + } + + @Override + public DAOProvider[] registerDAO() { + return new DAOProvider[]{ + UserRoleTypeDao.DAO, + FineLogRegisterDao.DAO, + new DAOProvider() { + @Override + public Class getEntityClass() { + return UserInfoEntity.class; + } + + @Override + public Class getDAOClass() { + return UserInfoDao.class; + } + } + }; + } + + @Override + public void onDBAvailable(DBAccessor dbAccessor) { + FineLoggerFactory.getLogger().info("RoleDBAccessProvider dbAccessor："+dbAccessor); + RoleDBAccessProvider.dbAccessor = dbAccessor; +/* + UserInfoEntity entity = new UserInfoEntity(); + entity.setGs_name("ssss"); + entity.setGs_social_credit_code("22333"); + entity.setId("sssdd111"); + entity.setOp_name("ss22"); + SxKaController.addRegisteLog(entity,"1"); + + */ + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/SsoFilter.java b/src/main/java/com/fr/plugin/sxka/sso/SsoFilter.java new file mode 100644 index 0000000..b6239dc --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/SsoFilter.java @@ -0,0 +1,703 @@ +package com.fr.plugin.sxka.sso; + +import com.fr.base.PropertiesUtils; +import com.fr.data.NetworkHelper; +import com.fr.decision.authority.AuthorityContext; +import com.fr.decision.authority.data.CustomRole; +import com.fr.decision.authority.data.User; +import com.fr.decision.fun.impl.AbstractGlobalRequestFilterProvider; +import com.fr.decision.mobile.terminal.TerminalHandler; +import com.fr.decision.webservice.bean.authentication.OriginUrlResponseBean; +import com.fr.decision.webservice.bean.user.UserBean; +import com.fr.decision.webservice.exception.user.UserNotExistException; +import com.fr.decision.webservice.utils.DecisionServiceConstants; +import com.fr.decision.webservice.utils.DecisionStatusService; +import com.fr.decision.webservice.utils.WebServiceUtils; +import com.fr.decision.webservice.v10.login.LoginService; +import com.fr.decision.webservice.v10.login.TokenResource; +import com.fr.decision.webservice.v10.user.UserService; +import com.fr.general.http.HttpRequest; +import com.fr.general.http.HttpToolbox; +import com.fr.json.JSONObject; +import com.fr.json.revise.EmbedJson; +import com.fr.locale.InterProviderFactory; +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.conf.UrlFilterConfigReader; +import com.fr.plugin.sxka.sso.controller.SxKaController; +import com.fr.plugin.sxka.sso.dao.UserInfoDao; +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeEntity; +import com.fr.plugin.sxka.sso.service.UserRoleTypeService; +import com.fr.plugin.transform.FunctionRecorder; +import com.fr.security.encryption.transmission.TransmissionEncryptors; +import com.fr.stable.StringUtils; +import com.fr.stable.db.action.DBAction; +import com.fr.stable.db.dao.DAOContext; +import com.fr.stable.query.QueryFactory; +import com.fr.stable.query.restriction.RestrictionFactory; +import com.fr.stable.web.Device; +import com.fr.third.fasterxml.jackson.databind.DeserializationFeature; +import com.fr.third.fasterxml.jackson.databind.ObjectMapper; +import com.fr.third.springframework.http.HttpHeaders; +import com.fr.third.springframework.http.MediaType; +import com.fr.third.springframework.util.DigestUtils; +import com.fr.web.controller.decision.api.auth.LoginResource; +import com.fr.web.utils.WebUtils; + + +import javax.servlet.FilterChain; +import javax.servlet.ServletException; +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.io.PrintWriter; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.util.*; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +/** + * @Author fr.open + * @Date 2021/5/12 + * @Description + **/ +//@FunctionRecorder +public class SsoFilter extends AbstractGlobalRequestFilterProvider { + + private static String[] notFilter = { + "/login/config", + "/login/slider", + "/system", + "/decision/file", + "/decision/resources", + "/remote", + "/view/report", + "/static", + "/sxka", + "/url/elite/", + "/com.fr.plugin.elite/elite/", + "/preview/info" + + }; + private static HashMap ROLE_MAP; + + public SsoFilter() { + } + + static { + ROLE_MAP = new HashMap<>(); + ROLE_MAP.put("1", "企业管理员"); + ROLE_MAP.put("2", "个人用户"); + ROLE_MAP.put("3", "企业操作员"); + ROLE_MAP.put("4", "政府端用户"); + } + + @Override + public String filterName() { + return "sxka"; + } + + @Override + public String[] urlPatterns() { + return new String[]{ + "/decision", + "/decision/", + "/decision/login", + "/decision/admin/login" + }; + } + + @Override + public void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain filterChain) { + String reqUri = req.getRequestURI(); + FineLoggerFactory.getLogger().info(getLogMessage("进来的url："+reqUri)); + FineLoggerFactory.getLogger().info(getLogMessage("req.getMethod():"+req.getMethod())); + if (reqUri.endsWith("/admin/login")) { //跳转到决策系统登录界面 + try { + String page = new LoginResource().page(req, res); + FineLoggerFactory.getLogger().info(getLogMessage("跳转到决策系统登录界面")); + if (StringUtils.isBlank(page)) { + return; + } + PrintWriter writer = WebUtils.createPrintWriter(res); + writer.println(page); + writer.flush(); + writer.close(); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return; + } + if (isLogin(req) || isAccept(req)) {//如果已经登录过或者/view/*，或者是notFilter中的，或者是css，js都放过去 + filter(req, res, filterChain); + return; + } + //登录页面跳转地址拦截 + String origin = WebUtils.getHTTPRequestParameter(req, "origin"); + FineLoggerFactory.getLogger().info(getLogMessage("origin:"+origin)); + if (reqUri.endsWith("decision/login")) {//如果url是决策系统的登录界面，拦截一下 + + if("get".equalsIgnoreCase(req.getMethod())){ + String state = this.getUserStateFromCookie(req, res);//从cookie中获取uid_state的值，如果没有就用UUID创建一个存到cookie中。 + try { + if (StringUtils.isNotBlank(origin)) {//把登录前的url存起来 + OriginUrlResponseBean path = DecisionStatusService.originUrlStatusService().get(origin); + cacheParam(res, path.getOriginUrl()); + } + FineLoggerFactory.getLogger().info("Redirect origin is {}", req.getRequestURL()); + FineLoggerFactory.getLogger().info(getLogMessage("如果是登录请求，跳转到认证url上")); + //这里会将请求转到https://www.singlewindow.shaanxi.cn/oauth/authorize上去认证，成功后回到 http://locahost:8075/webroot/decision + String authorizeUrl = buildAuthorizeUrl(state); + FineLoggerFactory.getLogger().info(getLogMessage("认证url为:"+authorizeUrl)); + res.sendRedirect(authorizeUrl); + return; + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + }else { + filter(req, res, filterChain); + return; + } + + } + //认证成功后回来的请求，检查code + String state = this.getUserStateFromCookie(req, res); + String code = req.getParameter("code"); + FineLoggerFactory.getLogger().info(getLogMessage("认证成功后回来的请求，检查code："+code+",state:"+state)); + if (StringUtils.isNotBlank(code)) { + //到https://www.singlewindow.shaanxi.cn/oauth/token上获取token。 + JSONObject data = acquireAccessToken(code); + FineLoggerFactory.getLogger().info("get access_token is {}", data); + // 计算过期时间 + int expires = Integer.valueOf(data.get("expires_in").toString()); + Date expiresTime = new Date(System.currentTimeMillis() + (expires * 1000)); + data.put("expires_at", expiresTime); + // 保存关系映射，将data存到DecisionStatusService上，state是key。DecisionStatusService上如果超过了expires_at，就会自动删除 + putState(state, data); + } + JSONObject tokenItem = null; + try { + tokenItem = DecisionStatusService.loginStatusService().get(state); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + if (tokenItem == null) {//如果获取不到state对应的data + try { + String jump = getOrginUrl(req);//req.getRequestURL() + (req.getQueryString() == null ? StringUtils.EMPTY : "?" + req.getQueryString()); + cacheParam(res, jump); + FineLoggerFactory.getLogger().info("Redirect origin is {}", jump); + String authorizeUrl = buildAuthorizeUrl(state); + FineLoggerFactory.getLogger().info(getLogMessage("没获取到tokenItem，跳转到认证上去,authorityYrl:"+authorizeUrl)); + //跳转到认证上去 + res.sendRedirect(authorizeUrl); + return; + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + } + // 检查 access token 是否过期 + Date tokenExpiresAt = (Date) tokenItem.get("expires_at"); + Date now = new Date(); + FineLoggerFactory.getLogger().info(getLogMessage("检查 access token 是否过期")); + if (tokenExpiresAt.before(now)) { + // 使用 refresh token 刷新 access token + String refreshToken = tokenItem.get("refresh_token").toString(); + tokenItem = this.refreshToken(refreshToken); + putState(state, tokenItem); + } + String accessToken = tokenItem.get("access_token").toString(); + //从https://www.singlewindow.shaanxi.cn/resource/user上获取该access_token对应的用户信息 + FineLoggerFactory.getLogger().info(getLogMessage("从https://xxxx/resource/user上获取该access_token对应的用户信息")); + JSONObject userProfile = this.acquireUserInfo(state, accessToken); + + try { + String key =userProfile.getString("id"); + FineLoggerFactory.getLogger().info("存到缓存里：key:"+key+",userProfile:"+userProfile); + DecisionStatusService.loginStatusService().put(key,userProfile); + } catch (Exception e) { + FineLoggerFactory.getLogger().info("存到缓存里失败"); + e.printStackTrace(); + } + + try { + boolean isFirst = false; + if (!existUser(userProfile.getString("id"))) {//如果决策系统不存在id属性值的用户，那么默认在决策系统中加上这个人。 + + FineLoggerFactory.getLogger().info("user {} not exist ", userProfile.getString("id")); + isFirst = true; + + } + UserInfoEntity infoEntity = recordUserInfo(userProfile);//将用户信息记录到数据库中 + //处理用户的角色 + if (checkAuth(infoEntity, req, res,isFirst,filterChain)) { + return; + } + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + filter(req, res, filterChain); + } + + private void putState(String state, JSONObject data) { + try { + DecisionStatusService.loginStatusService().put(state, data); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + } + private String getOrginUrl(HttpServletRequest req){ + String jump = req.getRequestURL() + (req.getQueryString() == null ? StringUtils.EMPTY : "?" + req.getQueryString()); + return jump; + } + + private void cacheParam(HttpServletResponse res, String jump) { + String id = UUID.randomUUID().toString(); + try { + DecisionStatusService.originUrlStatusService().put(id, new OriginUrlResponseBean(jump));//添加重定向地址 + FineLoggerFactory.getLogger().info("save orgin url id:"+id+", orgin:"+jump); + } catch (Exception e) { + FineLoggerFactory.getLogger().info(e.getMessage(), e); + } + + Cookie cookie = new Cookie("ORIGIN_URL", id); + cookie.setPath("/"); + cookie.setMaxAge(60); + //cookie.setHttpOnly(true); + FineLoggerFactory.getLogger().info("ORIGIN_URL:id="+id); + res.addCookie(cookie); + } + + public static void addRole(String userId,String roleName) throws Exception { + UserBean userAccount = UserService.getInstance().getUserAccount(userId); + CustomRole role = AuthorityContext.getInstance().getCustomRoleController().findOne(QueryFactory.create().addRestriction(RestrictionFactory.eq("name", roleName))); + if (role != null) { + //删除以前的角色，增加新角色 + List oldRoleList = AuthorityContext.getInstance().getCustomRoleController().findByUser(userAccount.getId(), QueryFactory.create()); + oldRoleList.forEach(e -> { + try { + AuthorityContext.getInstance().getUserController().removeUserFromCustomRole(userAccount.getId(), e.getId()); + } catch (Exception exception) { + FineLoggerFactory.getLogger().error(exception.getMessage(), exception); + } + }); + FineLoggerFactory.getLogger().info("增加角色，roleName:"+roleName+",userId:"+userId); + AuthorityContext.getInstance().getUserController().addUserToCustomRole(userAccount.getId(), role.getId()); + } + } + + private boolean checkAuth(UserInfoEntity entity, HttpServletRequest req, HttpServletResponse res,boolean isFirst,FilterChain filterChain) throws Exception { + FineLoggerFactory.getLogger().info(getLogMessage("验证用户角色，status:")+entity.getStatus()); + //这里再判断下个人用户，个人用户必须要在权限菜单里有数据才能视为不是第一次 + if(entity.getAccount_type().equals("2") == true){ + // + FineLoggerFactory.getLogger().info(getLogMessage("个人用户必须要在权限菜单里有数据才能视为不是第一次")); + List userRoleTypeList = UserRoleTypeService.getInstance().getUserRoleTypeByUserId(entity.getId()); + FineLoggerFactory.getLogger().info("个人用户:"+entity.getId()+",此时有的权限个数为:"+userRoleTypeList.size()); + if(userRoleTypeList.size() == 0){ + isFirst = true; + } + else{ + isFirst = false; + } + } + + if(isFirst == false){ + if (StringUtils.isNotBlank(entity.getStatus()) && entity.getStatus().equalsIgnoreCase("true")) { + //如果已经授权了 + FineLoggerFactory.getLogger().info(getLogMessage("如果已经是激活状态")); + /* + if (entity.getAccount_type().equals("1") || entity.getAccount_type().equals("3") || entity.getAccount_type().equals("4")) { //如果账号类型是这些 + + String roleName = ROLE_MAP.containsKey(entity.getAccount_type()) ? ROLE_MAP.get(entity.getAccount_type()) : "其他"; + addRole(entity.getId(),roleName); + } + */ + //登录 + loginFromToken(req, res, entity.getId()); + FineLoggerFactory.getLogger().info(getLogMessage("自动登录结束")); + String jump = getOrigin(req); + FineLoggerFactory.getLogger().info("get Origin path is {}", jump); + if (StringUtils.isNotBlank(jump)) { + FineLoggerFactory.getLogger().info(getLogMessage("跳转到orgin:"+jump)); + res.sendRedirect(jump); + } + else{ + filter(req, res, filterChain); + } + return true; + + } + } + + + + /* + if (entity.getAccount_type().equals("1") || entity.getAccount_type().equals("3") || entity.getAccount_type().equals("4")) { + setError(res, entity.getId()); //到冻结界面去 + return true; + } + */ + + FineLoggerFactory.getLogger().info("isFirst:"+isFirst); + //还没激活 + if(isFirst == true){ //如果是首次 + //如果没授权， + //其他类型跳转到write_report界面去，我应该是在这里做 + FineLoggerFactory.getLogger().info(getLogMessage("下面是没激活，也没有授权，就跳转到write_report配置的授权界面")); + String url = PropertiesUtils.getProperties("conf").getProperty("write_report"); + FineLoggerFactory.getLogger().info("write_report:"+url); + String jump = getOrigin(req); + if(StringUtils.isBlank(jump)){ + jump = getOrginUrl(req); + } + String param = "username=" + entity.getOp_name() + "&id=" + entity.getId()+"&accountType="+entity.getAccount_type()+"&orgin="+jump+""; + if(url.indexOf("&clientType=1") != -1){ + param += "&clientType=1"; + url = url.replace("&clientType=1",""); + } + if(url.indexOf("&clientType=2") != -1){ + param += "&clientType=2"; + url = url.replace("&clientType=2",""); + } + FineLoggerFactory.getLogger().info("urlparam加密前:"+param); + param = Encrypt(param, SxKaController.cKey);//URLEncoder.encode(param); + url = url.indexOf("?") != -1 ? url + "&" + param : url + "?" + param; + FineLoggerFactory.getLogger().info("授权界面url:"+url); + res.sendRedirect(url); + } + else{ //如果是非首次，也没激活，就去冻结 + if(entity.getAccount_type().equals("1") == true){ + FineLoggerFactory.getLogger().info("企业管理员第二次来，直接跳过"); + //登录 + loginFromToken(req, res, entity.getId()); + FineLoggerFactory.getLogger().info(getLogMessage("自动登录结束")); + filter(req, res, filterChain); + return true; + } + FineLoggerFactory.getLogger().info("到冻结界面去"); + setError(res, entity.getId()); //到冻结界面去 + return true; + } + return true; + } + + // 加密 + public static String Encrypt(String sSrc, String sKey) throws Exception { + if (sKey == null) { + System.out.print("Key为空null"); + return null; + } + // 判断Key是否为16位 + if (sKey.length() != 16) { + System.out.print("Key长度不是16位"); + return null; + } + byte[] raw = sKey.getBytes("utf-8"); + SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); + Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//"算法/模式/补码方式" + cipher.init(Cipher.ENCRYPT_MODE, skeySpec); + byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8")); + String msg = Base64.getEncoder().encodeToString(encrypted); + return msg;//此处使用BASE64做转码功能，同时能起到2次加密的作用。 + } + + + private static UserInfoEntity recordUserInfo(JSONObject user) { + //将json转为UserInfoEntity对象 + ObjectMapper mapper = EmbedJson.MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + UserInfoEntity entity = mapper.convertValue(user, UserInfoEntity.class); + + try { + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserInfoEntity run(DAOContext daoContext) throws Exception { + UserInfoDao dao = daoContext.getDAO(UserInfoDao.class); + //查询数据库是否存在该id对应的数据 + UserInfoEntity byId = dao.getById(entity.getId()); + if (byId != null) {//如果存在，更新下 + entity.setStatus(byId.getStatus()); + entity.setAccount_type(byId.getAccount_type()); + entity.setRegistryDate(byId.getRegistryDate()); + FineLoggerFactory.getLogger().info("外置表里有这个用户，这里更新"); + } else {//如果不存在，将状态置为false + FineLoggerFactory.getLogger().info("外置表里没这个用户，这里不增加，留到后面来增加"); + + } + //更新或者添加 + // dao.addOrUpdate(entity); + return entity; + } + }); + } catch (Exception e) { + FineLoggerFactory.getLogger().info(e.getMessage(), e); + } + + + return entity; + } + + + + private String getOrigin(HttpServletRequest req) throws Exception { + Cookie[] cookies = req.getCookies(); + if (cookies == null) { + return null; + } + for (int i = 0; i < cookies.length; i++) { + if ("ORIGIN_URL".equals(cookies[i].getName())) { + String id = cookies[i].getValue(); + OriginUrlResponseBean path = DecisionStatusService.originUrlStatusService().get(id); + FineLoggerFactory.getLogger().info("ORIGIN_URL,id="+id+",path="+path); + if (path != null) { + DecisionStatusService.originUrlStatusService().delete(id); + return path.getOriginUrl(); + } + } + } + return StringUtils.EMPTY; + } + + public static boolean existUser(String username) { + User user = null; + try { + user = UserService.getInstance().getUserByUserName(username); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return user != null; + } + + private boolean loginFromToken(HttpServletRequest req, HttpServletResponse res, String username) throws Exception { + try { + if (StringUtils.isNotEmpty(username)) { + FineLoggerFactory.getLogger().info("current username:" + username); + User user = UserService.getInstance().getUserByUserName(username); + FineLoggerFactory.getLogger().info("get user:" + user); + if (user == null) { + throw new UserNotExistException(); + } + String token = LoginService.getInstance().login(req, res, username); + FineLoggerFactory.getLogger().info("get login token:" + token); + req.setAttribute(DecisionServiceConstants.FINE_AUTH_TOKEN_NAME, token); + FineLoggerFactory.getLogger().info("username:" + username + "login success"); + return true; + } else { + FineLoggerFactory.getLogger().warn("username is null!"); + return false; + } + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return false; + } + + + private JSONObject acquireUserInfo(String state, String accessToken) { + String url = PropertiesUtils.getProperties("conf").getProperty("user_url"); + + Map params = new HashMap<>(); + params.put("client_id", PropertiesUtils.getProperties("conf").getProperty("client_id")); + params.put("access_token", accessToken); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + try { + String res = HttpToolbox.executeAndParse(HttpRequest.custom().url(url) + .headers(headers.toSingleValueMap()) + .post(params) + .build()); + FineLoggerFactory.getLogger().info("get user name url is 【{}】,params is，{} res is {}", url, params, res); + JSONObject object = new JSONObject(res); + return object.getJSONObject("data"); + } catch (IOException e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return JSONObject.EMPTY; + } + + private JSONObject refreshToken(String refreshToken) { + String url = PropertiesUtils.getProperties("conf").getProperty("token_url"); + + Map params = new HashMap<>(); + params.put("grant_type", "refresh_token"); + params.put("refresh_token", refreshToken); + params.put("client_id", PropertiesUtils.getProperties("conf").getProperty("client_id")); + params.put("client_sign", this.makeSign(refreshToken)); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + try { + String res = HttpToolbox.executeAndParse(HttpRequest.custom().url(url) + .headers(headers.toSingleValueMap()) + .post(params) + .build()); + FineLoggerFactory.getLogger().info("get refresh token url is 【{}】,params is，{} res is {}", url, params, res); + JSONObject object = new JSONObject(res); + return object.getJSONObject("data"); + } catch (IOException e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return JSONObject.EMPTY; + } + + private JSONObject acquireAccessToken(String code) { + FineLoggerFactory.getLogger().info(getLogMessage("去远程获取token")); + String url = PropertiesUtils.getProperties("conf").getProperty("token_url"); + Map params = new HashMap<>(); + params.put("grant_type", "authorization_code"); + params.put("code", code); + params.put("client_id", PropertiesUtils.getProperties("conf").getProperty("client_id")); + params.put("client_sign", this.makeSign(code)); + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED); + try { + String res = HttpToolbox.executeAndParse(HttpRequest.custom().url(url) + .headers(headers.toSingleValueMap()) + .post(params) + .build()); + FineLoggerFactory.getLogger().info("get access token url is 【{}】,params is，{} res is {}", url, params, res); + JSONObject object = new JSONObject(res); + return object.getJSONObject("data"); + } catch (IOException e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + return JSONObject.EMPTY; + } + + /** + * 生成签名值= md5Hex("$$", UTF8) + * + * @param data + * @return + */ + private String makeSign(String data) { + String value = String.join("$", new String[]{ + PropertiesUtils.getProperties("conf").getProperty("client_id"), + data, + PropertiesUtils.getProperties("conf").getProperty("client_secret") + }); + return DigestUtils.md5DigestAsHex(value.getBytes(StandardCharsets.UTF_8)); + } + + private String buildAuthorizeUrl(String state) { + String format = "%s?client_id=%s&response_type=code&scope=A1,C1,C2&state=%s&redirect_uri=%s"; + return String.format(format, PropertiesUtils.getProperties("conf").getProperty("auth_url"), PropertiesUtils.getProperties("conf").getProperty("client_id"), state, PropertiesUtils.getProperties("conf").getProperty("redirect_uri")); + } + + private void setUserStateCookie(HttpServletResponse response, String state) { + Cookie cookie = new Cookie("uid_state", state); + cookie.setMaxAge(300); + // 正式环境采用HTTPS协议，需要取消下方注释，确保仅在HTTPS下可用 +// cookie.setSecure(true); + cookie.setPath("/"); + response.addCookie(cookie); + } + + private String getUserStateFromCookie(HttpServletRequest request, HttpServletResponse res) { + FineLoggerFactory.getLogger().info(getLogMessage("从cookie获取uid_state")); + if (request.getCookies() == null) { + return null; + } + String state = StringUtils.EMPTY; + for (Cookie cookie : request.getCookies()) { + if ("uid_state".equals(cookie.getName())) { + state = cookie.getValue(); + } + } + if (StringUtils.isBlank(state)) { + state = UUID.randomUUID().toString(); + this.setUserStateCookie(res, state); + } + return state; + } + + private boolean isAccept(HttpServletRequest req) { + FineLoggerFactory.getLogger().info(getLogMessage("看url是否为放行的url")); + if (req.getRequestURI().endsWith("/view/form") || req.getRequestURI().endsWith("/view/report")) { + return true; + /*String viewlet = WebUtils.getHTTPRequestParameter(req, "viewlet"); + if (StringUtils.isBlank(viewlet)) { + return true; + } + if (!whiteList.stream().filter(e -> viewlet.contains(e)).collect(Collectors.toList()).isEmpty()) { + return true; + }*/ + } + String[] urlFilters = getUrlFilterArray(); + for (int i = 0; i < urlFilters.length; i++) { + if (req.getRequestURI().contains(urlFilters[i])) { + return true; + } + } + if (req.getRequestURI().endsWith("/.css") || req.getRequestURI().endsWith("/.js")) { + return true; + } + return false; + } + + private boolean isLogin(HttpServletRequest request) { + String oldToken = TokenResource.COOKIE.getToken(request); + boolean isOk = oldToken != null && checkTokenValid(request, (String) oldToken); + FineLoggerFactory.getLogger().info(getLogMessage("验证是否登录，如果有token，验证有效性:isOk:"+isOk)); + return isOk; + } + + private boolean checkTokenValid(HttpServletRequest req, String token) { + try { + Device device = NetworkHelper.getDevice(req); + FineLoggerFactory.getLogger().info(getLogMessage("调用LoginService.getInstance().loginStatusValid验证token有效性")); + LoginService.getInstance().loginStatusValid(token, TerminalHandler.getTerminal(req, device)); + return true; + } catch (Exception ignore) { + } + return false; + } + + public static void setError(HttpServletResponse res, String id) { + String error = PropertiesUtils.getProperties("conf").getProperty("unavailable"); + try { + + if (StringUtils.isNotBlank(error)) { + error = error.contains("?") ? (error + "&id=" + id) : (error + "?+id=" + id); + FineLoggerFactory.getLogger().info("到冻结界面去了:"+error); + res.sendRedirect(error); + return; + } + FineLoggerFactory.getLogger().info("到冻结界面去了"); + PrintWriter printWriter = WebUtils.createPrintWriter(res); + Map map = new HashMap<>(); + map.put("result", InterProviderFactory.getProvider().getLocText("Fine-Engine_Error_Page_Result")); + map.put("reason", "当前用户已冻结，请联系系统管理员激活"); + map.put("solution", InterProviderFactory.getProvider().getLocText("Fine-Engine_Please_Contact_Platform_Admin")); + String page = WebServiceUtils.parseWebPageResourceSafe("com/fr/web/controller/decision/entrance/resources/unavailable.html", map); + printWriter.write(page); + printWriter.flush(); + printWriter.close(); + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + } + + private void filter(HttpServletRequest req, HttpServletResponse res, FilterChain filterChain) { + try { + filterChain.doFilter(req, res); + } catch (IOException e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } catch (ServletException e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + } + + private String[] getUrlFilterArray(){ + String[] urls = UrlFilterConfigReader.getInstance().getUrlFilterArray(); + if(urls == null){ + return notFilter; + } + else{ + return urls; + } + } + + private String getLogMessage(String message){ + return "[SsoFilter]"+message; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/SxKaPerformanceMonitor.java b/src/main/java/com/fr/plugin/sxka/sso/SxKaPerformanceMonitor.java new file mode 100644 index 0000000..90baf99 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/SxKaPerformanceMonitor.java @@ -0,0 +1,101 @@ +package com.fr.plugin.sxka.sso; + +import com.fr.decision.webservice.utils.DecisionStatusService; +import com.fr.json.JSONObject; +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.context.PluginContext; +import com.fr.plugin.observer.inner.AbstractPluginLifecycleMonitor; +import com.fr.plugin.sxka.sso.conf.RoleXmlConfigReader; +import com.fr.plugin.sxka.sso.conf.UrlFilterConfigReader; +import com.fr.plugin.sxka.sso.controller.SxKaController; +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.plugin.transform.FunctionRecorder; +import com.fr.record.analyzer.EnableMetrics; +import com.fr.stable.xml.XMLTools; +import com.fr.workspace.WorkContext; + +import java.io.File; + +@EnableMetrics +@FunctionRecorder +public class SxKaPerformanceMonitor extends AbstractPluginLifecycleMonitor { + @Override + public void afterRun(PluginContext pluginContext) { + FineLoggerFactory.getLogger().info(pluginContext.getName()+"插件启动完成"); + ///webroot/decision/file?path=com/fr/plugin/sxka/sso/registe/index.html + //读取webroot下的角色配置文件 + String envPath = WorkContext.getCurrent().getPath(); + FineLoggerFactory.getLogger().info("envPath:"+envPath); + String webReport = (new File(envPath)).getParent(); + FineLoggerFactory.getLogger().info("webReport:"+webReport); + File envFile = new File(webReport+File.separator+"sxka"+File.separator+"role.xml"); + try { + RoleXmlConfigReader.getInstance().init(); + XMLTools.readFileXML(RoleXmlConfigReader.getInstance(), envFile); + } catch (Exception e) { + e.printStackTrace(); + } + + File urlFilterFile = new File(webReport+File.separator+"sxka"+File.separator+"urlFilter.xml"); + try { + UrlFilterConfigReader.getInstance().init(); + XMLTools.readFileXML(UrlFilterConfigReader.getInstance(), urlFilterFile); + } catch (Exception e) { + e.printStackTrace(); + } + + /* + try { + String ass = SsoFilter.Encrypt("username=bbb&id=bbb&accountType=4&orgin=http://baidu.com&clientType=1", SxKaController.cKey); + FineLoggerFactory.getLogger().info("ass:"+ass); + + ass = SsoFilter.Encrypt("username=bbb&id=bbb&accountType=4&orgin=http://baidu.com&clientType=2", SxKaController.cKey); + FineLoggerFactory.getLogger().info("ass:"+ass); + } catch (Exception e) { + e.printStackTrace(); + }*/ + + + /* + JSONObject userProfile = new JSONObject(); + userProfile.put("id","aaa"); + userProfile.put("op_name","ssss"); + userProfile.put("organization","ssss1"); + userProfile.put("account_type","1"); + userProfile.put("login_type","1"); + userProfile.put("gs_name","2333"); + userProfile.put("gs_type","2333"); + userProfile.put("gs_name_en","2333"); + userProfile.put("gs_address","2333"); + userProfile.put("gs_address_en","2333"); + userProfile.put("gs_tax_code","2333"); + userProfile.put("gs_expires","2333"); + userProfile.put("gs_postcode","2333"); + userProfile.put("gs_scope","2333"); + userProfile.put("gs_status","2333"); + userProfile.put("gs_regcap","2333"); + userProfile.put("gs_regcap_cur","2333"); + userProfile.put("gs_social_credit_code","2333"); + userProfile.put("gs_code","2333"); + userProfile.put("gs_regorg","2333"); + userProfile.put("gs_reg_number","2333"); + userProfile.put("gs_location","2333"); + userProfile.put("cus_number","2333"); + userProfile.put("cus_expires","2333"); + userProfile.put("cus_master","2333"); + userProfile.put("status","2333"); + userProfile.put("registry_date","2333"); + + try { + DecisionStatusService.loginStatusService().put("aaa",userProfile); + } catch (Exception e) { + e.printStackTrace(); + } + */ + } + + @Override + public void beforeStop(PluginContext pluginContext) { + FineLoggerFactory.getLogger().info(pluginContext.getName()+"插件即将停止"); + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/beans/DecryptParamBean.java b/src/main/java/com/fr/plugin/sxka/sso/beans/DecryptParamBean.java new file mode 100644 index 0000000..7466974 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/beans/DecryptParamBean.java @@ -0,0 +1,13 @@ +package com.fr.plugin.sxka.sso.beans; + +public class DecryptParamBean { + private String decryptParam; + + public String getDecryptParam() { + return decryptParam; + } + + public void setDecryptParam(String decryptParam) { + this.decryptParam = decryptParam; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/beans/SxkaConfigBean.java b/src/main/java/com/fr/plugin/sxka/sso/beans/SxkaConfigBean.java new file mode 100644 index 0000000..e496e2b --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/beans/SxkaConfigBean.java @@ -0,0 +1,23 @@ +package com.fr.plugin.sxka.sso.beans; + +public class SxkaConfigBean { + + private String unavailable; + private String unavailable1; + + public String getUnavailable() { + return unavailable; + } + + public String getUnavailable1() { + return unavailable1; + } + + public void setUnavailable(String unavailable) { + this.unavailable = unavailable; + } + + public void setUnavailable1(String unavailable1) { + this.unavailable1 = unavailable1; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/beans/UserRoleTypeParamBean.java b/src/main/java/com/fr/plugin/sxka/sso/beans/UserRoleTypeParamBean.java new file mode 100644 index 0000000..403cca5 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/beans/UserRoleTypeParamBean.java @@ -0,0 +1,50 @@ +package com.fr.plugin.sxka.sso.beans; + +public class UserRoleTypeParamBean { + + private String userId; + private String userRoleTypes; + private int accountType; + private String orgin; + private String clientType; + + public String getClientType() { + return clientType; + } + + public void setClientType(String clientType) { + this.clientType = clientType; + } + + public String getOrgin() { + return orgin; + } + + public void setOrgin(String orgin) { + this.orgin = orgin; + } + + public int getAccountType() { + return accountType; + } + + public void setAccountType(int accountType) { + this.accountType = accountType; + } + + public void setUserId(String userId) { + this.userId = userId; + } + + public void setUserRoleTypes(String userRoleTypes) { + this.userRoleTypes = userRoleTypes; + } + + public String getUserId() { + return userId; + } + + public String getUserRoleTypes() { + return userRoleTypes; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/conf/RoleConfigBean.java b/src/main/java/com/fr/plugin/sxka/sso/conf/RoleConfigBean.java new file mode 100644 index 0000000..089f04f --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/conf/RoleConfigBean.java @@ -0,0 +1,96 @@ +package com.fr.plugin.sxka.sso.conf; + +public class RoleConfigBean { + private String roleType; + private String roleSetPageUrl; + private String roleName; + private String roleDescn; + private boolean selected; + private boolean disabled; + private String owner; + private boolean isTab; + private boolean audit; + private String roleCode; + + public String getRoleCode() { + return roleCode; + } + + public void setRoleCode(String roleCode) { + this.roleCode = roleCode; + } + + public void setAudit(boolean audit) { + this.audit = audit; + } + + public boolean isAudit() { + return audit; + } + + + + public void setSelected(boolean selected) { + this.selected = selected; + } + + public void setDisabled(boolean disabled) { + this.disabled = disabled; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + public void setTab(boolean tab) { + isTab = tab; + } + + public boolean isSelected() { + return selected; + } + + public boolean isDisabled() { + return disabled; + } + + public String getOwner() { + return owner; + } + + public boolean isTab() { + return isTab; + } + + public void setRoleType(String roleType) { + this.roleType = roleType; + } + + public void setRoleSetPageUrl(String roleSetPageUrl) { + this.roleSetPageUrl = roleSetPageUrl; + } + + public void setRoleName(String roleName) { + this.roleName = roleName; + } + + public void setRoleDescn(String roleDescn) { + this.roleDescn = roleDescn; + } + + public String getRoleType() { + return roleType; + } + + public String getRoleSetPageUrl() { + return roleSetPageUrl; + } + + public String getRoleName() { + return roleName; + } + + public String getRoleDescn() { + return roleDescn; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/conf/RoleXmlConfigReader.java b/src/main/java/com/fr/plugin/sxka/sso/conf/RoleXmlConfigReader.java new file mode 100644 index 0000000..943bb56 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/conf/RoleXmlConfigReader.java @@ -0,0 +1,74 @@ +package com.fr.plugin.sxka.sso.conf; + +import com.fr.stable.xml.XMLReadable; +import com.fr.stable.xml.XMLableReader; + +import java.util.ArrayList; +import java.util.List; + +public class RoleXmlConfigReader implements XMLReadable { + + private static RoleXmlConfigReader instance; + + public static RoleXmlConfigReader getInstance(){ + if(instance == null){ + instance = new RoleXmlConfigReader(); + } + return instance; + } + + public List roles; + + public void init(){ + roles = new ArrayList<>(); + } + + public String getRoleCodeByName(String roleName){ + for(RoleConfigBean bean : roles){ + if(bean.getRoleType().equals(roleName)){ + return bean.getRoleCode(); + } + } + return ""; + } + + /** + * 配置文件格式为: + * + * + * + * + * @param reader + */ + @Override + public void readXML(XMLableReader reader) { + if (reader.isChildNode()) { + String nodeName = reader.getTagName(); + if("roleType".equals(nodeName)){ + RoleConfigBean bean = new RoleConfigBean(); + String type = reader.getAttrAsString("type",""); + String roleCode = reader.getAttrAsString("roleCode",""); + String name = reader.getAttrAsString("name",""); + String descn = reader.getAttrAsString("descn",""); + String url = reader.getAttrAsString("url",""); + boolean selected = reader.getAttrAsBoolean("selected",false); + boolean disabled = reader.getAttrAsBoolean("disabled",false); + String owner = reader.getAttrAsString("owner",""); + boolean isTab = reader.getAttrAsBoolean("isTab",false); + boolean audit = reader.getAttrAsBoolean("audit",false); + + bean.setRoleCode(roleCode); + bean.setSelected(selected); + bean.setDisabled(disabled); + bean.setOwner(owner); + bean.setTab(isTab); + bean.setRoleDescn(descn); + bean.setRoleName(name); + bean.setRoleType(type); + bean.setRoleSetPageUrl(url); + bean.setAudit(audit); + roles.add(bean); + } + } + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/conf/UrlFilterConfigReader.java b/src/main/java/com/fr/plugin/sxka/sso/conf/UrlFilterConfigReader.java new file mode 100644 index 0000000..80c6341 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/conf/UrlFilterConfigReader.java @@ -0,0 +1,49 @@ +package com.fr.plugin.sxka.sso.conf; + +import com.fr.stable.StringUtils; +import com.fr.stable.xml.XMLReadable; +import com.fr.stable.xml.XMLableReader; + +import java.util.ArrayList; +import java.util.List; + +public class UrlFilterConfigReader implements XMLReadable { + private static UrlFilterConfigReader instance; + + public static UrlFilterConfigReader getInstance(){ + if(instance == null){ + instance = new UrlFilterConfigReader(); + } + return instance; + } + + public List urlFilters; + + public void init(){ + urlFilters = new ArrayList<>(); + } + + public String[] getUrlFilterArray(){ + if(urlFilters == null || urlFilters.size() == 0){ + return null; + } + String[] urls = new String[urlFilters.size()]; + for(int i = 0 ; i < urlFilters.size();i++){ + urls[i] = urlFilters.get(i); + } + return urls; + } + + @Override + public void readXML(XMLableReader reader) { + if (reader.isChildNode()) { + String nodeName = reader.getTagName(); + if ("url".equals(nodeName)) { + String urlValue = StringUtils.trim(reader.getElementValue()); + if(StringUtils.isNotEmpty(urlValue)){ + urlFilters.add(urlValue); + } + } + } + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/conf/aaa.xml b/src/main/java/com/fr/plugin/sxka/sso/conf/aaa.xml new file mode 100644 index 0000000..c437f17 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/conf/aaa.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaController.java b/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaController.java new file mode 100644 index 0000000..9792d1f --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaController.java @@ -0,0 +1,389 @@ +package com.fr.plugin.sxka.sso.controller; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; + + +import com.fr.base.PropertiesUtils; +import com.fr.decision.webservice.Response; +import com.fr.decision.webservice.annotation.LoginStatusChecker; +import com.fr.decision.webservice.bean.user.UserBean; +import com.fr.decision.webservice.utils.DecisionStatusService; +import com.fr.decision.webservice.utils.WebServiceUtils; +import com.fr.decision.webservice.v10.user.UserService; +import com.fr.json.JSONObject; +import com.fr.json.revise.EmbedJson; +import com.fr.locale.InterProviderFactory; +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.RoleDBAccessProvider; +import com.fr.plugin.sxka.sso.SsoFilter; +import com.fr.plugin.sxka.sso.beans.DecryptParamBean; +import com.fr.plugin.sxka.sso.beans.UserRoleTypeParamBean; +import com.fr.plugin.sxka.sso.beans.SxkaConfigBean; +import com.fr.plugin.sxka.sso.conf.RoleConfigBean; +import com.fr.plugin.sxka.sso.conf.RoleXmlConfigReader; +import com.fr.plugin.sxka.sso.dao.UserInfoDao; +import com.fr.plugin.sxka.sso.entity.FineLogRegisterEntity; +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeDBAUtil; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeEntity; +import com.fr.plugin.sxka.sso.service.UserRoleTypeService; +import com.fr.security.encryption.transmission.TransmissionEncryptors; +import com.fr.stable.StringUtils; +import com.fr.stable.db.action.DBAction; +import com.fr.stable.db.dao.DAOContext; +import com.fr.stable.query.QueryFactory; +import com.fr.stable.query.condition.QueryCondition; +import com.fr.stable.query.restriction.RestrictionFactory; +import com.fr.third.fasterxml.jackson.databind.DeserializationFeature; +import com.fr.third.fasterxml.jackson.databind.ObjectMapper; +import com.fr.third.springframework.stereotype.Controller; +import com.fr.third.springframework.web.bind.annotation.*; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.text.SimpleDateFormat; +import java.util.*; + +@Controller +@LoginStatusChecker( + required = false //不需要验证是否登录 +) +public class SxKaController { + + @RequestMapping( + value = {"/sxka/getConfig"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response getConfig(HttpServletRequest req, HttpServletResponse res) throws Exception { + SxkaConfigBean bean = new SxkaConfigBean(); + String unavailableUrlPath = PropertiesUtils.getProperties("conf").getProperty("unavailable"); + String unavailableUrlPath1 = PropertiesUtils.getProperties("conf").getProperty("unavailable1"); + bean.setUnavailable(unavailableUrlPath); + bean.setUnavailable1(unavailableUrlPath1); + return Response.ok(bean); + } + + /** + * 获取所有的角色类型 + * + * @param req + * @param res + * @return + * @throws Exception + */ + @RequestMapping( + value = {"/sxka/getAllRoleTypeList"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response getAllRoleTypeList(HttpServletRequest req, HttpServletResponse res) throws Exception { + List allRoleTypes = RoleXmlConfigReader.getInstance().roles; + return Response.ok(allRoleTypes); + } + + /** + * 获取用户选择的权限列表 + * + * @param req + * @param res + * @param userId + * @return + * @throws Exception + */ + @RequestMapping( + value = {"/sxka/getUserRoleTypeList"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response getUserRoleTypeList(HttpServletRequest req, HttpServletResponse res, @RequestParam("userId") String userId) throws Exception { + FineLoggerFactory.getLogger().info("获取用户的权限类型列表：userId=" + userId); + List userRoleTypeList = UserRoleTypeService.getInstance().getUserRoleTypeByUserId(userId); + return Response.ok(userRoleTypeList); + } + + + public static final String cKey = "eaassww34422**aa"; + @RequestMapping( + value = {"/sxka/decryptParam"}, + method = {RequestMethod.POST} + ) + @ResponseBody + public Response decryptParam(HttpServletRequest req, HttpServletResponse res, @RequestBody DecryptParamBean decryptParamBean) throws Exception { + FineLoggerFactory.getLogger().info("解密 param=" + decryptParamBean.getDecryptParam()); + String result = Decrypt(decryptParamBean.getDecryptParam(),cKey); + FineLoggerFactory.getLogger().info("解密结果=" + result); + return Response.ok(result); + } + + public static String Decrypt(String sSrc, String sKey) throws Exception { + try { + // 判断Key是否正确 + if (sKey == null) { + FineLoggerFactory.getLogger().info("Key为空null"); + return null; + } + // 判断Key是否为16位 + if (sKey.length() != 16) { + FineLoggerFactory.getLogger().info("Key长度不是16位"); + return null; + } + byte[] raw = sKey.getBytes("utf-8"); + SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); + Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); + cipher.init(Cipher.DECRYPT_MODE, skeySpec); + + byte[] encrypted1 = Base64.getDecoder().decode(sSrc);//先用base64解密 + try { + byte[] original = cipher.doFinal(encrypted1); + String originalString = new String(original,"utf-8"); + return originalString; + } catch (Exception e) { + System.out.println(e.toString()); + return null; + } + } catch (Exception ex) { + System.out.println(ex.toString()); + return null; + } + } + + + /** + * 批量增加用户角色 + * + * @param req + * @param res + * @param userRoleTypeParam + * @return + * @throws Exception + */ + @RequestMapping( + value = {"/sxka/addUserRoleTypes"}, + method = {RequestMethod.POST} + ) + @ResponseBody + public Response addUserRoleTypes(HttpServletRequest req, HttpServletResponse res, @RequestBody UserRoleTypeParamBean userRoleTypeParam) throws Exception { + FineLoggerFactory.getLogger().info("用户增加权限类型：userId=" + userRoleTypeParam.getUserId() + ",userRoleTypes=" + userRoleTypeParam.getUserRoleTypes()+",clientType="+userRoleTypeParam.getClientType()+",orgin="+userRoleTypeParam.getOrgin()+",accountType="+userRoleTypeParam.getAccountType()); + addLoginUserAndUserInfo(userRoleTypeParam.getUserId()); + + //多个roleType用逗号隔开 + UserRoleTypeService.getInstance().addUserRoleTypes(userRoleTypeParam.getUserId(), userRoleTypeParam.getUserRoleTypes()); + //如果是企业管理员，直接可用 + if (userRoleTypeParam.getAccountType() == 1) { + FineLoggerFactory.getLogger().info("企业管理员直接可用，不跳冻结界面"); + if (StringUtils.isNotBlank(userRoleTypeParam.getOrgin())) { + return Response.ok(userRoleTypeParam.getOrgin()); + } + else{ + String unavailableUrlPath = PropertiesUtils.getProperties("conf").getProperty("unavailable1"); + FineLoggerFactory.getLogger().info("unavailableUrlPath:" + unavailableUrlPath); + // res.sendRedirect(unavailableUrlPath); + return Response.ok(unavailableUrlPath); + } + } + //查看是否有需要审批的权限 + List roles = RoleXmlConfigReader.getInstance().roles; + boolean isAudit = false; + for (RoleConfigBean config : roles) { + boolean isoK1 = config.getOwner().indexOf("" + userRoleTypeParam.getAccountType()) != -1; + boolean isoK2 = config.isAudit() == true; + boolean isoK3 = userRoleTypeParam.getUserRoleTypes().indexOf(config.getRoleType()) != -1; + if (isoK1 && isoK2 && isoK3) { + isAudit = true; + } + } + FineLoggerFactory.getLogger().info("isAudit:" + isAudit); + + if (isAudit == true) { + FineLoggerFactory.getLogger().info("clientType:" + userRoleTypeParam.getClientType()); + if ("1".equals(userRoleTypeParam.getClientType())) { + String unavailableUrlPath = PropertiesUtils.getProperties("conf").getProperty("unavailable"); + ; + //res.sendRedirect(unavailableUrlPath); + return Response.ok(unavailableUrlPath); + } else { + String unavailableUrlPath = PropertiesUtils.getProperties("conf").getProperty("unavailable1"); + FineLoggerFactory.getLogger().info("unavailableUrlPath:" + unavailableUrlPath); + // res.sendRedirect(unavailableUrlPath); + return Response.ok(unavailableUrlPath); + } + + // SsoFilter.setError(res, userRoleTypeParam.getUserId());//需要审核 + } else { + if (StringUtils.isNotBlank(userRoleTypeParam.getOrgin())) { + return Response.ok(userRoleTypeParam.getOrgin()); + } + } + return Response.ok("ok"); + } + + + @RequestMapping( + value = {"/sxka/deleteAllRoleType"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response deleteAllRoleType(HttpServletRequest req, HttpServletResponse res) throws Exception { + UserRoleTypeDBAUtil.getInstance().deleteAllEntity(); + return Response.ok("ok"); + } + + + @RequestMapping( + value = {"/sxka/getAllUsers"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response getAllUserInfo(HttpServletRequest req, HttpServletResponse res) throws Exception { + List allUsers = RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction>() { + @Override + public List run(DAOContext daoContext) throws Exception { + UserInfoDao dao = daoContext.getDAO(UserInfoDao.class); + QueryCondition condition = QueryFactory.create(); + return dao.find(condition); + } + }); + + return Response.ok(allUsers); + } + + @RequestMapping( + value = {"/sxka/deleteAllUsers"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response deleteAllUsers(HttpServletRequest req, HttpServletResponse res) throws Exception { + List allUsers = RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction>() { + @Override + public List run(DAOContext daoContext) throws Exception { + UserInfoDao dao = daoContext.getDAO(UserInfoDao.class); + QueryCondition condition = QueryFactory.create(); + + List allEntitys = dao.find(condition); + for(UserInfoEntity entity:allEntitys){ + QueryCondition deleteCondition = QueryFactory.create(); + deleteCondition.addRestriction(RestrictionFactory.eq("id",entity.getId())); + dao.remove(deleteCondition); + } + return null; + } + }); + + return Response.ok(allUsers); + } + + + @RequestMapping( + value = {"/sxka/initUserInfo"}, + method = {RequestMethod.GET} + ) + @ResponseBody + public Response initUserInfo(HttpServletRequest req, HttpServletResponse res, @RequestParam("userId") String userId) throws Exception { + FineLoggerFactory.getLogger().info("/sxka/initUserInfo user info：userId=" + userId); + addLoginUserAndUserInfo(userId); + return Response.ok("ok"); + } + + public static final String DATE_FORMAT_YMDHMS = "yyyy-MM-dd HH:mm:ss"; + private static final SimpleDateFormat YMDHMSFormater = new SimpleDateFormat(DATE_FORMAT_YMDHMS); + private void addLoginUserAndUserInfo(String userId) throws Exception { + FineLoggerFactory.getLogger().info("从缓存里取：key:"+userId); + JSONObject userProfile = DecisionStatusService.loginStatusService().get(userId); + if(userProfile != null){ + FineLoggerFactory.getLogger().info("从缓存里取到了:"+userProfile); + + if (!SsoFilter.existUser(userProfile.getString("id"))){ + FineLoggerFactory.getLogger().info("如果决策系统不存在id属性值的用户，那么默认在决策系统中加上这个人"); + UserBean userBean = new UserBean(); + userBean.setUsername(userProfile.getString("id")); + userBean.setRealName(userProfile.getString("op_name")); + userBean.setEnable(true); + + userBean.setPassword(TransmissionEncryptors.getInstance().encrypt(UUID.randomUUID().toString())); + UserService.getInstance().addUser(userBean); + FineLoggerFactory.getLogger().info("增加新用户:"+userProfile.getString("id")); + } + + ObjectMapper mapper = EmbedJson.MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + UserInfoEntity entity = mapper.convertValue(userProfile, UserInfoEntity.class); + final boolean[] isAdd= {false,false}; + + try { + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserInfoEntity run(DAOContext daoContext) throws Exception { + UserInfoDao dao = daoContext.getDAO(UserInfoDao.class); + //查询数据库是否存在该id对应的数据 + UserInfoEntity byId = dao.getById(entity.getId()); + if (byId != null) {//如果存在，更新下 + entity.setStatus(byId.getStatus()); + entity.setAccount_type(byId.getAccount_type()); + entity.setRegistryDate(byId.getRegistryDate()); + FineLoggerFactory.getLogger().info("外置表里有这个用户，这里更新"); + } else {//如果不存在，将状态置为false + FineLoggerFactory.getLogger().info("外置表里没这个用户，这里增加"); + entity.setStatus("false"); + entity.setRegistryDate(new Date()); + + if(entity.getAccount_type().equals("1")){ + isAdd[0] = true; + entity.setStatus("true"); + } + + if(entity.getAccount_type().equals("3")){ + isAdd[1] = true; + + } + } + //更新或者添加 + dao.addOrUpdate(entity); + return entity; + } + }); + + + if( isAdd[0] == true){ + UserRoleTypeService.getInstance().addUserRoleTypes(entity.getId(), "企业管理员"); + SsoFilter.addRole(entity.getId(),"企业管理员"); + //增加企业管理员日志 + addRegisteLog(entity,"1"); + } + if(isAdd[1] == true){ + UserRoleTypeService.getInstance().addUserRoleTypes(entity.getId(), "企业操作员"); + SsoFilter.addRole(entity.getId(),"企业操作员"); + //增加企业操作员日志 + addRegisteLog(entity,"3"); + } + } catch (Exception e) { + FineLoggerFactory.getLogger().error(e.getMessage(), e); + } + DecisionStatusService.loginStatusService().delete(userId); + FineLoggerFactory.getLogger().info("从缓存里delete：key:"+userId); + } + } + + public static void addRegisteLog(UserInfoEntity entity,String type){ + FineLogRegisterEntity logEntity = new FineLogRegisterEntity(); + logEntity.setGs_name(entity.getGs_name()); + logEntity.setGs_social_credit_code(entity.getGs_social_credit_code()); + logEntity.setType(type); + logEntity.setUser_id(entity.getId()); + logEntity.setOp_name(entity.getOp_name()); + Date date = new Date(); + String datef = YMDHMSFormater.format(date); + logEntity.setLog_time(datef); + if(type.equals("3")){ + logEntity.setAction("企业操作员注册"); + }if(type.equals("1")){ + logEntity.setAction("企业管理员注册"); + } + + logEntity.setExecutor_gs_name(logEntity.getGs_name()); + logEntity.setExecutor_gs_social_credit_code(logEntity.getGs_social_credit_code()); + logEntity.setExecutor(logEntity.getUser_id()); + logEntity.setExecutor_name(logEntity.getOp_name()); + UserRoleTypeDBAUtil.getInstance().addFineLogRegiste(logEntity); + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaControllerProvider.java b/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaControllerProvider.java new file mode 100644 index 0000000..9664dc8 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/controller/SxKaControllerProvider.java @@ -0,0 +1,12 @@ +package com.fr.plugin.sxka.sso.controller; + +import com.fr.decision.fun.impl.AbstractControllerRegisterProvider; + +public class SxKaControllerProvider extends AbstractControllerRegisterProvider { + @Override + public Class[] getControllers() { + return new Class[]{ + SxKaController.class + }; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/dao/FineLogRegisterDao.java b/src/main/java/com/fr/plugin/sxka/sso/dao/FineLogRegisterDao.java new file mode 100644 index 0000000..3f30122 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/dao/FineLogRegisterDao.java @@ -0,0 +1,41 @@ +package com.fr.plugin.sxka.sso.dao; + +import com.fr.plugin.sxka.sso.entity.FineLogRegisterEntity; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeEntity; +import com.fr.stable.db.dao.BaseDAO; +import com.fr.stable.db.dao.DAOProvider; +import com.fr.stable.db.session.DAOSession; + +import java.util.UUID; + +public class FineLogRegisterDao extends BaseDAO{ + + + public FineLogRegisterDao(DAOSession daoSession) { + super(daoSession); + } + + public void addEntity(FineLogRegisterEntity entity) throws Exception { + if(entity.getId()==null){ + entity.setId(UUID.randomUUID().toString()); + } + getSession().persist(entity); + } + + @Override + protected Class getEntityClass() { + return FineLogRegisterEntity.class; + } + + public final static DAOProvider DAO = new DAOProvider() { + @Override + public Class getEntityClass() { + return FineLogRegisterEntity.class; + } + + @Override + public Class getDAOClass() { + return FineLogRegisterDao.class; + } + }; +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/dao/UserInfoDao.java b/src/main/java/com/fr/plugin/sxka/sso/dao/UserInfoDao.java new file mode 100644 index 0000000..83a59c4 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/dao/UserInfoDao.java @@ -0,0 +1,21 @@ +package com.fr.plugin.sxka.sso.dao; + +import com.fr.plugin.sxka.sso.entity.UserInfoEntity; +import com.fr.stable.db.dao.BaseDAO; +import com.fr.stable.db.session.DAOSession; + +/** + * @Author hujian + * @Date 2021/5/17 + * @Description + **/ +public class UserInfoDao extends BaseDAO { + public UserInfoDao(DAOSession daoSession) { + super(daoSession); + } + + @Override + protected Class getEntityClass() { + return UserInfoEntity.class; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/dao/UserRoleTypeDao.java b/src/main/java/com/fr/plugin/sxka/sso/dao/UserRoleTypeDao.java new file mode 100644 index 0000000..f40f6b2 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/dao/UserRoleTypeDao.java @@ -0,0 +1,78 @@ +package com.fr.plugin.sxka.sso.dao; + +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeEntity; +import com.fr.stable.db.dao.BaseDAO; +import com.fr.stable.db.dao.DAOProvider; +import com.fr.stable.db.session.DAOSession; +import com.fr.stable.query.QueryFactory; +import com.fr.stable.query.condition.QueryCondition; +import com.fr.stable.query.restriction.RestrictionFactory; + +import java.util.List; +import java.util.UUID; + +public class UserRoleTypeDao extends BaseDAO { + public UserRoleTypeDao(DAOSession daoSession) { + super(daoSession); + } + + public void addEntity(UserRoleTypeEntity entity) throws Exception { + List list = getEntitiesByUserIdAndRoleCode(entity.getUserId(),entity.getRoleCode()); + if(list.size() == 0){ + if(entity.getId()==null){ + entity.setId(UUID.randomUUID().toString()); + } + getSession().persist(entity); + FineLoggerFactory.getLogger().info("userId:"+entity.getUserId()+",roleCode:"+entity.getRoleCode()+"插入"); + } + else{ + FineLoggerFactory.getLogger().info("userId:"+entity.getUserId()+",roleCode:"+entity.getRoleCode()+"已经存在"); + } + } + + public List getEntitiesByUserIdAndRoleCode(String userId,String roleCode) throws Exception { + QueryCondition condition = QueryFactory.create(); + condition.addRestriction(RestrictionFactory.eq("userId",userId)); + condition.addRestriction(RestrictionFactory.eq("roleCode",roleCode)); + return getSession().find(condition,getEntityClass()); + } + + public List getEntitiesByUserId(String userId) throws Exception { + QueryCondition condition = QueryFactory.create(); + condition.addRestriction(RestrictionFactory.eq("userId",userId)); + return getSession().find(condition,getEntityClass()); + } + + public void deleteUserRoleTypeByUserId(String userId) throws Exception { + List userRoleTypeList = getEntitiesByUserId(userId); + for(UserRoleTypeEntity entity:userRoleTypeList){ + getSession().remove(QueryFactory.create().addRestriction(RestrictionFactory.eq("id",entity.getId())),getEntityClass()); + } + } + + public void deleteAllEntity() throws Exception { + QueryCondition condition = QueryFactory.create(); + List entitys = getSession().find(condition,getEntityClass()); + for(UserRoleTypeEntity entity:entitys){ + getSession().remove(QueryFactory.create().addRestriction(RestrictionFactory.eq("id",entity.getId())),getEntityClass()); + } + } + + @Override + protected Class getEntityClass() { + return UserRoleTypeEntity.class; + } + + public final static DAOProvider DAO = new DAOProvider() { + @Override + public Class getEntityClass() { + return UserRoleTypeEntity.class; + } + + @Override + public Class getDAOClass() { + return UserRoleTypeDao.class; + } + }; +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/entity/FineLogRegisterEntity.java b/src/main/java/com/fr/plugin/sxka/sso/entity/FineLogRegisterEntity.java new file mode 100644 index 0000000..bd8f14b --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/entity/FineLogRegisterEntity.java @@ -0,0 +1,132 @@ +package com.fr.plugin.sxka.sso.entity; + +import com.fr.stable.db.entity.BaseEntity; +import com.fr.third.javax.persistence.Column; +import com.fr.third.javax.persistence.Entity; +import com.fr.third.javax.persistence.Table; + +@Entity +@Table(name = "fine_log_register_company") +public class FineLogRegisterEntity extends BaseEntity { + + @Column(name = "gs_name") + private String gs_name; + + @Column(name = "gs_social_credit_code") + private String gs_social_credit_code; + + @Column(name = "type") + private String type; + + @Column(name = "user_id") + private String user_id; + + @Column(name = "op_name") + private String op_name; + + @Column(name = "action") + private String action; + + @Column(name = "log_time") + private String log_time; + + @Column(name = "executor_gs_name") + private String executor_gs_name; + + @Column(name = "executor_gs_social_credit_code") + private String executor_gs_social_credit_code; + + @Column(name = "executor") + private String executor; + + @Column(name = "executor_name") + private String executor_name; + + public String getGs_name() { + return gs_name; + } + + public void setGs_name(String gs_name) { + this.gs_name = gs_name; + } + + public String getGs_social_credit_code() { + return gs_social_credit_code; + } + + public void setGs_social_credit_code(String gs_social_credit_code) { + this.gs_social_credit_code = gs_social_credit_code; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getUser_id() { + return user_id; + } + + public void setUser_id(String user_id) { + this.user_id = user_id; + } + + public String getOp_name() { + return op_name; + } + + public void setOp_name(String op_name) { + this.op_name = op_name; + } + + public String getAction() { + return action; + } + + public void setAction(String action) { + this.action = action; + } + + public String getLog_time() { + return log_time; + } + + public void setLog_time(String log_time) { + this.log_time = log_time; + } + + public String getExecutor_gs_name() { + return executor_gs_name; + } + + public void setExecutor_gs_name(String executor_gs_name) { + this.executor_gs_name = executor_gs_name; + } + + public String getExecutor_gs_social_credit_code() { + return executor_gs_social_credit_code; + } + + public void setExecutor_gs_social_credit_code(String executor_gs_social_credit_code) { + this.executor_gs_social_credit_code = executor_gs_social_credit_code; + } + + public String getExecutor() { + return executor; + } + + public void setExecutor(String executor) { + this.executor = executor; + } + + public String getExecutor_name() { + return executor_name; + } + + public void setExecutor_name(String executor_name) { + this.executor_name = executor_name; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/entity/UserInfoEntity.java b/src/main/java/com/fr/plugin/sxka/sso/entity/UserInfoEntity.java new file mode 100644 index 0000000..cc23fd9 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/entity/UserInfoEntity.java @@ -0,0 +1,310 @@ +package com.fr.plugin.sxka.sso.entity; + +import com.fr.stable.db.entity.BaseEntity; +import com.fr.third.javax.persistence.Column; +import com.fr.third.javax.persistence.Entity; +import com.fr.third.javax.persistence.Table; + +import java.util.Date; + +/** + * @Author fr.open + * @Date 2021/5/13 + * @Description + **/ +@Entity +@Table(name = "plugin_sxka_user_info") +public class UserInfoEntity extends BaseEntity { + + private static final long serialVersionUID = 5278704449983309952L; + + @Column(name = "op_name") + private String op_name; + + @Column(name = "organization") + private String organization; + + @Column(name = "account_type") + private String account_type; + + @Column(name = "login_type") + private String login_type; + + @Column(name = "gs_name") + private String gs_name; + + @Column(name = "gs_name_en") + private String gs_name_en; + + @Column(name = "gs_type") + private String gs_type; + + @Column(name = "gs_address") + private String gs_address; + + @Column(name = "gs_address_en") + private String gs_address_en; + + @Column(name = "gs_tax_code") + private String gs_tax_code; + + @Column(name = "gs_expires") + private String gs_expires; + + @Column(name = "gs_postcode") + private String gs_postcode; + + @Column(name = "gs_scope") + private String gs_scope; + + @Column(name = "gs_status") + private String gs_status; + + @Column(name = "gs_regcap") + private String gs_regcap; + + @Column(name = "gs_regcap_cur") + private String gs_regcap_cur; + + @Column(name = "gs_social_credit_code") + private String gs_social_credit_code; + + @Column(name = "gs_code") + private String gs_code; + + @Column(name = "gs_regorg") + private String gs_regorg; + + @Column(name = "gs_reg_number") + private String gs_reg_number; + + @Column(name = "gs_location") + private String gs_location; + + @Column(name = "cus_number") + private String cus_number; + + @Column(name = "cus_expires") + private String cus_expires; + + @Column(name = "cus_master") + private String cus_master; + + @Column(name = "status") + private String status; + + @Column(name = "registry_date") + private Date registryDate; + + public Date getRegistryDate() { + return registryDate; + } + + public void setRegistryDate(Date registryDate) { + this.registryDate = registryDate; + } + + public static long getSerialVersionUID() { + return serialVersionUID; + } + + public String getOp_name() { + return op_name; + } + + public void setOp_name(String op_name) { + this.op_name = op_name; + } + + public String getOrganization() { + return organization; + } + + public void setOrganization(String organization) { + this.organization = organization; + } + + public String getAccount_type() { + return account_type; + } + + public void setAccount_type(String account_type) { + this.account_type = account_type; + } + + public String getLogin_type() { + return login_type; + } + + public void setLogin_type(String login_type) { + this.login_type = login_type; + } + + public String getGs_name() { + return gs_name; + } + + public void setGs_name(String gs_name) { + this.gs_name = gs_name; + } + + public String getGs_name_en() { + return gs_name_en; + } + + public void setGs_name_en(String gs_name_en) { + this.gs_name_en = gs_name_en; + } + + public String getGs_type() { + return gs_type; + } + + public void setGs_type(String gs_type) { + this.gs_type = gs_type; + } + + public String getGs_address() { + return gs_address; + } + + public void setGs_address(String gs_address) { + this.gs_address = gs_address; + } + + public String getGs_address_en() { + return gs_address_en; + } + + public void setGs_address_en(String gs_address_en) { + this.gs_address_en = gs_address_en; + } + + public String getGs_tax_code() { + return gs_tax_code; + } + + public void setGs_tax_code(String gs_tax_code) { + this.gs_tax_code = gs_tax_code; + } + + public String getGs_expires() { + return gs_expires; + } + + public void setGs_expires(String gs_expires) { + this.gs_expires = gs_expires; + } + + public String getGs_postcode() { + return gs_postcode; + } + + public void setGs_postcode(String gs_postcode) { + this.gs_postcode = gs_postcode; + } + + public String getGs_scope() { + return gs_scope; + } + + public void setGs_scope(String gs_scope) { + this.gs_scope = gs_scope; + } + + public String getGs_status() { + return gs_status; + } + + public void setGs_status(String gs_status) { + this.gs_status = gs_status; + } + + public String getGs_regcap() { + return gs_regcap; + } + + public void setGs_regcap(String gs_regcap) { + this.gs_regcap = gs_regcap; + } + + public String getGs_regcap_cur() { + return gs_regcap_cur; + } + + public void setGs_regcap_cur(String gs_regcap_cur) { + this.gs_regcap_cur = gs_regcap_cur; + } + + public String getGs_social_credit_code() { + return gs_social_credit_code; + } + + public void setGs_social_credit_code(String gs_social_credit_code) { + this.gs_social_credit_code = gs_social_credit_code; + } + + public String getGs_code() { + return gs_code; + } + + public void setGs_code(String gs_code) { + this.gs_code = gs_code; + } + + public String getGs_regorg() { + return gs_regorg; + } + + public void setGs_regorg(String gs_regorg) { + this.gs_regorg = gs_regorg; + } + + public String getGs_reg_number() { + return gs_reg_number; + } + + public void setGs_reg_number(String gs_reg_number) { + this.gs_reg_number = gs_reg_number; + } + + public String getGs_location() { + return gs_location; + } + + public void setGs_location(String gs_location) { + this.gs_location = gs_location; + } + + public String getCus_number() { + return cus_number; + } + + public void setCus_number(String cus_number) { + this.cus_number = cus_number; + } + + public String getCus_expires() { + return cus_expires; + } + + public void setCus_expires(String cus_expires) { + this.cus_expires = cus_expires; + } + + public String getCus_master() { + return cus_master; + } + + public void setCus_master(String cus_master) { + this.cus_master = cus_master; + } + + public String getStatus() { + return status; + } + + public void setStatus(String status) { + this.status = status; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeDBAUtil.java b/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeDBAUtil.java new file mode 100644 index 0000000..f34ad9f --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeDBAUtil.java @@ -0,0 +1,108 @@ +package com.fr.plugin.sxka.sso.entity; + +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.RoleDBAccessProvider; +import com.fr.plugin.sxka.sso.dao.FineLogRegisterDao; +import com.fr.plugin.sxka.sso.dao.UserRoleTypeDao; +import com.fr.stable.db.action.DBAction; +import com.fr.stable.db.dao.DAOContext; + +import java.util.ArrayList; +import java.util.List; + + +public class UserRoleTypeDBAUtil { + + private static UserRoleTypeDBAUtil instance; + + public static UserRoleTypeDBAUtil getInstance(){ + if(instance == null){ + instance = new UserRoleTypeDBAUtil(); + } + return instance; + } + + + public void addFineLogRegiste(FineLogRegisterEntity entity){ + try{ + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserRoleTypeEntity run(DAOContext daoContext) throws Exception { + daoContext.getDAO(FineLogRegisterDao.class).addEntity(entity); + FineLoggerFactory.getLogger().info("增加日志成功....."); + return null; + } + }); + } + catch(Exception ex){ + FineLoggerFactory.getLogger().info("增加日志失败....."); + ex.printStackTrace(); + } + } + + public void addUserRoleType(UserRoleTypeEntity entity){ + try{ + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserRoleTypeEntity run(DAOContext daoContext) throws Exception { + daoContext.getDAO(UserRoleTypeDao.class).addEntity(entity); + return null; + } + }); + } + catch(Exception ex){ + ex.printStackTrace(); + } + } + + public List getUserRoleTypeByUserId(String userId){ + try{ + List entities = RoleDBAccessProvider.getDbAccessor().runQueryAction(new DBAction>() { + + @Override + public List run(DAOContext daoContext) throws Exception { + return daoContext.getDAO(UserRoleTypeDao.class).getEntitiesByUserId(userId); + + } + }); + + return entities; + } + catch(Exception ex){ + ex.printStackTrace(); + return new ArrayList<>(); + } + } + + public void deleteUserRoleTypeByUserId(String userId) throws Exception { + try{ + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserRoleTypeEntity run(DAOContext daoContext) throws Exception { + daoContext.getDAO(UserRoleTypeDao.class).deleteUserRoleTypeByUserId(userId); + return null; + } + }); + } + catch(Exception ex){ + ex.printStackTrace(); + } + } + + public void deleteAllEntity() throws Exception { + try{ + RoleDBAccessProvider.getDbAccessor().runDMLAction(new DBAction() { + @Override + public UserRoleTypeEntity run(DAOContext daoContext) throws Exception { + daoContext.getDAO(UserRoleTypeDao.class).deleteAllEntity(); + return null; + } + }); + } + catch(Exception ex){ + ex.printStackTrace(); + } + } + + +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeEntity.java b/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeEntity.java new file mode 100644 index 0000000..138a55e --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/entity/UserRoleTypeEntity.java @@ -0,0 +1,45 @@ +package com.fr.plugin.sxka.sso.entity; + +import com.fr.stable.db.entity.BaseEntity; +import com.fr.third.javax.persistence.Column; +import com.fr.third.javax.persistence.Entity; +import com.fr.third.javax.persistence.Table; + +@Entity +@Table(name = "plugin_sxka_user_role_type") +public class UserRoleTypeEntity extends BaseEntity { + + @Column(name = "userId") + private String userId; + + @Column(name = "roleType") + private String roleType; + + @Column(name = "roleCode") + private String roleCode; + + + public String getRoleCode() { + return roleCode; + } + + public void setRoleCode(String roleCode) { + this.roleCode = roleCode; + } + + public void setUserId(String userId) { + this.userId = userId; + } + + public void setRoleType(String roleType) { + this.roleType = roleType; + } + + public String getUserId() { + return userId; + } + + public String getRoleType() { + return roleType; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/js/FileDef.java b/src/main/java/com/fr/plugin/sxka/sso/js/FileDef.java new file mode 100644 index 0000000..0a79557 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/js/FileDef.java @@ -0,0 +1,54 @@ +package com.fr.plugin.sxka.sso.js; + +import com.fr.plugin.transform.ExecuteFunctionRecord; +import com.fr.web.struct.Component; +import com.fr.web.struct.Filter; +import com.fr.web.struct.browser.RequestClient; +import com.fr.web.struct.category.ScriptPath; +import com.fr.web.struct.category.StylePath; + +/** + * @author fr.open + * @date 2021/8/12 + */ +public class FileDef extends Component { + public static final FileDef KEY = new FileDef(); + private FileDef(){} + /** + * 返回需要引入的JS脚本路径 + * @param client 请求客户端描述 + * @return JS脚本路径 + */ + @Override + public ScriptPath script(RequestClient client ) { + //如果不需要就直接返回 ScriptPath.EMPTY + return ScriptPath.build("com/fr/plugin/sxka/sso/theme.js"); + } + + /** + * 返回需要引入的CSS样式路径 + * @param client 请求客户端描述 + * @return CSS样式路径 + */ + @Override + public StylePath style(RequestClient client ) { + //如果不需要就直接返回 StylePath.EMPTY; + return StylePath.EMPTY; + } + + /** + * 通过给定的资源过滤器控制是否加载这个资源 + * @return 资源过滤器 + */ + @ExecuteFunctionRecord + @Override + public Filter filter() { + return new Filter(){ + @Override + public boolean accept() { + //任何情况下我们都在平台组件加载时加载我们的组件 + return true; + } + }; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/js/JSCSSBridge.java b/src/main/java/com/fr/plugin/sxka/sso/js/JSCSSBridge.java new file mode 100644 index 0000000..8bae4a4 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/js/JSCSSBridge.java @@ -0,0 +1,25 @@ +package com.fr.plugin.sxka.sso.js; + +import com.fr.decision.fun.impl.AbstractWebResourceProvider; +import com.fr.decision.web.MainComponent; +import com.fr.plugin.transform.FunctionRecorder; +import com.fr.web.struct.Atom; + +/** + * @author fr.open + * @date 2021/8/12 + */ +@FunctionRecorder +public class JSCSSBridge extends AbstractWebResourceProvider { + @Override + public Atom attach() { + //在平台主组件加载时添加我们自己的组件 + return MainComponent.KEY; + } + + @Override + public Atom client() { + //我们自己要引入的组件 + return FileDef.KEY; + } +} diff --git a/src/main/java/com/fr/plugin/sxka/sso/service/UserRoleTypeService.java b/src/main/java/com/fr/plugin/sxka/sso/service/UserRoleTypeService.java new file mode 100644 index 0000000..94c91b4 --- /dev/null +++ b/src/main/java/com/fr/plugin/sxka/sso/service/UserRoleTypeService.java @@ -0,0 +1,57 @@ +package com.fr.plugin.sxka.sso.service; + +import com.fr.log.FineLoggerFactory; +import com.fr.plugin.sxka.sso.conf.RoleXmlConfigReader; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeDBAUtil; +import com.fr.plugin.sxka.sso.entity.UserRoleTypeEntity; + +import java.util.List; +import java.util.UUID; + +public class UserRoleTypeService { + + private static UserRoleTypeService instance; + + public static UserRoleTypeService getInstance(){ + if(instance == null){ + instance = new UserRoleTypeService(); + } + return instance; + } + + public synchronized void addUserRoleTypes(String userId,String userRoleTypes) throws Exception { + //先删除所有 + deleteUserRoleTypeByUserId(userId); + FineLoggerFactory.getLogger().info("先删除用户的权限:"+Thread.currentThread().getName()); + //多个roleType用逗号隔开 + String[] roleTypeArr = userRoleTypes.split(","); + // String[] roleCodeArr = roleCodes.split(","); + int index = 0; + for(String roleType:roleTypeArr){ + UserRoleTypeEntity entity = new UserRoleTypeEntity(); + entity.setId(UUID.randomUUID().toString()); + entity.setRoleType(roleType); + entity.setUserId(userId); + String addRoleCode = RoleXmlConfigReader.getInstance().getRoleCodeByName(roleType); + entity.setRoleCode(addRoleCode); + FineLoggerFactory.getLogger().info("增加角色，roleType:"+roleType+",roleCode:"+addRoleCode+",userId:"+userId+",threadName:"+Thread.currentThread().getName()); + addUserRoleType(entity); + index++; + } + } + + public void addUserRoleType(UserRoleTypeEntity entity){ + if(entity.getId() == null || "".equals(entity.getId())){ + entity.setId(UUID.randomUUID().toString()); + } + UserRoleTypeDBAUtil.getInstance().addUserRoleType(entity); + } + + public List getUserRoleTypeByUserId(String userId){ + return UserRoleTypeDBAUtil.getInstance().getUserRoleTypeByUserId(userId); + } + + public void deleteUserRoleTypeByUserId(String userId) throws Exception { + UserRoleTypeDBAUtil.getInstance().deleteUserRoleTypeByUserId(userId); + } +} diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/css/app.24a019f4.css b/src/main/resources/com/fr/plugin/sxka/sso/registe/css/app.24a019f4.css new file mode 100644 index 0000000..0338ab0 --- /dev/null +++ b/src/main/resources/com/fr/plugin/sxka/sso/registe/css/app.24a019f4.css @@ -0,0 +1 @@ +#app{font-family:Avenir,Helvetica,Arial,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;widows:100%;background-color:#bdd7ee}.headerStyle{padding-bottom:40px;padding-top:30px;text-align:center;vertical-align:middle;display:flex;justify-content:center;align-items:center;background-image:url(data:image/png;base64,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)}.logoStyle{width:98px;height:138px;background-image:url(data:image/png;base64,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)}.grid-content /deep/ .el-checkbox__label{font-size:18px;color:#000}.grid-content /deep/ .el-checkbox__input.is-disabled+span.el-checkbox__label{color:#8a8282}.roleDescnStyle{color:#fff;font-size:16px} \ No newline at end of file diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/css/chunk-vendors.a16c4353.css b/src/main/resources/com/fr/plugin/sxka/sso/registe/css/chunk-vendors.a16c4353.css new file mode 100644 index 0000000..c7a0f01 --- /dev/null +++ b/src/main/resources/com/fr/plugin/sxka/sso/registe/css/chunk-vendors.a16c4353.css @@ -0,0 +1 @@ +.el-pagination--small .arrow.disabled,.el-table--hidden,.el-table .el-table__cell.is-hidden>*,.el-table .hidden-columns{visibility:hidden}.el-dropdown .el-dropdown-selfdefine:focus:active,.el-dropdown .el-dropdown-selfdefine:focus:not(.focusing),.el-message__closeBtn:focus,.el-message__content:focus,.el-popover:focus,.el-popover:focus:active,.el-popover__reference:focus:hover,.el-popover__reference:focus:not(.focusing),.el-rate:active,.el-rate:focus,.el-tooltip:focus:hover,.el-tooltip:focus:not(.focusing),.el-upload-list__item.is-success:active,.el-upload-list__item.is-success:not(.focusing):focus{outline-width:0}.el-input__suffix,.el-tree.is-dragging .el-tree-node__content *{pointer-events:none}@font-face{font-family:element-icons;src:url(../fonts/element-icons.535877f5.woff) format("woff"),url(../fonts/element-icons.732389de.ttf) format("truetype");font-weight:400;font-display:"auto";font-style:normal}[class*=" el-icon-"],[class^=el-icon-]{font-family:element-icons!important;speak:none;font-style:normal;font-weight:400;font-variant:normal;text-transform:none;line-height:1;vertical-align:baseline;display:inline-block;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.el-icon-ice-cream-round:before{content:"\e6a0"}.el-icon-ice-cream-square:before{content:"\e6a3"}.el-icon-lollipop:before{content:"\e6a4"}.el-icon-potato-strips:before{content:"\e6a5"}.el-icon-milk-tea:before{content:"\e6a6"}.el-icon-ice-drink:before{content:"\e6a7"}.el-icon-ice-tea:before{content:"\e6a9"}.el-icon-coffee:before{content:"\e6aa"}.el-icon-orange:before{content:"\e6ab"}.el-icon-pear:before{content:"\e6ac"}.el-icon-apple:before{content:"\e6ad"}.el-icon-cherry:before{content:"\e6ae"}.el-icon-watermelon:before{content:"\e6af"}.el-icon-grape:before{content:"\e6b0"}.el-icon-refrigerator:before{content:"\e6b1"}.el-icon-goblet-square-full:before{content:"\e6b2"}.el-icon-goblet-square:before{content:"\e6b3"}.el-icon-goblet-full:before{content:"\e6b4"}.el-icon-goblet:before{content:"\e6b5"}.el-icon-cold-drink:before{content:"\e6b6"}.el-icon-coffee-cup:before{content:"\e6b8"}.el-icon-water-cup:before{content:"\e6b9"}.el-icon-hot-water:before{content:"\e6ba"}.el-icon-ice-cream:before{content:"\e6bb"}.el-icon-dessert:before{content:"\e6bc"}.el-icon-sugar:before{content:"\e6bd"}.el-icon-tableware:before{content:"\e6be"}.el-icon-burger:before{content:"\e6bf"}.el-icon-knife-fork:before{content:"\e6c1"}.el-icon-fork-spoon:before{content:"\e6c2"}.el-icon-chicken:before{content:"\e6c3"}.el-icon-food:before{content:"\e6c4"}.el-icon-dish-1:before{content:"\e6c5"}.el-icon-dish:before{content:"\e6c6"}.el-icon-moon-night:before{content:"\e6ee"}.el-icon-moon:before{content:"\e6f0"}.el-icon-cloudy-and-sunny:before{content:"\e6f1"}.el-icon-partly-cloudy:before{content:"\e6f2"}.el-icon-cloudy:before{content:"\e6f3"}.el-icon-sunny:before{content:"\e6f6"}.el-icon-sunset:before{content:"\e6f7"}.el-icon-sunrise-1:before{content:"\e6f8"}.el-icon-sunrise:before{content:"\e6f9"}.el-icon-heavy-rain:before{content:"\e6fa"}.el-icon-lightning:before{content:"\e6fb"}.el-icon-light-rain:before{content:"\e6fc"}.el-icon-wind-power:before{content:"\e6fd"}.el-icon-baseball:before{content:"\e712"}.el-icon-soccer:before{content:"\e713"}.el-icon-football:before{content:"\e715"}.el-icon-basketball:before{content:"\e716"}.el-icon-ship:before{content:"\e73f"}.el-icon-truck:before{content:"\e740"}.el-icon-bicycle:before{content:"\e741"}.el-icon-mobile-phone:before{content:"\e6d3"}.el-icon-service:before{content:"\e6d4"}.el-icon-key:before{content:"\e6e2"}.el-icon-unlock:before{content:"\e6e4"}.el-icon-lock:before{content:"\e6e5"}.el-icon-watch:before{content:"\e6fe"}.el-icon-watch-1:before{content:"\e6ff"}.el-icon-timer:before{content:"\e702"}.el-icon-alarm-clock:before{content:"\e703"}.el-icon-map-location:before{content:"\e704"}.el-icon-delete-location:before{content:"\e705"}.el-icon-add-location:before{content:"\e706"}.el-icon-location-information:before{content:"\e707"}.el-icon-location-outline:before{content:"\e708"}.el-icon-location:before{content:"\e79e"}.el-icon-place:before{content:"\e709"}.el-icon-discover:before{content:"\e70a"}.el-icon-first-aid-kit:before{content:"\e70b"}.el-icon-trophy-1:before{content:"\e70c"}.el-icon-trophy:before{content:"\e70d"}.el-icon-medal:before{content:"\e70e"}.el-icon-medal-1:before{content:"\e70f"}.el-icon-stopwatch:before{content:"\e710"}.el-icon-mic:before{content:"\e711"}.el-icon-copy-document:before{content:"\e718"}.el-icon-full-screen:before{content:"\e719"}.el-icon-switch-button:before{content:"\e71b"}.el-icon-aim:before{content:"\e71c"}.el-icon-crop:before{content:"\e71d"}.el-icon-odometer:before{content:"\e71e"}.el-icon-time:before{content:"\e71f"}.el-icon-bangzhu:before{content:"\e724"}.el-icon-close-notification:before{content:"\e726"}.el-icon-microphone:before{content:"\e727"}.el-icon-turn-off-microphone:before{content:"\e728"}.el-icon-position:before{content:"\e729"}.el-icon-postcard:before{content:"\e72a"}.el-icon-message:before{content:"\e72b"}.el-icon-chat-line-square:before{content:"\e72d"}.el-icon-chat-dot-square:before{content:"\e72e"}.el-icon-chat-dot-round:before{content:"\e72f"}.el-icon-chat-square:before{content:"\e730"}.el-icon-chat-line-round:before{content:"\e731"}.el-icon-chat-round:before{content:"\e732"}.el-icon-set-up:before{content:"\e733"}.el-icon-turn-off:before{content:"\e734"}.el-icon-open:before{content:"\e735"}.el-icon-connection:before{content:"\e736"}.el-icon-link:before{content:"\e737"}.el-icon-cpu:before{content:"\e738"}.el-icon-thumb:before{content:"\e739"}.el-icon-female:before{content:"\e73a"}.el-icon-male:before{content:"\e73b"}.el-icon-guide:before{content:"\e73c"}.el-icon-news:before{content:"\e73e"}.el-icon-price-tag:before{content:"\e744"}.el-icon-discount:before{content:"\e745"}.el-icon-wallet:before{content:"\e747"}.el-icon-coin:before{content:"\e748"}.el-icon-money:before{content:"\e749"}.el-icon-bank-card:before{content:"\e74a"}.el-icon-box:before{content:"\e74b"}.el-icon-present:before{content:"\e74c"}.el-icon-sell:before{content:"\e6d5"}.el-icon-sold-out:before{content:"\e6d6"}.el-icon-shopping-bag-2:before{content:"\e74d"}.el-icon-shopping-bag-1:before{content:"\e74e"}.el-icon-shopping-cart-2:before{content:"\e74f"}.el-icon-shopping-cart-1:before{content:"\e750"}.el-icon-shopping-cart-full:before{content:"\e751"}.el-icon-smoking:before{content:"\e752"}.el-icon-no-smoking:before{content:"\e753"}.el-icon-house:before{content:"\e754"}.el-icon-table-lamp:before{content:"\e755"}.el-icon-school:before{content:"\e756"}.el-icon-office-building:before{content:"\e757"}.el-icon-toilet-paper:before{content:"\e758"}.el-icon-notebook-2:before{content:"\e759"}.el-icon-notebook-1:before{content:"\e75a"}.el-icon-files:before{content:"\e75b"}.el-icon-collection:before{content:"\e75c"}.el-icon-receiving:before{content:"\e75d"}.el-icon-suitcase-1:before{content:"\e760"}.el-icon-suitcase:before{content:"\e761"}.el-icon-film:before{content:"\e763"}.el-icon-collection-tag:before{content:"\e765"}.el-icon-data-analysis:before{content:"\e766"}.el-icon-pie-chart:before{content:"\e767"}.el-icon-data-board:before{content:"\e768"}.el-icon-data-line:before{content:"\e76d"}.el-icon-reading:before{content:"\e769"}.el-icon-magic-stick:before{content:"\e76a"}.el-icon-coordinate:before{content:"\e76b"}.el-icon-mouse:before{content:"\e76c"}.el-icon-brush:before{content:"\e76e"}.el-icon-headset:before{content:"\e76f"}.el-icon-umbrella:before{content:"\e770"}.el-icon-scissors:before{content:"\e771"}.el-icon-mobile:before{content:"\e773"}.el-icon-attract:before{content:"\e774"}.el-icon-monitor:before{content:"\e775"}.el-icon-search:before{content:"\e778"}.el-icon-takeaway-box:before{content:"\e77a"}.el-icon-paperclip:before{content:"\e77d"}.el-icon-printer:before{content:"\e77e"}.el-icon-document-add:before{content:"\e782"}.el-icon-document:before{content:"\e785"}.el-icon-document-checked:before{content:"\e786"}.el-icon-document-copy:before{content:"\e787"}.el-icon-document-delete:before{content:"\e788"}.el-icon-document-remove:before{content:"\e789"}.el-icon-tickets:before{content:"\e78b"}.el-icon-folder-checked:before{content:"\e77f"}.el-icon-folder-delete:before{content:"\e780"}.el-icon-folder-remove:before{content:"\e781"}.el-icon-folder-add:before{content:"\e783"}.el-icon-folder-opened:before{content:"\e784"}.el-icon-folder:before{content:"\e78a"}.el-icon-edit-outline:before{content:"\e764"}.el-icon-edit:before{content:"\e78c"}.el-icon-date:before{content:"\e78e"}.el-icon-c-scale-to-original:before{content:"\e7c6"}.el-icon-view:before{content:"\e6ce"}.el-icon-loading:before{content:"\e6cf"}.el-icon-rank:before{content:"\e6d1"}.el-icon-sort-down:before{content:"\e7c4"}.el-icon-sort-up:before{content:"\e7c5"}.el-icon-sort:before{content:"\e6d2"}.el-icon-finished:before{content:"\e6cd"}.el-icon-refresh-left:before{content:"\e6c7"}.el-icon-refresh-right:before{content:"\e6c8"}.el-icon-refresh:before{content:"\e6d0"}.el-icon-video-play:before{content:"\e7c0"}.el-icon-video-pause:before{content:"\e7c1"}.el-icon-d-arrow-right:before{content:"\e6dc"}.el-icon-d-arrow-left:before{content:"\e6dd"}.el-icon-arrow-up:before{content:"\e6e1"}.el-icon-arrow-down:before{content:"\e6df"}.el-icon-arrow-right:before{content:"\e6e0"}.el-icon-arrow-left:before{content:"\e6de"}.el-icon-top-right:before{content:"\e6e7"}.el-icon-top-left:before{content:"\e6e8"}.el-icon-top:before{content:"\e6e6"}.el-icon-bottom:before{content:"\e6eb"}.el-icon-right:before{content:"\e6e9"}.el-icon-back:before{content:"\e6ea"}.el-icon-bottom-right:before{content:"\e6ec"}.el-icon-bottom-left:before{content:"\e6ed"}.el-icon-caret-top:before{content:"\e78f"}.el-icon-caret-bottom:before{content:"\e790"}.el-icon-caret-right:before{content:"\e791"}.el-icon-caret-left:before{content:"\e792"}.el-icon-d-caret:before{content:"\e79a"}.el-icon-share:before{content:"\e793"}.el-icon-menu:before{content:"\e798"}.el-icon-s-grid:before{content:"\e7a6"}.el-icon-s-check:before{content:"\e7a7"}.el-icon-s-data:before{content:"\e7a8"}.el-icon-s-opportunity:before{content:"\e7aa"}.el-icon-s-custom:before{content:"\e7ab"}.el-icon-s-claim:before{content:"\e7ad"}.el-icon-s-finance:before{content:"\e7ae"}.el-icon-s-comment:before{content:"\e7af"}.el-icon-s-flag:before{content:"\e7b0"}.el-icon-s-marketing:before{content:"\e7b1"}.el-icon-s-shop:before{content:"\e7b4"}.el-icon-s-open:before{content:"\e7b5"}.el-icon-s-management:before{content:"\e7b6"}.el-icon-s-ticket:before{content:"\e7b7"}.el-icon-s-release:before{content:"\e7b8"}.el-icon-s-home:before{content:"\e7b9"}.el-icon-s-promotion:before{content:"\e7ba"}.el-icon-s-operation:before{content:"\e7bb"}.el-icon-s-unfold:before{content:"\e7bc"}.el-icon-s-fold:before{content:"\e7a9"}.el-icon-s-platform:before{content:"\e7bd"}.el-icon-s-order:before{content:"\e7be"}.el-icon-s-cooperation:before{content:"\e7bf"}.el-icon-bell:before{content:"\e725"}.el-icon-message-solid:before{content:"\e799"}.el-icon-video-camera:before{content:"\e772"}.el-icon-video-camera-solid:before{content:"\e796"}.el-icon-camera:before{content:"\e779"}.el-icon-camera-solid:before{content:"\e79b"}.el-icon-download:before{content:"\e77c"}.el-icon-upload2:before{content:"\e77b"}.el-icon-upload:before{content:"\e7c3"}.el-icon-picture-outline-round:before{content:"\e75f"}.el-icon-picture-outline:before{content:"\e75e"}.el-icon-picture:before{content:"\e79f"}.el-icon-close:before{content:"\e6db"}.el-icon-check:before{content:"\e6da"}.el-icon-plus:before{content:"\e6d9"}.el-icon-minus:before{content:"\e6d8"}.el-icon-help:before{content:"\e73d"}.el-icon-s-help:before{content:"\e7b3"}.el-icon-circle-close:before{content:"\e78d"}.el-icon-circle-check:before{content:"\e720"}.el-icon-circle-plus-outline:before{content:"\e723"}.el-icon-remove-outline:before{content:"\e722"}.el-icon-zoom-out:before{content:"\e776"}.el-icon-zoom-in:before{content:"\e777"}.el-icon-error:before{content:"\e79d"}.el-icon-success:before{content:"\e79c"}.el-icon-circle-plus:before{content:"\e7a0"}.el-icon-remove:before{content:"\e7a2"}.el-icon-info:before{content:"\e7a1"}.el-icon-question:before{content:"\e7a4"}.el-icon-warning-outline:before{content:"\e6c9"}.el-icon-warning:before{content:"\e7a3"}.el-icon-goods:before{content:"\e7c2"}.el-icon-s-goods:before{content:"\e7b2"}.el-icon-star-off:before{content:"\e717"}.el-icon-star-on:before{content:"\e797"}.el-icon-more-outline:before{content:"\e6cc"}.el-icon-more:before{content:"\e794"}.el-icon-phone-outline:before{content:"\e6cb"}.el-icon-phone:before{content:"\e795"}.el-icon-user:before{content:"\e6e3"}.el-icon-user-solid:before{content:"\e7a5"}.el-icon-setting:before{content:"\e6ca"}.el-icon-s-tools:before{content:"\e7ac"}.el-icon-delete:before{content:"\e6d7"}.el-icon-delete-solid:before{content:"\e7c9"}.el-icon-eleme:before{content:"\e7c7"}.el-icon-platform-eleme:before{content:"\e7ca"}.el-icon-loading{-webkit-animation:rotating 2s linear infinite;animation:rotating 2s linear infinite}.el-icon--right{margin-left:5px}.el-icon--left{margin-right:5px}@-webkit-keyframes rotating{0%{transform:rotate(0)}to{transform:rotate(1turn)}}@keyframes rotating{0%{transform:rotate(0)}to{transform:rotate(1turn)}}.el-pagination{white-space:nowrap;padding:2px 5px;color:#303133;font-weight:700}.el-pagination:after,.el-pagination:before{display:table;content:""}.el-pagination:after{clear:both}.el-pagination button,.el-pagination span:not([class*=suffix]){display:inline-block;font-size:13px;min-width:35.5px;height:28px;line-height:28px;vertical-align:top;box-sizing:border-box}.el-pagination .el-input__inner{text-align:center;-moz-appearance:textfield;line-height:normal}.el-pagination .el-input__suffix{right:0;transform:scale(.8)}.el-pagination .el-select .el-input{width:100px;margin:0 5px}.el-pagination .el-select .el-input .el-input__inner{padding-right:25px;border-radius:3px}.el-pagination button{border:none;padding:0 6px;background:0 0}.el-pagination button:focus{outline:0}.el-pagination button:hover{color:#409eff}.el-pagination button:disabled{color:#c0c4cc;background-color:#fff;cursor:not-allowed}.el-pagination .btn-next,.el-pagination .btn-prev{background:50% no-repeat #fff;background-size:16px;cursor:pointer;margin:0;color:#303133}.el-pagination .btn-next .el-icon,.el-pagination .btn-prev .el-icon{display:block;font-size:12px;font-weight:700}.el-pagination .btn-prev{padding-right:12px}.el-pagination .btn-next{padding-left:12px}.el-pagination .el-pager li.disabled{color:#c0c4cc;cursor:not-allowed}.el-pager li,.el-pager li.btn-quicknext:hover,.el-pager li.btn-quickprev:hover{cursor:pointer}.el-pagination--small .btn-next,.el-pagination--small .btn-prev,.el-pagination--small .el-pager li,.el-pagination--small .el-pager li.btn-quicknext,.el-pagination--small .el-pager li.btn-quickprev,.el-pagination--small .el-pager li:last-child{border-color:transparent;font-size:12px;line-height:22px;height:22px;min-width:22px}.el-pagination--small .more:before,.el-pagination--small li.more:before{line-height:24px}.el-pagination--small button,.el-pagination--small span:not([class*=suffix]){height:22px;line-height:22px}.el-pagination--small .el-pagination__editor,.el-pagination--small .el-pagination__editor.el-input .el-input__inner{height:22px}.el-pagination__sizes{margin:0 10px 0 0;font-weight:400;color:#606266}.el-pagination__sizes .el-input .el-input__inner{font-size:13px;padding-left:8px}.el-pagination__sizes .el-input .el-input__inner:hover{border-color:#409eff}.el-pagination__total{margin-right:10px;font-weight:400;color:#606266}.el-pagination__jump{margin-left:24px;font-weight:400;color:#606266}.el-pagination__jump .el-input__inner{padding:0 3px}.el-pagination__rightwrapper{float:right}.el-pagination__editor{line-height:18px;padding:0 2px;height:28px;text-align:center;margin:0 2px;box-sizing:border-box;border-radius:3px}.el-pager,.el-pagination.is-background .btn-next,.el-pagination.is-background .btn-prev{padding:0}.el-pagination__editor.el-input{width:50px}.el-pagination__editor.el-input .el-input__inner{height:28px}.el-pagination__editor .el-input__inner::-webkit-inner-spin-button,.el-pagination__editor .el-input__inner::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}.el-pagination.is-background .btn-next,.el-pagination.is-background .btn-prev,.el-pagination.is-background .el-pager li{margin:0 5px;background-color:#f4f4f5;color:#606266;min-width:30px;border-radius:2px}.el-pagination.is-background .btn-next.disabled,.el-pagination.is-background .btn-next:disabled,.el-pagination.is-background .btn-prev.disabled,.el-pagination.is-background .btn-prev:disabled,.el-pagination.is-background .el-pager li.disabled{color:#c0c4cc}.el-pagination.is-background .el-pager li:not(.disabled):hover{color:#409eff}.el-pagination.is-background .el-pager li:not(.disabled).active{background-color:#409eff;color:#fff}.el-dialog,.el-pager li{background:#fff;-webkit-box-sizing:border-box}.el-pagination.is-background.el-pagination--small .btn-next,.el-pagination.is-background.el-pagination--small .btn-prev,.el-pagination.is-background.el-pagination--small .el-pager li{margin:0 3px;min-width:22px}.el-pager,.el-pager li{vertical-align:top;margin:0;display:inline-block}.el-pager{-ms-user-select:none;user-select:none;list-style:none;font-size:0}.el-date-table,.el-pager,.el-table th.el-table__cell{-webkit-user-select:none;-moz-user-select:none}.el-pager .more:before{line-height:30px}.el-pager li{padding:0 4px;font-size:13px;min-width:35.5px;height:28px;line-height:28px;box-sizing:border-box;text-align:center}.el-menu--collapse .el-menu .el-submenu,.el-menu--popup{min-width:200px}.el-pager li.btn-quicknext,.el-pager li.btn-quickprev{line-height:28px;color:#303133}.el-pager li.btn-quicknext.disabled,.el-pager li.btn-quickprev.disabled{color:#c0c4cc}.el-pager li.active+li{border-left:0}.el-pager li:hover{color:#409eff}.el-pager li.active{color:#409eff;cursor:default}@-webkit-keyframes v-modal-in{0%{opacity:0}}@-webkit-keyframes v-modal-out{to{opacity:0}}.el-dialog{position:relative;margin:0 auto 50px;border-radius:2px;box-shadow:0 1px 3px rgba(0,0,0,.3);box-sizing:border-box;width:50%}.el-dialog.is-fullscreen{width:100%;margin-top:0;margin-bottom:0;height:100%;overflow:auto}.el-dialog__wrapper{position:fixed;top:0;right:0;bottom:0;left:0;overflow:auto;margin:0}.el-dialog__header{padding:20px 20px 10px}.el-dialog__headerbtn{position:absolute;top:20px;right:20px;padding:0;background:0 0;border:none;outline:0;cursor:pointer;font-size:16px}.el-dialog__headerbtn .el-dialog__close{color:#909399}.el-dialog__headerbtn:focus .el-dialog__close,.el-dialog__headerbtn:hover .el-dialog__close{color:#409eff}.el-dialog__title{line-height:24px;font-size:18px;color:#303133}.el-dialog__body{padding:30px 20px;color:#606266;font-size:14px;word-break:break-all}.el-dialog__footer{padding:10px 20px 20px;text-align:right;box-sizing:border-box}.el-dialog--center{text-align:center}.el-dialog--center .el-dialog__body{text-align:initial;padding:25px 25px 30px}.el-dialog--center .el-dialog__footer{text-align:inherit}.dialog-fade-enter-active{-webkit-animation:dialog-fade-in .3s;animation:dialog-fade-in .3s}.dialog-fade-leave-active{-webkit-animation:dialog-fade-out .3s;animation:dialog-fade-out .3s}@-webkit-keyframes dialog-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@keyframes dialog-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@-webkit-keyframes dialog-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}@keyframes dialog-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}.el-autocomplete{position:relative;display:inline-block}.el-autocomplete-suggestion{margin:5px 0;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);border-radius:4px;border:1px solid #e4e7ed;box-sizing:border-box;background-color:#fff}.el-dropdown-menu,.el-menu--collapse .el-submenu .el-menu{z-index:10;-webkit-box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-autocomplete-suggestion__wrap{max-height:280px;padding:10px 0;box-sizing:border-box}.el-autocomplete-suggestion__list{margin:0;padding:0}.el-autocomplete-suggestion li{padding:0 20px;margin:0;line-height:34px;cursor:pointer;color:#606266;font-size:14px;list-style:none;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.el-autocomplete-suggestion li.highlighted,.el-autocomplete-suggestion li:hover{background-color:#f5f7fa}.el-autocomplete-suggestion li.divider{margin-top:6px;border-top:1px solid #000}.el-autocomplete-suggestion li.divider:last-child{margin-bottom:-6px}.el-autocomplete-suggestion.is-loading li{text-align:center;height:100px;line-height:100px;font-size:20px;color:#999}.el-autocomplete-suggestion.is-loading li:after{display:inline-block;content:"";height:100%;vertical-align:middle}.el-autocomplete-suggestion.is-loading li:hover{background-color:#fff}.el-autocomplete-suggestion.is-loading .el-icon-loading{vertical-align:middle}.el-dropdown{display:inline-block;position:relative;color:#606266;font-size:14px}.el-dropdown .el-button-group{display:block}.el-dropdown .el-button-group .el-button{float:none}.el-dropdown .el-dropdown__caret-button{padding-left:5px;padding-right:5px;position:relative;border-left:none}.el-dropdown .el-dropdown__caret-button:before{content:"";position:absolute;display:block;width:1px;top:5px;bottom:5px;left:0;background:hsla(0,0%,100%,.5)}.el-dropdown .el-dropdown__caret-button.el-button--default:before{background:rgba(220,223,230,.5)}.el-dropdown .el-dropdown__caret-button:hover:not(.is-disabled):before{top:0;bottom:0}.el-dropdown .el-dropdown__caret-button .el-dropdown__icon{padding-left:0}.el-dropdown__icon{font-size:12px;margin:0 3px}.el-dropdown [disabled]{cursor:not-allowed;color:#bbb}.el-dropdown-menu{position:absolute;top:0;left:0;padding:10px 0;margin:5px 0;background-color:#fff;border:1px solid #ebeef5;border-radius:4px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-dropdown-menu__item{list-style:none;line-height:36px;padding:0 20px;margin:0;font-size:14px;color:#606266;cursor:pointer;outline:0}.el-dropdown-menu__item:focus,.el-dropdown-menu__item:not(.is-disabled):hover{background-color:#ecf5ff;color:#66b1ff}.el-dropdown-menu__item i{margin-right:5px}.el-dropdown-menu__item--divided{position:relative;margin-top:6px;border-top:1px solid #ebeef5}.el-dropdown-menu__item--divided:before{content:"";height:6px;display:block;margin:0 -20px;background-color:#fff}.el-dropdown-menu__item.is-disabled{cursor:default;color:#bbb;pointer-events:none}.el-dropdown-menu--medium{padding:6px 0}.el-dropdown-menu--medium .el-dropdown-menu__item{line-height:30px;padding:0 17px;font-size:14px}.el-dropdown-menu--medium .el-dropdown-menu__item.el-dropdown-menu__item--divided{margin-top:6px}.el-dropdown-menu--medium .el-dropdown-menu__item.el-dropdown-menu__item--divided:before{height:6px;margin:0 -17px}.el-dropdown-menu--small{padding:6px 0}.el-dropdown-menu--small .el-dropdown-menu__item{line-height:27px;padding:0 15px;font-size:13px}.el-dropdown-menu--small .el-dropdown-menu__item.el-dropdown-menu__item--divided{margin-top:4px}.el-dropdown-menu--small .el-dropdown-menu__item.el-dropdown-menu__item--divided:before{height:4px;margin:0 -15px}.el-dropdown-menu--mini{padding:3px 0}.el-dropdown-menu--mini .el-dropdown-menu__item{line-height:24px;padding:0 10px;font-size:12px}.el-dropdown-menu--mini .el-dropdown-menu__item.el-dropdown-menu__item--divided{margin-top:3px}.el-dropdown-menu--mini .el-dropdown-menu__item.el-dropdown-menu__item--divided:before{height:3px;margin:0 -10px}.el-menu{border-right:1px solid #e6e6e6;list-style:none;position:relative;margin:0;padding-left:0}.el-menu,.el-menu--horizontal>.el-menu-item:not(.is-disabled):focus,.el-menu--horizontal>.el-menu-item:not(.is-disabled):hover,.el-menu--horizontal>.el-submenu .el-submenu__title:hover{background-color:#fff}.el-menu:after,.el-menu:before{display:table;content:""}.el-menu:after{clear:both}.el-menu.el-menu--horizontal{border-bottom:1px solid #e6e6e6}.el-menu--horizontal{border-right:none}.el-menu--horizontal>.el-menu-item{float:left;height:60px;line-height:60px;margin:0;border-bottom:2px solid transparent;color:#909399}.el-menu--horizontal>.el-menu-item a,.el-menu--horizontal>.el-menu-item a:hover{color:inherit}.el-menu--horizontal>.el-submenu{float:left}.el-menu--horizontal>.el-submenu:focus,.el-menu--horizontal>.el-submenu:hover{outline:0}.el-menu--horizontal>.el-submenu:focus .el-submenu__title,.el-menu--horizontal>.el-submenu:hover .el-submenu__title{color:#303133}.el-menu--horizontal>.el-submenu.is-active .el-submenu__title{border-bottom:2px solid #409eff;color:#303133}.el-menu--horizontal>.el-submenu .el-submenu__title{height:60px;line-height:60px;border-bottom:2px solid transparent;color:#909399}.el-menu--horizontal>.el-submenu .el-submenu__icon-arrow{position:static;vertical-align:middle;margin-left:8px;margin-top:-3px}.el-menu--horizontal .el-menu .el-menu-item,.el-menu--horizontal .el-menu .el-submenu__title{background-color:#fff;float:none;height:36px;line-height:36px;padding:0 10px;color:#909399}.el-menu--horizontal .el-menu .el-menu-item.is-active,.el-menu--horizontal .el-menu .el-submenu.is-active>.el-submenu__title{color:#303133}.el-menu--horizontal .el-menu-item:not(.is-disabled):focus,.el-menu--horizontal .el-menu-item:not(.is-disabled):hover{outline:0;color:#303133}.el-menu--horizontal>.el-menu-item.is-active{border-bottom:2px solid #409eff;color:#303133}.el-menu--collapse{width:64px}.el-menu--collapse>.el-menu-item [class^=el-icon-],.el-menu--collapse>.el-submenu>.el-submenu__title [class^=el-icon-]{margin:0;vertical-align:middle;width:24px;text-align:center}.el-menu--collapse>.el-menu-item .el-submenu__icon-arrow,.el-menu--collapse>.el-submenu>.el-submenu__title .el-submenu__icon-arrow{display:none}.el-menu--collapse>.el-menu-item span,.el-menu--collapse>.el-submenu>.el-submenu__title span{height:0;width:0;overflow:hidden;visibility:hidden;display:inline-block}.el-menu--collapse>.el-menu-item.is-active i{color:inherit}.el-menu--collapse .el-submenu{position:relative}.el-menu--collapse .el-submenu .el-menu{position:absolute;margin-left:5px;top:0;left:100%;border:1px solid #e4e7ed;border-radius:2px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-menu-item,.el-submenu__title{height:56px;line-height:56px;position:relative;-webkit-box-sizing:border-box;white-space:nowrap;list-style:none}.el-menu--collapse .el-submenu.is-opened>.el-submenu__title .el-submenu__icon-arrow{transform:none}.el-menu--popup{z-index:100;border:none;padding:5px 0;border-radius:2px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-menu--popup-bottom-start{margin-top:5px}.el-menu--popup-right-start{margin-left:5px;margin-right:5px}.el-menu-item{font-size:14px;color:#303133;padding:0 20px;cursor:pointer;transition:border-color .3s,background-color .3s,color .3s;box-sizing:border-box}.el-menu-item *{vertical-align:middle}.el-menu-item i{color:#909399}.el-menu-item:focus,.el-menu-item:hover{outline:0;background-color:#ecf5ff}.el-menu-item.is-disabled{opacity:.25;cursor:not-allowed;background:0 0!important}.el-menu-item [class^=el-icon-]{margin-right:5px;width:24px;text-align:center;font-size:18px;vertical-align:middle}.el-menu-item.is-active{color:#409eff}.el-menu-item.is-active i{color:inherit}.el-submenu{list-style:none;margin:0;padding-left:0}.el-submenu__title{font-size:14px;color:#303133;padding:0 20px;cursor:pointer;transition:border-color .3s,background-color .3s,color .3s;box-sizing:border-box}.el-submenu__title *{vertical-align:middle}.el-submenu__title i{color:#909399}.el-submenu__title:focus,.el-submenu__title:hover{outline:0;background-color:#ecf5ff}.el-submenu__title.is-disabled{opacity:.25;cursor:not-allowed;background:0 0!important}.el-submenu__title:hover{background-color:#ecf5ff}.el-submenu .el-menu{border:none}.el-submenu .el-menu-item{height:50px;line-height:50px;padding:0 45px;min-width:200px}.el-submenu__icon-arrow{position:absolute;top:50%;right:20px;margin-top:-7px;transition:transform .3s;font-size:12px}.el-submenu.is-active .el-submenu__title{border-bottom-color:#409eff}.el-submenu.is-opened>.el-submenu__title .el-submenu__icon-arrow{transform:rotate(180deg)}.el-submenu.is-disabled .el-menu-item,.el-submenu.is-disabled .el-submenu__title{opacity:.25;cursor:not-allowed;background:0 0!important}.el-submenu [class^=el-icon-]{vertical-align:middle;margin-right:5px;width:24px;text-align:center;font-size:18px}.el-menu-item-group>ul{padding:0}.el-menu-item-group__title{padding:7px 0 7px 20px;line-height:normal;font-size:12px;color:#909399}.el-radio-button__inner,.el-radio-group{display:inline-block;line-height:1;vertical-align:middle}.horizontal-collapse-transition .el-submenu__title .el-submenu__icon-arrow{transition:.2s;opacity:0}.el-radio-group{font-size:0}.el-radio-button{position:relative;display:inline-block;outline:0}.el-radio-button__inner{white-space:nowrap;background:#fff;border:1px solid #dcdfe6;font-weight:500;border-left:0;color:#606266;-webkit-appearance:none;text-align:center;box-sizing:border-box;outline:0;margin:0;position:relative;cursor:pointer;transition:all .3s cubic-bezier(.645,.045,.355,1);padding:12px 20px;font-size:14px;border-radius:0}.el-radio-button__inner.is-round{padding:12px 20px}.el-radio-button__inner:hover{color:#409eff}.el-radio-button__inner [class*=el-icon-]{line-height:.9}.el-radio-button__inner [class*=el-icon-]+span{margin-left:5px}.el-radio-button:first-child .el-radio-button__inner{border-left:1px solid #dcdfe6;border-radius:4px 0 0 4px;box-shadow:none!important}.el-radio-button__orig-radio{opacity:0;outline:0;position:absolute;z-index:-1}.el-radio-button__orig-radio:checked+.el-radio-button__inner{color:#fff;background-color:#409eff;border-color:#409eff;box-shadow:-1px 0 0 0 #409eff}.el-radio-button__orig-radio:disabled+.el-radio-button__inner{color:#c0c4cc;cursor:not-allowed;background-image:none;background-color:#fff;border-color:#ebeef5;box-shadow:none}.el-radio-button__orig-radio:disabled:checked+.el-radio-button__inner{background-color:#f2f6fc}.el-radio-button:last-child .el-radio-button__inner{border-radius:0 4px 4px 0}.el-popover,.el-radio-button:first-child:last-child .el-radio-button__inner{border-radius:4px}.el-radio-button--medium .el-radio-button__inner{padding:10px 20px;font-size:14px;border-radius:0}.el-radio-button--medium .el-radio-button__inner.is-round{padding:10px 20px}.el-radio-button--small .el-radio-button__inner{padding:9px 15px;font-size:12px;border-radius:0}.el-radio-button--small .el-radio-button__inner.is-round{padding:9px 15px}.el-radio-button--mini .el-radio-button__inner{padding:7px 15px;font-size:12px;border-radius:0}.el-radio-button--mini .el-radio-button__inner.is-round{padding:7px 15px}.el-radio-button:focus:not(.is-focus):not(:active):not(.is-disabled){box-shadow:0 0 2px 2px #409eff}.el-switch{display:inline-flex;align-items:center;position:relative;font-size:14px;line-height:20px;height:20px;vertical-align:middle}.el-switch__core,.el-switch__label{display:inline-block;cursor:pointer}.el-switch.is-disabled .el-switch__core,.el-switch.is-disabled .el-switch__label{cursor:not-allowed}.el-switch__label{transition:.2s;height:20px;font-size:14px;font-weight:500;vertical-align:middle;color:#303133}.el-switch__label.is-active{color:#409eff}.el-switch__label--left{margin-right:10px}.el-switch__label--right{margin-left:10px}.el-switch__label *{line-height:1;font-size:14px;display:inline-block}.el-switch__input{position:absolute;width:0;height:0;opacity:0;margin:0}.el-switch__core{margin:0;position:relative;width:40px;height:20px;border:1px solid #dcdfe6;outline:0;border-radius:10px;box-sizing:border-box;background:#dcdfe6;transition:border-color .3s,background-color .3s;vertical-align:middle}.el-switch__core:after{content:"";position:absolute;top:1px;left:1px;border-radius:100%;transition:all .3s;width:16px;height:16px;background-color:#fff}.el-switch.is-checked .el-switch__core{border-color:#409eff;background-color:#409eff}.el-switch.is-checked .el-switch__core:after{left:100%;margin-left:-17px}.el-switch.is-disabled{opacity:.6}.el-switch--wide .el-switch__label.el-switch__label--left span{left:10px}.el-switch--wide .el-switch__label.el-switch__label--right span{right:10px}.el-switch .label-fade-enter,.el-switch .label-fade-leave-active{opacity:0}.el-select-dropdown{position:absolute;z-index:1001;border:1px solid #e4e7ed;border-radius:4px;background-color:#fff;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);box-sizing:border-box;margin:5px 0}.el-select-dropdown.is-multiple .el-select-dropdown__item{padding-right:40px}.el-select-dropdown.is-multiple .el-select-dropdown__item.selected{color:#409eff;background-color:#fff}.el-select-dropdown.is-multiple .el-select-dropdown__item.selected.hover{background-color:#f5f7fa}.el-select-dropdown.is-multiple .el-select-dropdown__item.selected:after{position:absolute;right:20px;font-family:element-icons;content:"\e6da";font-size:12px;font-weight:700;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.el-select-dropdown .el-scrollbar.is-empty .el-select-dropdown__list{padding:0}.el-select-dropdown__empty{padding:10px 0;margin:0;text-align:center;color:#999;font-size:14px}.el-select-dropdown__wrap{max-height:274px}.el-select-dropdown__list{list-style:none;padding:6px 0;margin:0;box-sizing:border-box}.el-select-dropdown__item{font-size:14px;padding:0 20px;position:relative;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;color:#606266;height:34px;line-height:34px;box-sizing:border-box;cursor:pointer}.el-select-dropdown__item.is-disabled{color:#c0c4cc;cursor:not-allowed}.el-select-dropdown__item.is-disabled:hover{background-color:#fff}.el-select-dropdown__item.hover,.el-select-dropdown__item:hover{background-color:#f5f7fa}.el-select-dropdown__item.selected{color:#409eff;font-weight:700}.el-select-group{margin:0;padding:0}.el-select-group__wrap{position:relative;list-style:none;margin:0;padding:0}.el-select-group__wrap:not(:last-of-type){padding-bottom:24px}.el-select-group__wrap:not(:last-of-type):after{content:"";position:absolute;display:block;left:20px;right:20px;bottom:12px;height:1px;background:#e4e7ed}.el-select-group__title{padding-left:20px;font-size:12px;color:#909399;line-height:30px}.el-select-group .el-select-dropdown__item{padding-left:20px}.el-select{display:inline-block;position:relative}.el-select .el-select__tags>span{display:contents}.el-select:hover .el-input__inner{border-color:#c0c4cc}.el-select .el-input__inner{cursor:pointer;padding-right:35px}.el-select .el-input__inner:focus{border-color:#409eff}.el-select .el-input .el-select__caret{color:#c0c4cc;font-size:14px;transition:transform .3s;transform:rotate(180deg);cursor:pointer}.el-select .el-input .el-select__caret.is-reverse{transform:rotate(0)}.el-select .el-input .el-select__caret.is-show-close{font-size:14px;text-align:center;transform:rotate(180deg);border-radius:100%;color:#c0c4cc;transition:color .2s cubic-bezier(.645,.045,.355,1)}.el-select .el-input .el-select__caret.is-show-close:hover{color:#909399}.el-select .el-input.is-disabled .el-input__inner{cursor:not-allowed}.el-select .el-input.is-disabled .el-input__inner:hover{border-color:#e4e7ed}.el-select .el-input.is-focus .el-input__inner{border-color:#409eff}.el-select>.el-input{display:block}.el-select__input{border:none;outline:0;padding:0;margin-left:15px;color:#666;font-size:14px;-webkit-appearance:none;-moz-appearance:none;appearance:none;height:28px;background-color:transparent}.el-select__input.is-mini{height:14px}.el-select__close{cursor:pointer;position:absolute;top:8px;z-index:1000;right:25px;color:#c0c4cc;line-height:18px;font-size:14px}.el-select__close:hover{color:#909399}.el-select__tags{position:absolute;line-height:normal;white-space:normal;z-index:1;top:50%;transform:translateY(-50%);display:flex;align-items:center;flex-wrap:wrap}.el-select__tags-text{overflow:hidden;text-overflow:ellipsis}.el-select .el-tag{box-sizing:border-box;border-color:transparent;margin:2px 0 2px 6px;background-color:#f0f2f5;display:flex;max-width:100%;align-items:center}.el-select .el-tag__close.el-icon-close{background-color:#c0c4cc;top:0;color:#fff;flex-shrink:0}.el-select .el-tag__close.el-icon-close:hover{background-color:#909399}.el-table,.el-table__expanded-cell{background-color:#fff}.el-select .el-tag__close.el-icon-close:before{display:block;transform:translateY(.5px)}.el-table{position:relative;overflow:hidden;box-sizing:border-box;flex:1;width:100%;max-width:100%;font-size:14px;color:#606266}.el-table--mini,.el-table--small,.el-table__expand-icon{font-size:12px}.el-table__empty-block{min-height:60px;text-align:center;width:100%;display:flex;justify-content:center;align-items:center}.el-table__empty-text{line-height:60px;width:50%;color:#909399}.el-table__expand-column .cell{padding:0;text-align:center}.el-table__expand-icon{position:relative;cursor:pointer;color:#666;transition:transform .2s ease-in-out;height:20px}.el-table__expand-icon--expanded{transform:rotate(90deg)}.el-table__expand-icon>.el-icon{position:absolute;left:50%;top:50%;margin-left:-5px;margin-top:-5px}.el-table__expanded-cell[class*=cell]{padding:20px 50px}.el-table__expanded-cell:hover{background-color:transparent!important}.el-table__placeholder{display:inline-block;width:20px}.el-table__append-wrapper{overflow:hidden}.el-table--fit{border-right:0;border-bottom:0}.el-table--fit .el-table__cell.gutter{border-right-width:1px}.el-table--scrollable-x .el-table__body-wrapper{overflow-x:auto}.el-table--scrollable-y .el-table__body-wrapper{overflow-y:auto}.el-table thead{color:#909399;font-weight:500}.el-table thead.is-group th.el-table__cell{background:#f5f7fa}.el-table .el-table__cell{padding:12px 0;min-width:0;box-sizing:border-box;text-overflow:ellipsis;vertical-align:middle;position:relative;text-align:left}.el-table .el-table__cell.is-center{text-align:center}.el-table .el-table__cell.is-right{text-align:right}.el-table .el-table__cell.gutter{width:15px;border-right-width:0;border-bottom-width:0;padding:0}.el-table--medium .el-table__cell{padding:10px 0}.el-table--small .el-table__cell{padding:8px 0}.el-table--mini .el-table__cell{padding:6px 0}.el-table--border .el-table__cell:first-child .cell,.el-table .cell{padding-left:10px}.el-table tr{background-color:#fff}.el-table tr input[type=checkbox]{margin:0}.el-table td.el-table__cell,.el-table th.el-table__cell.is-leaf{border-bottom:1px solid #ebeef5}.el-table th.el-table__cell.is-sortable{cursor:pointer}.el-table th.el-table__cell{overflow:hidden;-ms-user-select:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;background-color:#fff}.el-table th.el-table__cell>.cell{display:inline-block;box-sizing:border-box;position:relative;vertical-align:middle;padding-left:10px;padding-right:10px;width:100%}.el-table th.el-table__cell>.cell.highlight{color:#409eff}.el-table th.el-table__cell.required>div:before{display:inline-block;content:"";width:8px;height:8px;border-radius:50%;background:#ff4d51;margin-right:5px;vertical-align:middle}.el-table td.el-table__cell div{box-sizing:border-box}.el-table td.el-table__cell.gutter{width:0}.el-table .cell{box-sizing:border-box;overflow:hidden;text-overflow:ellipsis;white-space:normal;word-break:break-all;line-height:23px;padding-right:10px}.el-table .cell.el-tooltip{white-space:nowrap;min-width:50px}.el-table--border,.el-table--group{border:1px solid #ebeef5}.el-table--border:after,.el-table--group:after,.el-table:before{content:"";position:absolute;background-color:#ebeef5;z-index:1}.el-table--border:after,.el-table--group:after{top:0;right:0;width:1px;height:100%}.el-table:before{left:0;bottom:0;width:100%;height:1px}.el-table--border{border-right:none;border-bottom:none}.el-table--border.el-loading-parent--relative{border-color:transparent}.el-table--border .el-table__cell,.el-table__body-wrapper .el-table--border.is-scrolling-left~.el-table__fixed{border-right:1px solid #ebeef5}.el-table--border th.el-table__cell.gutter:last-of-type{border-bottom:1px solid #ebeef5;border-bottom-width:1px}.el-table--border th.el-table__cell,.el-table__fixed-right-patch{border-bottom:1px solid #ebeef5}.el-table__fixed,.el-table__fixed-right{position:absolute;top:0;left:0;overflow-x:hidden;overflow-y:hidden;box-shadow:0 0 10px rgba(0,0,0,.12)}.el-table__fixed-right:before,.el-table__fixed:before{content:"";position:absolute;left:0;bottom:0;width:100%;height:1px;background-color:#ebeef5;z-index:4}.el-table__fixed-right-patch{position:absolute;top:-1px;right:0;background-color:#fff}.el-table__fixed-right{top:0;left:auto;right:0}.el-table__fixed-right .el-table__fixed-body-wrapper,.el-table__fixed-right .el-table__fixed-footer-wrapper,.el-table__fixed-right .el-table__fixed-header-wrapper{left:auto;right:0}.el-table__fixed-header-wrapper{position:absolute;left:0;top:0;z-index:3}.el-table__fixed-footer-wrapper{position:absolute;left:0;bottom:0;z-index:3}.el-table__fixed-footer-wrapper tbody td.el-table__cell{border-top:1px solid #ebeef5;background-color:#f5f7fa;color:#606266}.el-table__fixed-body-wrapper{position:absolute;left:0;top:37px;overflow:hidden;z-index:3}.el-table__body-wrapper,.el-table__footer-wrapper,.el-table__header-wrapper{width:100%}.el-table__footer-wrapper{margin-top:-1px}.el-table__footer-wrapper td.el-table__cell{border-top:1px solid #ebeef5}.el-table__body,.el-table__footer,.el-table__header{table-layout:fixed;border-collapse:separate}.el-table__footer-wrapper,.el-table__header-wrapper{overflow:hidden}.el-table__footer-wrapper tbody td.el-table__cell,.el-table__header-wrapper tbody td.el-table__cell{background-color:#f5f7fa;color:#606266}.el-table__body-wrapper{overflow:hidden;position:relative}.el-table__body-wrapper.is-scrolling-left~.el-table__fixed,.el-table__body-wrapper.is-scrolling-none~.el-table__fixed,.el-table__body-wrapper.is-scrolling-none~.el-table__fixed-right,.el-table__body-wrapper.is-scrolling-right~.el-table__fixed-right{box-shadow:none}.el-picker-panel,.el-table-filter{-webkit-box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-table__body-wrapper .el-table--border.is-scrolling-right~.el-table__fixed-right{border-left:1px solid #ebeef5}.el-table .caret-wrapper{display:inline-flex;flex-direction:column;align-items:center;height:34px;width:24px;vertical-align:middle;cursor:pointer;overflow:initial;position:relative}.el-table .sort-caret{width:0;height:0;border:5px solid transparent;position:absolute;left:7px}.el-table .sort-caret.ascending{border-bottom-color:#c0c4cc;top:5px}.el-table .sort-caret.descending{border-top-color:#c0c4cc;bottom:7px}.el-table .ascending .sort-caret.ascending{border-bottom-color:#409eff}.el-table .descending .sort-caret.descending{border-top-color:#409eff}.el-table .hidden-columns{position:absolute;z-index:-1}.el-table--striped .el-table__body tr.el-table__row--striped td.el-table__cell{background:#fafafa}.el-table--striped .el-table__body tr.el-table__row--striped.current-row td.el-table__cell{background-color:#ecf5ff}.el-table__body tr.hover-row.current-row>td.el-table__cell,.el-table__body tr.hover-row.el-table__row--striped.current-row>td.el-table__cell,.el-table__body tr.hover-row.el-table__row--striped>td.el-table__cell,.el-table__body tr.hover-row>td.el-table__cell{background-color:#f5f7fa}.el-table__body tr.current-row>td.el-table__cell{background-color:#ecf5ff}.el-table__column-resize-proxy{position:absolute;left:200px;top:0;bottom:0;width:0;border-left:1px solid #ebeef5;z-index:10}.el-table__column-filter-trigger{display:inline-block;line-height:34px;cursor:pointer}.el-table__column-filter-trigger i{color:#909399;font-size:12px;transform:scale(.75)}.el-table--enable-row-transition .el-table__body td.el-table__cell{transition:background-color .25s ease}.el-table--enable-row-hover .el-table__body tr:hover>td.el-table__cell{background-color:#f5f7fa}.el-table--fluid-height .el-table__fixed,.el-table--fluid-height .el-table__fixed-right{bottom:0;overflow:hidden}.el-table [class*=el-table__row--level] .el-table__expand-icon{display:inline-block;width:20px;line-height:20px;height:20px;text-align:center;margin-right:3px}.el-table-column--selection .cell{padding-left:14px;padding-right:14px}.el-table-filter{border:1px solid #ebeef5;border-radius:2px;background-color:#fff;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);box-sizing:border-box;margin:2px 0}.el-date-table td,.el-date-table td div{height:30px;-webkit-box-sizing:border-box}.el-table-filter__list{padding:5px 0;margin:0;list-style:none;min-width:100px}.el-table-filter__list-item{line-height:36px;padding:0 10px;cursor:pointer;font-size:14px}.el-table-filter__list-item:hover{background-color:#ecf5ff;color:#66b1ff}.el-table-filter__list-item.is-active{background-color:#409eff;color:#fff}.el-table-filter__content{min-width:100px}.el-table-filter__bottom{border-top:1px solid #ebeef5;padding:8px}.el-table-filter__bottom button{background:0 0;border:none;color:#606266;cursor:pointer;font-size:13px;padding:0 3px}.el-date-table.is-week-mode .el-date-table__row.current div,.el-date-table.is-week-mode .el-date-table__row:hover div,.el-date-table td.in-range div,.el-date-table td.in-range div:hover{background-color:#f2f6fc}.el-table-filter__bottom button:hover{color:#409eff}.el-table-filter__bottom button:focus{outline:0}.el-table-filter__bottom button.is-disabled{color:#c0c4cc;cursor:not-allowed}.el-table-filter__wrap{max-height:280px}.el-table-filter__checkbox-group{padding:10px}.el-table-filter__checkbox-group label.el-checkbox{display:block;margin-right:5px;margin-bottom:8px;margin-left:5px}.el-table-filter__checkbox-group .el-checkbox:last-child{margin-bottom:0}.el-date-table{font-size:12px;-ms-user-select:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.el-date-table.is-week-mode .el-date-table__row:hover td.available:hover{color:#606266}.el-date-table.is-week-mode .el-date-table__row:hover td:first-child div{margin-left:5px;border-top-left-radius:15px;border-bottom-left-radius:15px}.el-date-table.is-week-mode .el-date-table__row:hover td:last-child div{margin-right:5px;border-top-right-radius:15px;border-bottom-right-radius:15px}.el-date-table td{width:32px;padding:4px 0;box-sizing:border-box;text-align:center;cursor:pointer;position:relative}.el-date-table td div{padding:3px 0;box-sizing:border-box}.el-date-table td span{width:24px;height:24px;display:block;margin:0 auto;line-height:24px;position:absolute;left:50%;transform:translateX(-50%);border-radius:50%}.el-date-table td.next-month,.el-date-table td.prev-month{color:#c0c4cc}.el-date-table td.today{position:relative}.el-date-table td.today span{color:#409eff;font-weight:700}.el-date-table td.today.end-date span,.el-date-table td.today.start-date span{color:#fff}.el-date-table td.available:hover{color:#409eff}.el-date-table td.current:not(.disabled) span{color:#fff;background-color:#409eff}.el-date-table td.end-date div,.el-date-table td.start-date div{color:#fff}.el-date-table td.end-date span,.el-date-table td.start-date span{background-color:#409eff}.el-date-table td.start-date div{margin-left:5px;border-top-left-radius:15px;border-bottom-left-radius:15px}.el-date-table td.end-date div{margin-right:5px;border-top-right-radius:15px;border-bottom-right-radius:15px}.el-date-table td.disabled div{background-color:#f5f7fa;opacity:1;cursor:not-allowed;color:#c0c4cc}.el-date-table td.selected div{margin-left:5px;margin-right:5px;background-color:#f2f6fc;border-radius:15px}.el-date-table td.selected div:hover{background-color:#f2f6fc}.el-date-table td.selected span{background-color:#409eff;color:#fff;border-radius:15px}.el-date-table td.week{font-size:80%;color:#606266}.el-month-table,.el-year-table{font-size:12px;border-collapse:collapse}.el-date-table th{padding:5px;color:#606266;font-weight:400;border-bottom:1px solid #ebeef5}.el-month-table{margin:-1px}.el-month-table td{text-align:center;padding:8px 0;cursor:pointer}.el-month-table td div{height:48px;padding:6px 0;box-sizing:border-box}.el-month-table td.today .cell{color:#409eff;font-weight:700}.el-month-table td.today.end-date .cell,.el-month-table td.today.start-date .cell{color:#fff}.el-month-table td.disabled .cell{background-color:#f5f7fa;cursor:not-allowed;color:#c0c4cc}.el-month-table td.disabled .cell:hover{color:#c0c4cc}.el-month-table td .cell{width:60px;height:36px;display:block;line-height:36px;color:#606266;margin:0 auto;border-radius:18px}.el-month-table td .cell:hover{color:#409eff}.el-month-table td.in-range div,.el-month-table td.in-range div:hover{background-color:#f2f6fc}.el-month-table td.end-date div,.el-month-table td.start-date div{color:#fff}.el-month-table td.end-date .cell,.el-month-table td.start-date .cell{color:#fff;background-color:#409eff}.el-month-table td.start-date div{border-top-left-radius:24px;border-bottom-left-radius:24px}.el-month-table td.end-date div{border-top-right-radius:24px;border-bottom-right-radius:24px}.el-month-table td.current:not(.disabled) .cell{color:#409eff}.el-year-table{margin:-1px}.el-year-table .el-icon{color:#303133}.el-year-table td{text-align:center;padding:20px 3px;cursor:pointer}.el-year-table td.today .cell{color:#409eff;font-weight:700}.el-year-table td.disabled .cell{background-color:#f5f7fa;cursor:not-allowed;color:#c0c4cc}.el-year-table td.disabled .cell:hover{color:#c0c4cc}.el-year-table td .cell{width:48px;height:32px;display:block;line-height:32px;color:#606266;margin:0 auto}.el-year-table td .cell:hover,.el-year-table td.current:not(.disabled) .cell{color:#409eff}.el-date-range-picker{width:646px}.el-date-range-picker.has-sidebar{width:756px}.el-date-range-picker table{table-layout:fixed;width:100%}.el-date-range-picker .el-picker-panel__body{min-width:513px}.el-date-range-picker .el-picker-panel__content{margin:0}.el-date-range-picker__header{position:relative;text-align:center;height:28px}.el-date-range-picker__header [class*=arrow-left]{float:left}.el-date-range-picker__header [class*=arrow-right]{float:right}.el-date-range-picker__header div{font-size:16px;font-weight:500;margin-right:50px}.el-date-range-picker__content{float:left;width:50%;box-sizing:border-box;margin:0;padding:16px}.el-date-range-picker__content.is-left{border-right:1px solid #e4e4e4}.el-date-range-picker__content .el-date-range-picker__header div{margin-left:50px;margin-right:50px}.el-date-range-picker__editors-wrap{box-sizing:border-box;display:table-cell}.el-date-range-picker__editors-wrap.is-right{text-align:right}.el-date-range-picker__time-header{position:relative;border-bottom:1px solid #e4e4e4;font-size:12px;padding:8px 5px 5px;display:table;width:100%;box-sizing:border-box}.el-date-range-picker__time-header>.el-icon-arrow-right{font-size:20px;vertical-align:middle;display:table-cell;color:#303133}.el-date-range-picker__time-picker-wrap{position:relative;display:table-cell;padding:0 5px}.el-date-range-picker__time-picker-wrap .el-picker-panel{position:absolute;top:13px;right:0;z-index:1;background:#fff}.el-date-picker{width:322px}.el-date-picker.has-sidebar.has-time{width:434px}.el-date-picker.has-sidebar{width:438px}.el-date-picker.has-time .el-picker-panel__body-wrapper{position:relative}.el-date-picker .el-picker-panel__content{width:292px}.el-date-picker table{table-layout:fixed;width:100%}.el-date-picker__editor-wrap{position:relative;display:table-cell;padding:0 5px}.el-date-picker__time-header{position:relative;border-bottom:1px solid #e4e4e4;font-size:12px;padding:8px 5px 5px;display:table;width:100%;box-sizing:border-box}.el-date-picker__header{margin:12px;text-align:center}.el-date-picker__header--bordered{margin-bottom:0;padding-bottom:12px;border-bottom:1px solid #ebeef5}.el-date-picker__header--bordered+.el-picker-panel__content{margin-top:0}.el-date-picker__header-label{font-size:16px;font-weight:500;padding:0 5px;line-height:22px;text-align:center;cursor:pointer;color:#606266}.el-date-picker__header-label.active,.el-date-picker__header-label:hover{color:#409eff}.el-date-picker__prev-btn{float:left}.el-date-picker__next-btn{float:right}.el-date-picker__time-wrap{padding:10px;text-align:center}.el-date-picker__time-label{float:left;cursor:pointer;line-height:30px;margin-left:10px}.time-select{margin:5px 0;min-width:0}.time-select .el-picker-panel__content{max-height:200px;margin:0}.time-select-item{padding:8px 10px;font-size:14px;line-height:20px}.time-select-item.selected:not(.disabled){color:#409eff;font-weight:700}.time-select-item.disabled{color:#e4e7ed;cursor:not-allowed}.time-select-item:hover{background-color:#f5f7fa;font-weight:700;cursor:pointer}.el-date-editor{position:relative;display:inline-block;text-align:left}.el-date-editor.el-input,.el-date-editor.el-input__inner{width:220px}.el-date-editor--monthrange.el-input,.el-date-editor--monthrange.el-input__inner{width:300px}.el-date-editor--daterange.el-input,.el-date-editor--daterange.el-input__inner,.el-date-editor--timerange.el-input,.el-date-editor--timerange.el-input__inner{width:350px}.el-date-editor--datetimerange.el-input,.el-date-editor--datetimerange.el-input__inner{width:400px}.el-date-editor--dates .el-input__inner{text-overflow:ellipsis;white-space:nowrap}.el-date-editor .el-icon-circle-close{cursor:pointer}.el-date-editor .el-range__icon{font-size:14px;margin-left:-5px;color:#c0c4cc;float:left;line-height:32px}.el-date-editor .el-range-input,.el-date-editor .el-range-separator{height:100%;margin:0;text-align:center;display:inline-block;font-size:14px}.el-date-editor .el-range-input{-webkit-appearance:none;-moz-appearance:none;appearance:none;border:none;outline:0;padding:0;width:39%;color:#606266}.el-date-editor .el-range-input:-ms-input-placeholder{color:#c0c4cc}.el-date-editor .el-range-input::-moz-placeholder{color:#c0c4cc}.el-date-editor .el-range-input::placeholder{color:#c0c4cc}.el-date-editor .el-range-separator{padding:0 5px;line-height:32px;width:5%;color:#303133}.el-date-editor .el-range__close-icon{font-size:14px;color:#c0c4cc;width:25px;display:inline-block;float:right;line-height:32px}.el-range-editor.el-input__inner{display:inline-flex;align-items:center;padding:3px 10px}.el-range-editor .el-range-input{line-height:1}.el-range-editor.is-active,.el-range-editor.is-active:hover{border-color:#409eff}.el-range-editor--medium.el-input__inner{height:36px}.el-range-editor--medium .el-range-separator{line-height:28px;font-size:14px}.el-range-editor--medium .el-range-input{font-size:14px}.el-range-editor--medium .el-range__close-icon,.el-range-editor--medium .el-range__icon{line-height:28px}.el-range-editor--small.el-input__inner{height:32px}.el-range-editor--small .el-range-separator{line-height:24px;font-size:13px}.el-range-editor--small .el-range-input{font-size:13px}.el-range-editor--small .el-range__close-icon,.el-range-editor--small .el-range__icon{line-height:24px}.el-range-editor--mini.el-input__inner{height:28px}.el-range-editor--mini .el-range-separator{line-height:20px;font-size:12px}.el-range-editor--mini .el-range-input{font-size:12px}.el-range-editor--mini .el-range__close-icon,.el-range-editor--mini .el-range__icon{line-height:20px}.el-range-editor.is-disabled{background-color:#f5f7fa;border-color:#e4e7ed;color:#c0c4cc;cursor:not-allowed}.el-range-editor.is-disabled:focus,.el-range-editor.is-disabled:hover{border-color:#e4e7ed}.el-range-editor.is-disabled input{background-color:#f5f7fa;color:#c0c4cc;cursor:not-allowed}.el-range-editor.is-disabled input:-ms-input-placeholder{color:#c0c4cc}.el-range-editor.is-disabled input::-moz-placeholder{color:#c0c4cc}.el-range-editor.is-disabled input::placeholder{color:#c0c4cc}.el-range-editor.is-disabled .el-range-separator{color:#c0c4cc}.el-picker-panel{color:#606266;border:1px solid #e4e7ed;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);background:#fff;border-radius:4px;line-height:30px;margin:5px 0}.el-popover,.el-time-panel{-webkit-box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-picker-panel__body-wrapper:after,.el-picker-panel__body:after{content:"";display:table;clear:both}.el-picker-panel__content{position:relative;margin:15px}.el-picker-panel__footer{border-top:1px solid #e4e4e4;padding:4px;text-align:right;background-color:#fff;position:relative;font-size:0}.el-picker-panel__shortcut{display:block;width:100%;border:0;background-color:transparent;line-height:28px;font-size:14px;color:#606266;padding-left:12px;text-align:left;outline:0;cursor:pointer}.el-picker-panel__shortcut:hover{color:#409eff}.el-picker-panel__shortcut.active{background-color:#e6f1fe;color:#409eff}.el-picker-panel__btn{border:1px solid #dcdcdc;color:#333;line-height:24px;border-radius:2px;padding:0 20px;cursor:pointer;background-color:transparent;outline:0;font-size:12px}.el-picker-panel__btn[disabled]{color:#ccc;cursor:not-allowed}.el-picker-panel__icon-btn{font-size:12px;color:#303133;border:0;background:0 0;cursor:pointer;outline:0;margin-top:8px}.el-picker-panel__icon-btn:hover{color:#409eff}.el-picker-panel__icon-btn.is-disabled{color:#bbb}.el-picker-panel__icon-btn.is-disabled:hover{cursor:not-allowed}.el-picker-panel__link-btn{vertical-align:middle}.el-picker-panel [slot=sidebar],.el-picker-panel__sidebar{position:absolute;top:0;bottom:0;width:110px;border-right:1px solid #e4e4e4;box-sizing:border-box;padding-top:6px;background-color:#fff;overflow:auto}.el-picker-panel [slot=sidebar]+.el-picker-panel__body,.el-picker-panel__sidebar+.el-picker-panel__body{margin-left:110px}.el-time-spinner.has-seconds .el-time-spinner__wrapper{width:33.3%}.el-time-spinner__wrapper{max-height:190px;overflow:auto;display:inline-block;width:50%;vertical-align:top;position:relative}.el-time-spinner__wrapper .el-scrollbar__wrap:not(.el-scrollbar__wrap--hidden-default){padding-bottom:15px}.el-time-spinner__input.el-input .el-input__inner,.el-time-spinner__list{padding:0;text-align:center}.el-time-spinner__wrapper.is-arrow{box-sizing:border-box;text-align:center;overflow:hidden}.el-time-spinner__wrapper.is-arrow .el-time-spinner__list{transform:translateY(-32px)}.el-time-spinner__wrapper.is-arrow .el-time-spinner__item:hover:not(.disabled):not(.active){background:#fff;cursor:default}.el-time-spinner__arrow{font-size:12px;color:#909399;position:absolute;left:0;width:100%;z-index:1;text-align:center;height:30px;line-height:30px;cursor:pointer}.el-time-spinner__arrow:hover{color:#409eff}.el-time-spinner__arrow.el-icon-arrow-up{top:10px}.el-time-spinner__arrow.el-icon-arrow-down{bottom:10px}.el-time-spinner__input.el-input{width:70%}.el-time-spinner__list{margin:0;list-style:none}.el-time-spinner__list:after,.el-time-spinner__list:before{content:"";display:block;width:100%;height:80px}.el-time-spinner__item{height:32px;line-height:32px;font-size:12px;color:#606266}.el-time-spinner__item:hover:not(.disabled):not(.active){background:#f5f7fa;cursor:pointer}.el-time-spinner__item.active:not(.disabled){color:#303133;font-weight:700}.el-time-spinner__item.disabled{color:#c0c4cc;cursor:not-allowed}.el-time-panel{margin:5px 0;border:1px solid #e4e7ed;background-color:#fff;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);border-radius:2px;position:absolute;width:180px;left:0;z-index:1000;user-select:none;box-sizing:content-box}.el-slider__button,.el-slider__button-wrapper,.el-time-panel{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none}.el-time-panel__content{font-size:0;position:relative;overflow:hidden}.el-time-panel__content:after,.el-time-panel__content:before{content:"";top:50%;position:absolute;margin-top:-15px;height:32px;z-index:-1;left:0;right:0;box-sizing:border-box;padding-top:6px;text-align:left;border-top:1px solid #e4e7ed;border-bottom:1px solid #e4e7ed}.el-time-panel__content:after{left:50%;margin-left:12%;margin-right:12%}.el-time-panel__content:before{padding-left:50%;margin-right:12%;margin-left:12%}.el-time-panel__content.has-seconds:after{left:66.66667%}.el-time-panel__content.has-seconds:before{padding-left:33.33333%}.el-time-panel__footer{border-top:1px solid #e4e4e4;padding:4px;height:36px;line-height:25px;text-align:right;box-sizing:border-box}.el-time-panel__btn{border:none;line-height:28px;padding:0 5px;margin:0 5px;cursor:pointer;background-color:transparent;outline:0;font-size:12px;color:#303133}.el-time-panel__btn.confirm{font-weight:800;color:#409eff}.el-time-range-picker{width:354px;overflow:visible}.el-time-range-picker__content{position:relative;text-align:center;padding:10px}.el-time-range-picker__cell{box-sizing:border-box;margin:0;padding:4px 7px 7px;width:50%;display:inline-block}.el-time-range-picker__header{margin-bottom:5px;text-align:center;font-size:14px}.el-time-range-picker__body{border-radius:2px;border:1px solid #e4e7ed}.el-popover{position:absolute;background:#fff;min-width:150px;border:1px solid #ebeef5;padding:12px;z-index:2000;color:#606266;line-height:1.4;text-align:justify;font-size:14px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);word-break:break-all}.el-popover--plain{padding:18px 20px}.el-popover__title{color:#303133;font-size:16px;line-height:1;margin-bottom:12px}.v-modal-enter{-webkit-animation:v-modal-in .2s ease;animation:v-modal-in .2s ease}.v-modal-leave{-webkit-animation:v-modal-out .2s ease forwards;animation:v-modal-out .2s ease forwards}@keyframes v-modal-in{0%{opacity:0}}@keyframes v-modal-out{to{opacity:0}}.v-modal{position:fixed;left:0;top:0;width:100%;height:100%;opacity:.5;background:#000}.el-popup-parent--hidden{overflow:hidden}.el-message-box{display:inline-block;width:420px;padding-bottom:10px;vertical-align:middle;background-color:#fff;border-radius:4px;border:1px solid #ebeef5;font-size:18px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);text-align:left;overflow:hidden;-webkit-backface-visibility:hidden;backface-visibility:hidden}.el-message-box__wrapper{position:fixed;top:0;bottom:0;left:0;right:0;text-align:center}.el-message-box__wrapper:after{content:"";display:inline-block;height:100%;width:0;vertical-align:middle}.el-message-box__header{position:relative;padding:15px 15px 10px}.el-message-box__title{padding-left:0;margin-bottom:0;font-size:18px;line-height:1;color:#303133}.el-message-box__headerbtn{position:absolute;top:15px;right:15px;padding:0;border:none;outline:0;background:0 0;font-size:16px;cursor:pointer}.el-form-item.is-error .el-input__inner,.el-form-item.is-error .el-input__inner:focus,.el-form-item.is-error .el-textarea__inner,.el-form-item.is-error .el-textarea__inner:focus,.el-message-box__input input.invalid,.el-message-box__input input.invalid:focus{border-color:#f56c6c}.el-message-box__headerbtn .el-message-box__close{color:#909399}.el-message-box__headerbtn:focus .el-message-box__close,.el-message-box__headerbtn:hover .el-message-box__close{color:#409eff}.el-message-box__content{padding:10px 15px;color:#606266;font-size:14px}.el-message-box__container{position:relative}.el-message-box__input{padding-top:15px}.el-message-box__status{position:absolute;top:50%;transform:translateY(-50%);font-size:24px!important}.el-message-box__status:before{padding-left:1px}.el-message-box__status+.el-message-box__message{padding-left:36px;padding-right:12px}.el-message-box__status.el-icon-success{color:#67c23a}.el-message-box__status.el-icon-info{color:#909399}.el-message-box__status.el-icon-warning{color:#e6a23c}.el-message-box__status.el-icon-error{color:#f56c6c}.el-message-box__message{margin:0}.el-message-box__message p{margin:0;line-height:24px}.el-message-box__errormsg{color:#f56c6c;font-size:12px;min-height:18px;margin-top:2px}.el-message-box__btns{padding:5px 15px 0;text-align:right}.el-message-box__btns button:nth-child(2){margin-left:10px}.el-message-box__btns-reverse{flex-direction:row-reverse}.el-message-box--center{padding-bottom:30px}.el-message-box--center .el-message-box__header{padding-top:30px}.el-message-box--center .el-message-box__title{position:relative;display:flex;align-items:center;justify-content:center}.el-message-box--center .el-message-box__status{position:relative;top:auto;padding-right:5px;text-align:center;transform:translateY(-1px)}.el-message-box--center .el-message-box__message{margin-left:0}.el-message-box--center .el-message-box__btns,.el-message-box--center .el-message-box__content{text-align:center}.el-message-box--center .el-message-box__content{padding-left:27px;padding-right:27px}.msgbox-fade-enter-active{-webkit-animation:msgbox-fade-in .3s;animation:msgbox-fade-in .3s}.msgbox-fade-leave-active{-webkit-animation:msgbox-fade-out .3s;animation:msgbox-fade-out .3s}@-webkit-keyframes msgbox-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@keyframes msgbox-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@-webkit-keyframes msgbox-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}@keyframes msgbox-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}.el-breadcrumb{font-size:14px;line-height:1}.el-breadcrumb:after,.el-breadcrumb:before{display:table;content:""}.el-breadcrumb:after{clear:both}.el-breadcrumb__separator{margin:0 9px;font-weight:700;color:#c0c4cc}.el-breadcrumb__separator[class*=icon]{margin:0 6px;font-weight:400}.el-breadcrumb__item{float:left}.el-breadcrumb__inner{color:#606266}.el-breadcrumb__inner.is-link,.el-breadcrumb__inner a{font-weight:700;text-decoration:none;transition:color .2s cubic-bezier(.645,.045,.355,1);color:#303133}.el-breadcrumb__inner.is-link:hover,.el-breadcrumb__inner a:hover{color:#409eff;cursor:pointer}.el-breadcrumb__item:last-child .el-breadcrumb__inner,.el-breadcrumb__item:last-child .el-breadcrumb__inner:hover,.el-breadcrumb__item:last-child .el-breadcrumb__inner a,.el-breadcrumb__item:last-child .el-breadcrumb__inner a:hover{font-weight:400;color:#606266;cursor:text}.el-breadcrumb__item:last-child .el-breadcrumb__separator{display:none}.el-form--label-left .el-form-item__label{text-align:left}.el-form--label-top .el-form-item__label{float:none;display:inline-block;text-align:left;padding:0 0 10px}.el-form--inline .el-form-item{display:inline-block;margin-right:10px;vertical-align:top}.el-form--inline .el-form-item__label{float:none;display:inline-block}.el-form--inline .el-form-item__content{display:inline-block;vertical-align:top}.el-form--inline.el-form--label-top .el-form-item__content{display:block}.el-form-item{margin-bottom:22px}.el-form-item:after,.el-form-item:before{display:table;content:""}.el-form-item:after{clear:both}.el-form-item .el-form-item{margin-bottom:0}.el-form-item--mini.el-form-item,.el-form-item--small.el-form-item{margin-bottom:18px}.el-form-item .el-input__validateIcon{display:none}.el-form-item--medium .el-form-item__content,.el-form-item--medium .el-form-item__label{line-height:36px}.el-form-item--small .el-form-item__content,.el-form-item--small .el-form-item__label{line-height:32px}.el-form-item--small .el-form-item__error{padding-top:2px}.el-form-item--mini .el-form-item__content,.el-form-item--mini .el-form-item__label{line-height:28px}.el-form-item--mini .el-form-item__error{padding-top:1px}.el-form-item__label-wrap{float:left}.el-form-item__label-wrap .el-form-item__label{display:inline-block;float:none}.el-form-item__label{text-align:right;vertical-align:middle;float:left;font-size:14px;color:#606266;line-height:40px;padding:0 12px 0 0;box-sizing:border-box}.el-form-item__content{line-height:40px;position:relative;font-size:14px}.el-form-item__content:after,.el-form-item__content:before{display:table;content:""}.el-form-item__content:after{clear:both}.el-form-item__content .el-input-group{vertical-align:top}.el-form-item__error{color:#f56c6c;font-size:12px;line-height:1;padding-top:4px;position:absolute;top:100%;left:0}.el-form-item__error--inline{position:relative;top:auto;left:auto;display:inline-block;margin-left:10px}.el-form-item.is-required:not(.is-no-asterisk) .el-form-item__label-wrap>.el-form-item__label:before,.el-form-item.is-required:not(.is-no-asterisk)>.el-form-item__label:before{content:"*";color:#f56c6c;margin-right:4px}.el-form-item.is-error .el-input-group__append .el-input__inner,.el-form-item.is-error .el-input-group__prepend .el-input__inner{border-color:transparent}.el-form-item.is-error .el-input__validateIcon{color:#f56c6c}.el-form-item--feedback .el-input__validateIcon{display:inline-block}.el-tabs__header{padding:0;position:relative;margin:0 0 15px}.el-tabs__active-bar{position:absolute;bottom:0;left:0;height:2px;background-color:#409eff;z-index:1;transition:transform .3s cubic-bezier(.645,.045,.355,1);list-style:none}.el-tabs__new-tab{float:right;border:1px solid #d3dce6;height:18px;width:18px;line-height:18px;margin:12px 0 9px 10px;border-radius:3px;text-align:center;font-size:12px;color:#d3dce6;cursor:pointer;transition:all .15s}.el-collapse-item__arrow,.el-tabs__nav{-webkit-transition:-webkit-transform .3s}.el-tabs__new-tab .el-icon-plus{transform:scale(.8)}.el-tabs__new-tab:hover{color:#409eff}.el-tabs__nav-wrap{overflow:hidden;margin-bottom:-1px;position:relative}.el-tabs__nav-wrap:after{content:"";position:absolute;left:0;bottom:0;width:100%;height:2px;background-color:#e4e7ed;z-index:1}.el-tabs--border-card>.el-tabs__header .el-tabs__nav-wrap:after,.el-tabs--card>.el-tabs__header .el-tabs__nav-wrap:after{content:none}.el-tabs__nav-wrap.is-scrollable{padding:0 20px;box-sizing:border-box}.el-tabs__nav-scroll{overflow:hidden}.el-tabs__nav-next,.el-tabs__nav-prev{position:absolute;cursor:pointer;line-height:44px;font-size:12px;color:#909399}.el-tabs__nav-next{right:0}.el-tabs__nav-prev{left:0}.el-tabs__nav{white-space:nowrap;position:relative;transition:transform .3s;float:left;z-index:2}.el-tabs__nav.is-stretch{min-width:100%;display:flex}.el-tabs__nav.is-stretch>*{flex:1;text-align:center}.el-tabs__item{padding:0 20px;height:40px;box-sizing:border-box;line-height:40px;display:inline-block;list-style:none;font-size:14px;font-weight:500;color:#303133;position:relative}.el-tabs__item:focus,.el-tabs__item:focus:active{outline:0}.el-tabs__item:focus.is-active.is-focus:not(:active){box-shadow:inset 0 0 2px 2px #409eff;border-radius:3px}.el-tabs__item .el-icon-close{border-radius:50%;text-align:center;transition:all .3s cubic-bezier(.645,.045,.355,1);margin-left:5px}.el-tabs__item .el-icon-close:before{transform:scale(.9);display:inline-block}.el-tabs__item .el-icon-close:hover{background-color:#c0c4cc;color:#fff}.el-tabs__item.is-active{color:#409eff}.el-tabs__item:hover{color:#409eff;cursor:pointer}.el-tabs__item.is-disabled{color:#c0c4cc;cursor:default}.el-tabs__content{overflow:hidden;position:relative}.el-tabs--card>.el-tabs__header{border-bottom:1px solid #e4e7ed}.el-tabs--card>.el-tabs__header .el-tabs__nav{border:1px solid #e4e7ed;border-bottom:none;border-radius:4px 4px 0 0;box-sizing:border-box}.el-tabs--card>.el-tabs__header .el-tabs__active-bar{display:none}.el-tabs--card>.el-tabs__header .el-tabs__item .el-icon-close{position:relative;font-size:12px;width:0;height:14px;vertical-align:middle;line-height:15px;overflow:hidden;top:-1px;right:-2px;transform-origin:100% 50%}.el-tabs--card>.el-tabs__header .el-tabs__item.is-active.is-closable .el-icon-close,.el-tabs--card>.el-tabs__header .el-tabs__item.is-closable:hover .el-icon-close{width:14px}.el-tabs--card>.el-tabs__header .el-tabs__item{border-bottom:1px solid transparent;border-left:1px solid #e4e7ed;transition:color .3s cubic-bezier(.645,.045,.355,1),padding .3s cubic-bezier(.645,.045,.355,1)}.el-tabs--card>.el-tabs__header .el-tabs__item:first-child{border-left:none}.el-tabs--card>.el-tabs__header .el-tabs__item.is-closable:hover{padding-left:13px;padding-right:13px}.el-tabs--card>.el-tabs__header .el-tabs__item.is-active{border-bottom-color:#fff}.el-tabs--card>.el-tabs__header .el-tabs__item.is-active.is-closable{padding-left:20px;padding-right:20px}.el-tabs--border-card{background:#fff;border:1px solid #dcdfe6;box-shadow:0 2px 4px 0 rgba(0,0,0,.12),0 0 6px 0 rgba(0,0,0,.04)}.el-tabs--border-card>.el-tabs__content{padding:15px}.el-tabs--border-card>.el-tabs__header{background-color:#f5f7fa;border-bottom:1px solid #e4e7ed;margin:0}.el-tabs--border-card>.el-tabs__header .el-tabs__item{transition:all .3s cubic-bezier(.645,.045,.355,1);border:1px solid transparent;margin-top:-1px;color:#909399}.el-tabs--border-card>.el-tabs__header .el-tabs__item+.el-tabs__item,.el-tabs--border-card>.el-tabs__header .el-tabs__item:first-child{margin-left:-1px}.el-tabs--border-card>.el-tabs__header .el-tabs__item.is-active{color:#409eff;background-color:#fff;border-right-color:#dcdfe6;border-left-color:#dcdfe6}.el-tabs--border-card>.el-tabs__header .el-tabs__item:not(.is-disabled):hover{color:#409eff}.el-tabs--border-card>.el-tabs__header .el-tabs__item.is-disabled{color:#c0c4cc}.el-tabs--border-card>.el-tabs__header .is-scrollable .el-tabs__item:first-child{margin-left:0}.el-tabs--bottom .el-tabs__item.is-bottom:nth-child(2),.el-tabs--bottom .el-tabs__item.is-top:nth-child(2),.el-tabs--top .el-tabs__item.is-bottom:nth-child(2),.el-tabs--top .el-tabs__item.is-top:nth-child(2){padding-left:0}.el-tabs--bottom .el-tabs__item.is-bottom:last-child,.el-tabs--bottom .el-tabs__item.is-top:last-child,.el-tabs--top .el-tabs__item.is-bottom:last-child,.el-tabs--top .el-tabs__item.is-top:last-child{padding-right:0}.el-tabs--bottom.el-tabs--border-card>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--bottom.el-tabs--card>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--bottom .el-tabs--left>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--bottom .el-tabs--right>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--top.el-tabs--border-card>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--top.el-tabs--card>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--top .el-tabs--left>.el-tabs__header .el-tabs__item:nth-child(2),.el-tabs--top .el-tabs--right>.el-tabs__header .el-tabs__item:nth-child(2){padding-left:20px}.el-tabs--bottom.el-tabs--border-card>.el-tabs__header .el-tabs__item:last-child,.el-tabs--bottom.el-tabs--card>.el-tabs__header .el-tabs__item:last-child,.el-tabs--bottom .el-tabs--left>.el-tabs__header .el-tabs__item:last-child,.el-tabs--bottom .el-tabs--right>.el-tabs__header .el-tabs__item:last-child,.el-tabs--top.el-tabs--border-card>.el-tabs__header .el-tabs__item:last-child,.el-tabs--top.el-tabs--card>.el-tabs__header .el-tabs__item:last-child,.el-tabs--top .el-tabs--left>.el-tabs__header .el-tabs__item:last-child,.el-tabs--top .el-tabs--right>.el-tabs__header .el-tabs__item:last-child{padding-right:20px}.el-tabs--bottom .el-tabs__header.is-bottom{margin-bottom:0;margin-top:10px}.el-tabs--bottom.el-tabs--border-card .el-tabs__header.is-bottom{border-bottom:0;border-top:1px solid #dcdfe6}.el-tabs--bottom.el-tabs--border-card .el-tabs__nav-wrap.is-bottom{margin-top:-1px;margin-bottom:0}.el-tabs--bottom.el-tabs--border-card .el-tabs__item.is-bottom:not(.is-active){border:1px solid transparent}.el-tabs--bottom.el-tabs--border-card .el-tabs__item.is-bottom{margin:0 -1px -1px}.el-tabs--left,.el-tabs--right{overflow:hidden}.el-tabs--left .el-tabs__header.is-left,.el-tabs--left .el-tabs__header.is-right,.el-tabs--left .el-tabs__nav-scroll,.el-tabs--left .el-tabs__nav-wrap.is-left,.el-tabs--left .el-tabs__nav-wrap.is-right,.el-tabs--right .el-tabs__header.is-left,.el-tabs--right .el-tabs__header.is-right,.el-tabs--right .el-tabs__nav-scroll,.el-tabs--right .el-tabs__nav-wrap.is-left,.el-tabs--right .el-tabs__nav-wrap.is-right{height:100%}.el-tabs--left .el-tabs__active-bar.is-left,.el-tabs--left .el-tabs__active-bar.is-right,.el-tabs--right .el-tabs__active-bar.is-left,.el-tabs--right .el-tabs__active-bar.is-right{top:0;bottom:auto;width:2px;height:auto}.el-tabs--left .el-tabs__nav-wrap.is-left,.el-tabs--left .el-tabs__nav-wrap.is-right,.el-tabs--right .el-tabs__nav-wrap.is-left,.el-tabs--right .el-tabs__nav-wrap.is-right{margin-bottom:0}.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-next,.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-next,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-next,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-next,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev{height:30px;line-height:30px;width:100%;text-align:center;cursor:pointer}.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-next i,.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev i,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-next i,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev i,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-next i,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev i,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-next i,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev i{transform:rotate(90deg)}.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-prev,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-prev{left:auto;top:0}.el-tabs--left .el-tabs__nav-wrap.is-left>.el-tabs__nav-next,.el-tabs--left .el-tabs__nav-wrap.is-right>.el-tabs__nav-next,.el-tabs--right .el-tabs__nav-wrap.is-left>.el-tabs__nav-next,.el-tabs--right .el-tabs__nav-wrap.is-right>.el-tabs__nav-next{right:auto;bottom:0}.el-tabs--left .el-tabs__active-bar.is-left,.el-tabs--left .el-tabs__nav-wrap.is-left:after{right:0;left:auto}.el-tabs--left .el-tabs__nav-wrap.is-left.is-scrollable,.el-tabs--left .el-tabs__nav-wrap.is-right.is-scrollable,.el-tabs--right .el-tabs__nav-wrap.is-left.is-scrollable,.el-tabs--right .el-tabs__nav-wrap.is-right.is-scrollable{padding:30px 0}.el-tabs--left .el-tabs__nav-wrap.is-left:after,.el-tabs--left .el-tabs__nav-wrap.is-right:after,.el-tabs--right .el-tabs__nav-wrap.is-left:after,.el-tabs--right .el-tabs__nav-wrap.is-right:after{height:100%;width:2px;bottom:auto;top:0}.el-tabs--left .el-tabs__nav.is-left,.el-tabs--left .el-tabs__nav.is-right,.el-tabs--right .el-tabs__nav.is-left,.el-tabs--right .el-tabs__nav.is-right{float:none}.el-tabs--left .el-tabs__item.is-left,.el-tabs--left .el-tabs__item.is-right,.el-tabs--right .el-tabs__item.is-left,.el-tabs--right .el-tabs__item.is-right{display:block}.el-tabs--left.el-tabs--card .el-tabs__active-bar.is-left,.el-tabs--right.el-tabs--card .el-tabs__active-bar.is-right{display:none}.el-tabs--left .el-tabs__header.is-left{float:left;margin-bottom:0;margin-right:10px}.el-tabs--left .el-tabs__nav-wrap.is-left{margin-right:-1px}.el-tabs--left .el-tabs__item.is-left{text-align:right}.el-tabs--left.el-tabs--card .el-tabs__item.is-left{border-left:none;border-right:1px solid #e4e7ed;border-bottom:none;border-top:1px solid #e4e7ed;text-align:left}.el-tabs--left.el-tabs--card .el-tabs__item.is-left:first-child{border-right:1px solid #e4e7ed;border-top:none}.el-tabs--left.el-tabs--card .el-tabs__item.is-left.is-active{border:1px solid #e4e7ed;border-right-color:#fff;border-left:none;border-bottom:none}.el-tabs--left.el-tabs--card .el-tabs__item.is-left.is-active:first-child{border-top:none}.el-tabs--left.el-tabs--card .el-tabs__item.is-left.is-active:last-child{border-bottom:none}.el-tabs--left.el-tabs--card .el-tabs__nav{border-radius:4px 0 0 4px;border-bottom:1px solid #e4e7ed;border-right:none}.el-tabs--left.el-tabs--card .el-tabs__new-tab{float:none}.el-tabs--left.el-tabs--border-card .el-tabs__header.is-left{border-right:1px solid #dfe4ed}.el-tabs--left.el-tabs--border-card .el-tabs__item.is-left{border:1px solid transparent;margin:-1px 0 -1px -1px}.el-tabs--left.el-tabs--border-card .el-tabs__item.is-left.is-active{border-color:#d1dbe5 transparent}.el-tabs--right .el-tabs__header.is-right{float:right;margin-bottom:0;margin-left:10px}.el-tabs--right .el-tabs__nav-wrap.is-right{margin-left:-1px}.el-tabs--right .el-tabs__nav-wrap.is-right:after{left:0;right:auto}.el-tabs--right .el-tabs__active-bar.is-right{left:0}.el-tabs--right.el-tabs--card .el-tabs__item.is-right{border-bottom:none;border-top:1px solid #e4e7ed}.el-tabs--right.el-tabs--card .el-tabs__item.is-right:first-child{border-left:1px solid #e4e7ed;border-top:none}.el-tabs--right.el-tabs--card .el-tabs__item.is-right.is-active{border:1px solid #e4e7ed;border-left-color:#fff;border-right:none;border-bottom:none}.el-tabs--right.el-tabs--card .el-tabs__item.is-right.is-active:first-child{border-top:none}.el-tabs--right.el-tabs--card .el-tabs__item.is-right.is-active:last-child{border-bottom:none}.el-tabs--right.el-tabs--card .el-tabs__nav{border-radius:0 4px 4px 0;border-bottom:1px solid #e4e7ed;border-left:none}.el-tabs--right.el-tabs--border-card .el-tabs__header.is-right{border-left:1px solid #dfe4ed}.el-tabs--right.el-tabs--border-card .el-tabs__item.is-right{border:1px solid transparent;margin:-1px -1px -1px 0}.el-tabs--right.el-tabs--border-card .el-tabs__item.is-right.is-active{border-color:#d1dbe5 transparent}.slideInLeft-transition,.slideInRight-transition{display:inline-block}.slideInRight-enter{-webkit-animation:slideInRight-enter .3s;animation:slideInRight-enter .3s}.slideInRight-leave{position:absolute;left:0;right:0;-webkit-animation:slideInRight-leave .3s;animation:slideInRight-leave .3s}.slideInLeft-enter{-webkit-animation:slideInLeft-enter .3s;animation:slideInLeft-enter .3s}.slideInLeft-leave{position:absolute;left:0;right:0;-webkit-animation:slideInLeft-leave .3s;animation:slideInLeft-leave .3s}@-webkit-keyframes slideInRight-enter{0%{opacity:0;transform-origin:0 0;transform:translateX(100%)}to{opacity:1;transform-origin:0 0;transform:translateX(0)}}@keyframes slideInRight-enter{0%{opacity:0;transform-origin:0 0;transform:translateX(100%)}to{opacity:1;transform-origin:0 0;transform:translateX(0)}}@-webkit-keyframes slideInRight-leave{0%{transform-origin:0 0;transform:translateX(0);opacity:1}to{transform-origin:0 0;transform:translateX(100%);opacity:0}}@keyframes slideInRight-leave{0%{transform-origin:0 0;transform:translateX(0);opacity:1}to{transform-origin:0 0;transform:translateX(100%);opacity:0}}@-webkit-keyframes slideInLeft-enter{0%{opacity:0;transform-origin:0 0;transform:translateX(-100%)}to{opacity:1;transform-origin:0 0;transform:translateX(0)}}@keyframes slideInLeft-enter{0%{opacity:0;transform-origin:0 0;transform:translateX(-100%)}to{opacity:1;transform-origin:0 0;transform:translateX(0)}}@-webkit-keyframes slideInLeft-leave{0%{transform-origin:0 0;transform:translateX(0);opacity:1}to{transform-origin:0 0;transform:translateX(-100%);opacity:0}}@keyframes slideInLeft-leave{0%{transform-origin:0 0;transform:translateX(0);opacity:1}to{transform-origin:0 0;transform:translateX(-100%);opacity:0}}.el-tree{position:relative;cursor:default;background:#fff;color:#606266}.el-tree__empty-block{position:relative;min-height:60px;text-align:center;width:100%;height:100%}.el-tree__empty-text{position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);color:#909399;font-size:14px}.el-tree__drop-indicator{position:absolute;left:0;right:0;height:1px;background-color:#409eff}.el-tree-node{white-space:nowrap;outline:0}.el-tree-node:focus>.el-tree-node__content{background-color:#f5f7fa}.el-tree-node.is-drop-inner>.el-tree-node__content .el-tree-node__label{background-color:#409eff;color:#fff}.el-tree-node__content{display:flex;align-items:center;height:26px;cursor:pointer}.el-tree-node__content>.el-tree-node__expand-icon{padding:6px}.el-tree-node__content>label.el-checkbox{margin-right:8px}.el-tree-node__content:hover{background-color:#f5f7fa}.el-tree.is-dragging .el-tree-node__content{cursor:move}.el-tree.is-dragging.is-drop-not-allow .el-tree-node__content{cursor:not-allowed}.el-tree-node__expand-icon{cursor:pointer;color:#c0c4cc;font-size:12px;transform:rotate(0);transition:transform .3s ease-in-out}.el-tree-node__expand-icon.expanded{transform:rotate(90deg)}.el-tree-node__expand-icon.is-leaf{color:transparent;cursor:default}.el-tree-node__label{font-size:14px}.el-tree-node__loading-icon{margin-right:8px;font-size:14px;color:#c0c4cc}.el-tree-node>.el-tree-node__children{overflow:hidden;background-color:transparent}.el-tree-node.is-expanded>.el-tree-node__children{display:block}.el-tree--highlight-current .el-tree-node.is-current>.el-tree-node__content{background-color:#f0f7ff}.el-alert{width:100%;padding:8px 16px;margin:0;box-sizing:border-box;border-radius:4px;position:relative;background-color:#fff;overflow:hidden;opacity:1;display:flex;align-items:center;transition:opacity .2s}.el-alert.is-light .el-alert__closebtn{color:#c0c4cc}.el-alert.is-dark .el-alert__closebtn,.el-alert.is-dark .el-alert__description{color:#fff}.el-alert.is-center{justify-content:center}.el-alert--success.is-light{background-color:#f0f9eb;color:#67c23a}.el-alert--success.is-light .el-alert__description{color:#67c23a}.el-alert--success.is-dark{background-color:#67c23a;color:#fff}.el-alert--info.is-light{background-color:#f4f4f5;color:#909399}.el-alert--info.is-dark{background-color:#909399;color:#fff}.el-alert--info .el-alert__description{color:#909399}.el-alert--warning.is-light{background-color:#fdf6ec;color:#e6a23c}.el-alert--warning.is-light .el-alert__description{color:#e6a23c}.el-alert--warning.is-dark{background-color:#e6a23c;color:#fff}.el-alert--error.is-light{background-color:#fef0f0;color:#f56c6c}.el-alert--error.is-light .el-alert__description{color:#f56c6c}.el-alert--error.is-dark{background-color:#f56c6c;color:#fff}.el-alert__content{display:table-cell;padding:0 8px}.el-alert__icon{font-size:16px;width:16px}.el-alert__icon.is-big{font-size:28px;width:28px}.el-alert__title{font-size:13px;line-height:18px}.el-alert__title.is-bold{font-weight:700}.el-alert .el-alert__description{font-size:12px;margin:5px 0 0}.el-alert__closebtn{font-size:12px;opacity:1;position:absolute;top:12px;right:15px;cursor:pointer}.el-alert-fade-enter,.el-alert-fade-leave-active,.el-loading-fade-enter,.el-loading-fade-leave-active,.el-notification-fade-leave-active{opacity:0}.el-alert__closebtn.is-customed{font-style:normal;font-size:13px;top:9px}.el-notification{display:flex;width:330px;padding:14px 26px 14px 13px;border-radius:8px;box-sizing:border-box;border:1px solid #ebeef5;position:fixed;background-color:#fff;box-shadow:0 2px 12px 0 rgba(0,0,0,.1);transition:opacity .3s,transform .3s,left .3s,right .3s,top .4s,bottom .3s;overflow:hidden}.el-notification.right{right:16px}.el-notification.left{left:16px}.el-notification__group{margin-left:13px;margin-right:8px}.el-notification__title{font-weight:700;font-size:16px;color:#303133;margin:0}.el-notification__content{font-size:14px;line-height:21px;margin:6px 0 0;color:#606266;text-align:justify}.el-notification__content p{margin:0}.el-notification__icon{height:24px;width:24px;font-size:24px}.el-notification__closeBtn{position:absolute;top:18px;right:15px;cursor:pointer;color:#909399;font-size:16px}.el-notification__closeBtn:hover{color:#606266}.el-notification .el-icon-success{color:#67c23a}.el-notification .el-icon-error{color:#f56c6c}.el-notification .el-icon-info{color:#909399}.el-notification .el-icon-warning{color:#e6a23c}.el-notification-fade-enter.right{right:0;transform:translateX(100%)}.el-notification-fade-enter.left{left:0;transform:translateX(-100%)}.el-input-number{position:relative;display:inline-block;width:180px;line-height:38px}.el-input-number .el-input{display:block}.el-input-number .el-input__inner{-webkit-appearance:none;padding-left:50px;padding-right:50px;text-align:center}.el-input-number__decrease,.el-input-number__increase{position:absolute;z-index:1;top:1px;width:40px;height:auto;text-align:center;background:#f5f7fa;color:#606266;cursor:pointer;font-size:13px}.el-input-number__decrease:hover,.el-input-number__increase:hover{color:#409eff}.el-input-number__decrease:hover:not(.is-disabled)~.el-input .el-input__inner:not(.is-disabled),.el-input-number__increase:hover:not(.is-disabled)~.el-input .el-input__inner:not(.is-disabled){border-color:#409eff}.el-input-number__decrease.is-disabled,.el-input-number__increase.is-disabled{color:#c0c4cc;cursor:not-allowed}.el-input-number__increase{right:1px;border-radius:0 4px 4px 0;border-left:1px solid #dcdfe6}.el-input-number__decrease{left:1px;border-radius:4px 0 0 4px;border-right:1px solid #dcdfe6}.el-input-number.is-disabled .el-input-number__decrease,.el-input-number.is-disabled .el-input-number__increase{border-color:#e4e7ed;color:#e4e7ed}.el-input-number.is-disabled .el-input-number__decrease:hover,.el-input-number.is-disabled .el-input-number__increase:hover{color:#e4e7ed;cursor:not-allowed}.el-input-number--medium{width:200px;line-height:34px}.el-input-number--medium .el-input-number__decrease,.el-input-number--medium .el-input-number__increase{width:36px;font-size:14px}.el-input-number--medium .el-input__inner{padding-left:43px;padding-right:43px}.el-input-number--small{width:130px;line-height:30px}.el-input-number--small .el-input-number__decrease,.el-input-number--small .el-input-number__increase{width:32px;font-size:13px}.el-input-number--small .el-input-number__decrease [class*=el-icon],.el-input-number--small .el-input-number__increase [class*=el-icon]{transform:scale(.9)}.el-input-number--small .el-input__inner{padding-left:39px;padding-right:39px}.el-input-number--mini{width:130px;line-height:26px}.el-input-number--mini .el-input-number__decrease,.el-input-number--mini .el-input-number__increase{width:28px;font-size:12px}.el-input-number--mini .el-input-number__decrease [class*=el-icon],.el-input-number--mini .el-input-number__increase [class*=el-icon]{transform:scale(.8)}.el-input-number--mini .el-input__inner{padding-left:35px;padding-right:35px}.el-input-number.is-without-controls .el-input__inner{padding-left:15px;padding-right:15px}.el-input-number.is-controls-right .el-input__inner{padding-left:15px;padding-right:50px}.el-input-number.is-controls-right .el-input-number__decrease,.el-input-number.is-controls-right .el-input-number__increase{height:auto;line-height:19px}.el-input-number.is-controls-right .el-input-number__decrease [class*=el-icon],.el-input-number.is-controls-right .el-input-number__increase [class*=el-icon]{transform:scale(.8)}.el-input-number.is-controls-right .el-input-number__increase{border-radius:0 4px 0 0;border-bottom:1px solid #dcdfe6}.el-input-number.is-controls-right .el-input-number__decrease{right:1px;bottom:1px;top:auto;left:auto;border-right:none;border-left:1px solid #dcdfe6;border-radius:0 0 4px}.el-input-number.is-controls-right[class*=medium] [class*=decrease],.el-input-number.is-controls-right[class*=medium] [class*=increase]{line-height:17px}.el-input-number.is-controls-right[class*=small] [class*=decrease],.el-input-number.is-controls-right[class*=small] [class*=increase]{line-height:15px}.el-input-number.is-controls-right[class*=mini] [class*=decrease],.el-input-number.is-controls-right[class*=mini] [class*=increase]{line-height:13px}.el-tooltip__popper{position:absolute;border-radius:4px;padding:10px;z-index:2000;font-size:12px;line-height:1.2;min-width:10px;word-wrap:break-word}.el-tooltip__popper .popper__arrow,.el-tooltip__popper .popper__arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.el-tooltip__popper .popper__arrow{border-width:6px}.el-tooltip__popper .popper__arrow:after{content:" ";border-width:5px}.el-progress-bar__inner:after,.el-row:after,.el-row:before,.el-slider:after,.el-slider:before,.el-slider__button-wrapper:after,.el-upload-cover:after{content:""}.el-tooltip__popper[x-placement^=top]{margin-bottom:12px}.el-tooltip__popper[x-placement^=top] .popper__arrow{bottom:-6px;border-top-color:#303133;border-bottom-width:0}.el-tooltip__popper[x-placement^=top] .popper__arrow:after{bottom:1px;margin-left:-5px;border-top-color:#303133;border-bottom-width:0}.el-tooltip__popper[x-placement^=bottom]{margin-top:12px}.el-tooltip__popper[x-placement^=bottom] .popper__arrow{top:-6px;border-top-width:0;border-bottom-color:#303133}.el-tooltip__popper[x-placement^=bottom] .popper__arrow:after{top:1px;margin-left:-5px;border-top-width:0;border-bottom-color:#303133}.el-tooltip__popper[x-placement^=right]{margin-left:12px}.el-tooltip__popper[x-placement^=right] .popper__arrow{left:-6px;border-right-color:#303133;border-left-width:0}.el-tooltip__popper[x-placement^=right] .popper__arrow:after{bottom:-5px;left:1px;border-right-color:#303133;border-left-width:0}.el-tooltip__popper[x-placement^=left]{margin-right:12px}.el-tooltip__popper[x-placement^=left] .popper__arrow{right:-6px;border-right-width:0;border-left-color:#303133}.el-tooltip__popper[x-placement^=left] .popper__arrow:after{right:1px;bottom:-5px;margin-left:-5px;border-right-width:0;border-left-color:#303133}.el-tooltip__popper.is-dark{background:#303133;color:#fff}.el-tooltip__popper.is-light{background:#fff;border:1px solid #303133}.el-tooltip__popper.is-light[x-placement^=top] .popper__arrow{border-top-color:#303133}.el-tooltip__popper.is-light[x-placement^=top] .popper__arrow:after{border-top-color:#fff}.el-tooltip__popper.is-light[x-placement^=bottom] .popper__arrow{border-bottom-color:#303133}.el-tooltip__popper.is-light[x-placement^=bottom] .popper__arrow:after{border-bottom-color:#fff}.el-tooltip__popper.is-light[x-placement^=left] .popper__arrow{border-left-color:#303133}.el-tooltip__popper.is-light[x-placement^=left] .popper__arrow:after{border-left-color:#fff}.el-tooltip__popper.is-light[x-placement^=right] .popper__arrow{border-right-color:#303133}.el-tooltip__popper.is-light[x-placement^=right] .popper__arrow:after{border-right-color:#fff}.el-slider:after,.el-slider:before{display:table}.el-slider__button-wrapper .el-tooltip,.el-slider__button-wrapper:after{vertical-align:middle;display:inline-block}.el-slider:after{clear:both}.el-slider__runway{width:100%;height:6px;margin:16px 0;background-color:#e4e7ed;border-radius:3px;position:relative;cursor:pointer;vertical-align:middle}.el-slider__runway.show-input{margin-right:160px;width:auto}.el-slider__runway.disabled{cursor:default}.el-slider__runway.disabled .el-slider__bar{background-color:#c0c4cc}.el-slider__runway.disabled .el-slider__button{border-color:#c0c4cc}.el-slider__runway.disabled .el-slider__button-wrapper.dragging,.el-slider__runway.disabled .el-slider__button-wrapper.hover,.el-slider__runway.disabled .el-slider__button-wrapper:hover{cursor:not-allowed}.el-slider__runway.disabled .el-slider__button.dragging,.el-slider__runway.disabled .el-slider__button.hover,.el-slider__runway.disabled .el-slider__button:hover{transform:scale(1);cursor:not-allowed}.el-slider__button-wrapper,.el-slider__stop{-webkit-transform:translateX(-50%);position:absolute}.el-slider__input{float:right;margin-top:3px;width:130px}.el-slider__input.el-input-number--mini{margin-top:5px}.el-slider__input.el-input-number--medium{margin-top:0}.el-slider__input.el-input-number--large{margin-top:-2px}.el-slider__bar{height:6px;background-color:#409eff;border-top-left-radius:3px;border-bottom-left-radius:3px;position:absolute}.el-slider__button-wrapper{height:36px;width:36px;z-index:1001;top:-15px;transform:translateX(-50%);background-color:transparent;text-align:center;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;line-height:normal}.el-slider__button-wrapper:after{height:100%}.el-slider__button-wrapper.hover,.el-slider__button-wrapper:hover{cursor:-webkit-grab;cursor:grab}.el-slider__button-wrapper.dragging{cursor:-webkit-grabbing;cursor:grabbing}.el-slider__button{width:16px;height:16px;border:2px solid #409eff;background-color:#fff;border-radius:50%;transition:.2s;user-select:none}.el-image-viewer__btn,.el-slider__button,.el-step__icon-inner{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none}.el-slider__button.dragging,.el-slider__button.hover,.el-slider__button:hover{transform:scale(1.2)}.el-slider__button.hover,.el-slider__button:hover{cursor:-webkit-grab;cursor:grab}.el-slider__button.dragging{cursor:-webkit-grabbing;cursor:grabbing}.el-slider__stop{height:6px;width:6px;border-radius:100%;background-color:#fff;transform:translateX(-50%)}.el-slider__marks{top:0;left:12px;width:18px;height:100%}.el-slider__marks-text{position:absolute;transform:translateX(-50%);font-size:14px;color:#909399;margin-top:15px}.el-slider.is-vertical{position:relative}.el-slider.is-vertical .el-slider__runway{width:6px;height:100%;margin:0 16px}.el-slider.is-vertical .el-slider__bar{width:6px;height:auto;border-radius:0 0 3px 3px}.el-slider.is-vertical .el-slider__button-wrapper{top:auto;left:-15px;transform:translateY(50%)}.el-slider.is-vertical .el-slider__stop{transform:translateY(50%)}.el-slider.is-vertical.el-slider--with-input{padding-bottom:58px}.el-slider.is-vertical.el-slider--with-input .el-slider__input{overflow:visible;float:none;position:absolute;bottom:22px;width:36px;margin-top:15px}.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input__inner{text-align:center;padding-left:5px;padding-right:5px}.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input-number__decrease,.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input-number__increase{top:32px;margin-top:-1px;border:1px solid #dcdfe6;line-height:20px;box-sizing:border-box;transition:border-color .2s cubic-bezier(.645,.045,.355,1)}.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input-number__decrease{width:18px;right:18px;border-bottom-left-radius:4px}.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input-number__increase{width:19px;border-bottom-right-radius:4px}.el-slider.is-vertical.el-slider--with-input .el-slider__input .el-input-number__increase~.el-input .el-input__inner{border-bottom-left-radius:0;border-bottom-right-radius:0}.el-slider.is-vertical.el-slider--with-input .el-slider__input:hover .el-input-number__decrease,.el-slider.is-vertical.el-slider--with-input .el-slider__input:hover .el-input-number__increase{border-color:#c0c4cc}.el-slider.is-vertical.el-slider--with-input .el-slider__input:active .el-input-number__decrease,.el-slider.is-vertical.el-slider--with-input .el-slider__input:active .el-input-number__increase{border-color:#409eff}.el-slider.is-vertical .el-slider__marks-text{margin-top:0;left:15px;transform:translateY(50%)}.el-loading-parent--relative{position:relative!important}.el-loading-parent--hidden{overflow:hidden!important}.el-loading-mask{position:absolute;z-index:2000;background-color:hsla(0,0%,100%,.9);margin:0;top:0;right:0;bottom:0;left:0;transition:opacity .3s}.el-loading-mask.is-fullscreen{position:fixed}.el-loading-mask.is-fullscreen .el-loading-spinner{margin-top:-25px}.el-loading-mask.is-fullscreen .el-loading-spinner .circular{height:50px;width:50px}.el-loading-spinner{top:50%;margin-top:-21px;width:100%;text-align:center;position:absolute}.el-col-pull-0,.el-col-pull-1,.el-col-pull-2,.el-col-pull-3,.el-col-pull-4,.el-col-pull-5,.el-col-pull-6,.el-col-pull-7,.el-col-pull-8,.el-col-pull-9,.el-col-pull-10,.el-col-pull-11,.el-col-pull-13,.el-col-pull-14,.el-col-pull-15,.el-col-pull-16,.el-col-pull-17,.el-col-pull-18,.el-col-pull-19,.el-col-pull-20,.el-col-pull-21,.el-col-pull-22,.el-col-pull-23,.el-col-pull-24,.el-col-push-0,.el-col-push-1,.el-col-push-2,.el-col-push-3,.el-col-push-4,.el-col-push-5,.el-col-push-6,.el-col-push-7,.el-col-push-8,.el-col-push-9,.el-col-push-10,.el-col-push-11,.el-col-push-12,.el-col-push-13,.el-col-push-14,.el-col-push-15,.el-col-push-16,.el-col-push-17,.el-col-push-18,.el-col-push-19,.el-col-push-20,.el-col-push-21,.el-col-push-22,.el-col-push-23,.el-col-push-24,.el-row{position:relative}.el-loading-spinner .el-loading-text{color:#409eff;margin:3px 0;font-size:14px}.el-loading-spinner .circular{height:42px;width:42px;-webkit-animation:loading-rotate 2s linear infinite;animation:loading-rotate 2s linear infinite}.el-loading-spinner .path{-webkit-animation:loading-dash 1.5s ease-in-out infinite;animation:loading-dash 1.5s ease-in-out infinite;stroke-dasharray:90,150;stroke-dashoffset:0;stroke-width:2;stroke:#409eff;stroke-linecap:round}.el-loading-spinner i{color:#409eff}@-webkit-keyframes loading-rotate{to{transform:rotate(1turn)}}@keyframes loading-rotate{to{transform:rotate(1turn)}}@-webkit-keyframes loading-dash{0%{stroke-dasharray:1,200;stroke-dashoffset:0}50%{stroke-dasharray:90,150;stroke-dashoffset:-40px}to{stroke-dasharray:90,150;stroke-dashoffset:-120px}}@keyframes loading-dash{0%{stroke-dasharray:1,200;stroke-dashoffset:0}50%{stroke-dasharray:90,150;stroke-dashoffset:-40px}to{stroke-dasharray:90,150;stroke-dashoffset:-120px}}.el-row{box-sizing:border-box}.el-row:after,.el-row:before{display:table}.el-row:after{clear:both}.el-row--flex{display:flex}.el-col-0,.el-row--flex:after,.el-row--flex:before{display:none}.el-row--flex.is-justify-center{justify-content:center}.el-row--flex.is-justify-end{justify-content:flex-end}.el-row--flex.is-justify-space-between{justify-content:space-between}.el-row--flex.is-justify-space-around{justify-content:space-around}.el-row--flex.is-align-top{align-items:flex-start}.el-row--flex.is-align-middle{align-items:center}.el-row--flex.is-align-bottom{align-items:flex-end}[class*=el-col-]{float:left;box-sizing:border-box}.el-upload--picture-card,.el-upload-dragger{-webkit-box-sizing:border-box;cursor:pointer}.el-col-0{width:0}.el-col-offset-0{margin-left:0}.el-col-pull-0{right:0}.el-col-push-0{left:0}.el-col-1{width:4.16667%}.el-col-offset-1{margin-left:4.16667%}.el-col-pull-1{right:4.16667%}.el-col-push-1{left:4.16667%}.el-col-2{width:8.33333%}.el-col-offset-2{margin-left:8.33333%}.el-col-pull-2{right:8.33333%}.el-col-push-2{left:8.33333%}.el-col-3{width:12.5%}.el-col-offset-3{margin-left:12.5%}.el-col-pull-3{right:12.5%}.el-col-push-3{left:12.5%}.el-col-4{width:16.66667%}.el-col-offset-4{margin-left:16.66667%}.el-col-pull-4{right:16.66667%}.el-col-push-4{left:16.66667%}.el-col-5{width:20.83333%}.el-col-offset-5{margin-left:20.83333%}.el-col-pull-5{right:20.83333%}.el-col-push-5{left:20.83333%}.el-col-6{width:25%}.el-col-offset-6{margin-left:25%}.el-col-pull-6{right:25%}.el-col-push-6{left:25%}.el-col-7{width:29.16667%}.el-col-offset-7{margin-left:29.16667%}.el-col-pull-7{right:29.16667%}.el-col-push-7{left:29.16667%}.el-col-8{width:33.33333%}.el-col-offset-8{margin-left:33.33333%}.el-col-pull-8{right:33.33333%}.el-col-push-8{left:33.33333%}.el-col-9{width:37.5%}.el-col-offset-9{margin-left:37.5%}.el-col-pull-9{right:37.5%}.el-col-push-9{left:37.5%}.el-col-10{width:41.66667%}.el-col-offset-10{margin-left:41.66667%}.el-col-pull-10{right:41.66667%}.el-col-push-10{left:41.66667%}.el-col-11{width:45.83333%}.el-col-offset-11{margin-left:45.83333%}.el-col-pull-11{right:45.83333%}.el-col-push-11{left:45.83333%}.el-col-12{width:50%}.el-col-offset-12{margin-left:50%}.el-col-pull-12{position:relative;right:50%}.el-col-push-12{left:50%}.el-col-13{width:54.16667%}.el-col-offset-13{margin-left:54.16667%}.el-col-pull-13{right:54.16667%}.el-col-push-13{left:54.16667%}.el-col-14{width:58.33333%}.el-col-offset-14{margin-left:58.33333%}.el-col-pull-14{right:58.33333%}.el-col-push-14{left:58.33333%}.el-col-15{width:62.5%}.el-col-offset-15{margin-left:62.5%}.el-col-pull-15{right:62.5%}.el-col-push-15{left:62.5%}.el-col-16{width:66.66667%}.el-col-offset-16{margin-left:66.66667%}.el-col-pull-16{right:66.66667%}.el-col-push-16{left:66.66667%}.el-col-17{width:70.83333%}.el-col-offset-17{margin-left:70.83333%}.el-col-pull-17{right:70.83333%}.el-col-push-17{left:70.83333%}.el-col-18{width:75%}.el-col-offset-18{margin-left:75%}.el-col-pull-18{right:75%}.el-col-push-18{left:75%}.el-col-19{width:79.16667%}.el-col-offset-19{margin-left:79.16667%}.el-col-pull-19{right:79.16667%}.el-col-push-19{left:79.16667%}.el-col-20{width:83.33333%}.el-col-offset-20{margin-left:83.33333%}.el-col-pull-20{right:83.33333%}.el-col-push-20{left:83.33333%}.el-col-21{width:87.5%}.el-col-offset-21{margin-left:87.5%}.el-col-pull-21{right:87.5%}.el-col-push-21{left:87.5%}.el-col-22{width:91.66667%}.el-col-offset-22{margin-left:91.66667%}.el-col-pull-22{right:91.66667%}.el-col-push-22{left:91.66667%}.el-col-23{width:95.83333%}.el-col-offset-23{margin-left:95.83333%}.el-col-pull-23{right:95.83333%}.el-col-push-23{left:95.83333%}.el-col-24{width:100%}.el-col-offset-24{margin-left:100%}.el-col-pull-24{right:100%}.el-col-push-24{left:100%}@media only screen and (max-width:767px){.el-col-xs-0{display:none;width:0}.el-col-xs-offset-0{margin-left:0}.el-col-xs-pull-0{position:relative;right:0}.el-col-xs-push-0{position:relative;left:0}.el-col-xs-1{width:4.16667%}.el-col-xs-offset-1{margin-left:4.16667%}.el-col-xs-pull-1{position:relative;right:4.16667%}.el-col-xs-push-1{position:relative;left:4.16667%}.el-col-xs-2{width:8.33333%}.el-col-xs-offset-2{margin-left:8.33333%}.el-col-xs-pull-2{position:relative;right:8.33333%}.el-col-xs-push-2{position:relative;left:8.33333%}.el-col-xs-3{width:12.5%}.el-col-xs-offset-3{margin-left:12.5%}.el-col-xs-pull-3{position:relative;right:12.5%}.el-col-xs-push-3{position:relative;left:12.5%}.el-col-xs-4{width:16.66667%}.el-col-xs-offset-4{margin-left:16.66667%}.el-col-xs-pull-4{position:relative;right:16.66667%}.el-col-xs-push-4{position:relative;left:16.66667%}.el-col-xs-5{width:20.83333%}.el-col-xs-offset-5{margin-left:20.83333%}.el-col-xs-pull-5{position:relative;right:20.83333%}.el-col-xs-push-5{position:relative;left:20.83333%}.el-col-xs-6{width:25%}.el-col-xs-offset-6{margin-left:25%}.el-col-xs-pull-6{position:relative;right:25%}.el-col-xs-push-6{position:relative;left:25%}.el-col-xs-7{width:29.16667%}.el-col-xs-offset-7{margin-left:29.16667%}.el-col-xs-pull-7{position:relative;right:29.16667%}.el-col-xs-push-7{position:relative;left:29.16667%}.el-col-xs-8{width:33.33333%}.el-col-xs-offset-8{margin-left:33.33333%}.el-col-xs-pull-8{position:relative;right:33.33333%}.el-col-xs-push-8{position:relative;left:33.33333%}.el-col-xs-9{width:37.5%}.el-col-xs-offset-9{margin-left:37.5%}.el-col-xs-pull-9{position:relative;right:37.5%}.el-col-xs-push-9{position:relative;left:37.5%}.el-col-xs-10{width:41.66667%}.el-col-xs-offset-10{margin-left:41.66667%}.el-col-xs-pull-10{position:relative;right:41.66667%}.el-col-xs-push-10{position:relative;left:41.66667%}.el-col-xs-11{width:45.83333%}.el-col-xs-offset-11{margin-left:45.83333%}.el-col-xs-pull-11{position:relative;right:45.83333%}.el-col-xs-push-11{position:relative;left:45.83333%}.el-col-xs-12{width:50%}.el-col-xs-offset-12{margin-left:50%}.el-col-xs-pull-12{position:relative;right:50%}.el-col-xs-push-12{position:relative;left:50%}.el-col-xs-13{width:54.16667%}.el-col-xs-offset-13{margin-left:54.16667%}.el-col-xs-pull-13{position:relative;right:54.16667%}.el-col-xs-push-13{position:relative;left:54.16667%}.el-col-xs-14{width:58.33333%}.el-col-xs-offset-14{margin-left:58.33333%}.el-col-xs-pull-14{position:relative;right:58.33333%}.el-col-xs-push-14{position:relative;left:58.33333%}.el-col-xs-15{width:62.5%}.el-col-xs-offset-15{margin-left:62.5%}.el-col-xs-pull-15{position:relative;right:62.5%}.el-col-xs-push-15{position:relative;left:62.5%}.el-col-xs-16{width:66.66667%}.el-col-xs-offset-16{margin-left:66.66667%}.el-col-xs-pull-16{position:relative;right:66.66667%}.el-col-xs-push-16{position:relative;left:66.66667%}.el-col-xs-17{width:70.83333%}.el-col-xs-offset-17{margin-left:70.83333%}.el-col-xs-pull-17{position:relative;right:70.83333%}.el-col-xs-push-17{position:relative;left:70.83333%}.el-col-xs-18{width:75%}.el-col-xs-offset-18{margin-left:75%}.el-col-xs-pull-18{position:relative;right:75%}.el-col-xs-push-18{position:relative;left:75%}.el-col-xs-19{width:79.16667%}.el-col-xs-offset-19{margin-left:79.16667%}.el-col-xs-pull-19{position:relative;right:79.16667%}.el-col-xs-push-19{position:relative;left:79.16667%}.el-col-xs-20{width:83.33333%}.el-col-xs-offset-20{margin-left:83.33333%}.el-col-xs-pull-20{position:relative;right:83.33333%}.el-col-xs-push-20{position:relative;left:83.33333%}.el-col-xs-21{width:87.5%}.el-col-xs-offset-21{margin-left:87.5%}.el-col-xs-pull-21{position:relative;right:87.5%}.el-col-xs-push-21{position:relative;left:87.5%}.el-col-xs-22{width:91.66667%}.el-col-xs-offset-22{margin-left:91.66667%}.el-col-xs-pull-22{position:relative;right:91.66667%}.el-col-xs-push-22{position:relative;left:91.66667%}.el-col-xs-23{width:95.83333%}.el-col-xs-offset-23{margin-left:95.83333%}.el-col-xs-pull-23{position:relative;right:95.83333%}.el-col-xs-push-23{position:relative;left:95.83333%}.el-col-xs-24{width:100%}.el-col-xs-offset-24{margin-left:100%}.el-col-xs-pull-24{position:relative;right:100%}.el-col-xs-push-24{position:relative;left:100%}}@media only screen and (min-width:768px){.el-col-sm-0{display:none;width:0}.el-col-sm-offset-0{margin-left:0}.el-col-sm-pull-0{position:relative;right:0}.el-col-sm-push-0{position:relative;left:0}.el-col-sm-1{width:4.16667%}.el-col-sm-offset-1{margin-left:4.16667%}.el-col-sm-pull-1{position:relative;right:4.16667%}.el-col-sm-push-1{position:relative;left:4.16667%}.el-col-sm-2{width:8.33333%}.el-col-sm-offset-2{margin-left:8.33333%}.el-col-sm-pull-2{position:relative;right:8.33333%}.el-col-sm-push-2{position:relative;left:8.33333%}.el-col-sm-3{width:12.5%}.el-col-sm-offset-3{margin-left:12.5%}.el-col-sm-pull-3{position:relative;right:12.5%}.el-col-sm-push-3{position:relative;left:12.5%}.el-col-sm-4{width:16.66667%}.el-col-sm-offset-4{margin-left:16.66667%}.el-col-sm-pull-4{position:relative;right:16.66667%}.el-col-sm-push-4{position:relative;left:16.66667%}.el-col-sm-5{width:20.83333%}.el-col-sm-offset-5{margin-left:20.83333%}.el-col-sm-pull-5{position:relative;right:20.83333%}.el-col-sm-push-5{position:relative;left:20.83333%}.el-col-sm-6{width:25%}.el-col-sm-offset-6{margin-left:25%}.el-col-sm-pull-6{position:relative;right:25%}.el-col-sm-push-6{position:relative;left:25%}.el-col-sm-7{width:29.16667%}.el-col-sm-offset-7{margin-left:29.16667%}.el-col-sm-pull-7{position:relative;right:29.16667%}.el-col-sm-push-7{position:relative;left:29.16667%}.el-col-sm-8{width:33.33333%}.el-col-sm-offset-8{margin-left:33.33333%}.el-col-sm-pull-8{position:relative;right:33.33333%}.el-col-sm-push-8{position:relative;left:33.33333%}.el-col-sm-9{width:37.5%}.el-col-sm-offset-9{margin-left:37.5%}.el-col-sm-pull-9{position:relative;right:37.5%}.el-col-sm-push-9{position:relative;left:37.5%}.el-col-sm-10{width:41.66667%}.el-col-sm-offset-10{margin-left:41.66667%}.el-col-sm-pull-10{position:relative;right:41.66667%}.el-col-sm-push-10{position:relative;left:41.66667%}.el-col-sm-11{width:45.83333%}.el-col-sm-offset-11{margin-left:45.83333%}.el-col-sm-pull-11{position:relative;right:45.83333%}.el-col-sm-push-11{position:relative;left:45.83333%}.el-col-sm-12{width:50%}.el-col-sm-offset-12{margin-left:50%}.el-col-sm-pull-12{position:relative;right:50%}.el-col-sm-push-12{position:relative;left:50%}.el-col-sm-13{width:54.16667%}.el-col-sm-offset-13{margin-left:54.16667%}.el-col-sm-pull-13{position:relative;right:54.16667%}.el-col-sm-push-13{position:relative;left:54.16667%}.el-col-sm-14{width:58.33333%}.el-col-sm-offset-14{margin-left:58.33333%}.el-col-sm-pull-14{position:relative;right:58.33333%}.el-col-sm-push-14{position:relative;left:58.33333%}.el-col-sm-15{width:62.5%}.el-col-sm-offset-15{margin-left:62.5%}.el-col-sm-pull-15{position:relative;right:62.5%}.el-col-sm-push-15{position:relative;left:62.5%}.el-col-sm-16{width:66.66667%}.el-col-sm-offset-16{margin-left:66.66667%}.el-col-sm-pull-16{position:relative;right:66.66667%}.el-col-sm-push-16{position:relative;left:66.66667%}.el-col-sm-17{width:70.83333%}.el-col-sm-offset-17{margin-left:70.83333%}.el-col-sm-pull-17{position:relative;right:70.83333%}.el-col-sm-push-17{position:relative;left:70.83333%}.el-col-sm-18{width:75%}.el-col-sm-offset-18{margin-left:75%}.el-col-sm-pull-18{position:relative;right:75%}.el-col-sm-push-18{position:relative;left:75%}.el-col-sm-19{width:79.16667%}.el-col-sm-offset-19{margin-left:79.16667%}.el-col-sm-pull-19{position:relative;right:79.16667%}.el-col-sm-push-19{position:relative;left:79.16667%}.el-col-sm-20{width:83.33333%}.el-col-sm-offset-20{margin-left:83.33333%}.el-col-sm-pull-20{position:relative;right:83.33333%}.el-col-sm-push-20{position:relative;left:83.33333%}.el-col-sm-21{width:87.5%}.el-col-sm-offset-21{margin-left:87.5%}.el-col-sm-pull-21{position:relative;right:87.5%}.el-col-sm-push-21{position:relative;left:87.5%}.el-col-sm-22{width:91.66667%}.el-col-sm-offset-22{margin-left:91.66667%}.el-col-sm-pull-22{position:relative;right:91.66667%}.el-col-sm-push-22{position:relative;left:91.66667%}.el-col-sm-23{width:95.83333%}.el-col-sm-offset-23{margin-left:95.83333%}.el-col-sm-pull-23{position:relative;right:95.83333%}.el-col-sm-push-23{position:relative;left:95.83333%}.el-col-sm-24{width:100%}.el-col-sm-offset-24{margin-left:100%}.el-col-sm-pull-24{position:relative;right:100%}.el-col-sm-push-24{position:relative;left:100%}}@media only screen and (min-width:992px){.el-col-md-0{display:none;width:0}.el-col-md-offset-0{margin-left:0}.el-col-md-pull-0{position:relative;right:0}.el-col-md-push-0{position:relative;left:0}.el-col-md-1{width:4.16667%}.el-col-md-offset-1{margin-left:4.16667%}.el-col-md-pull-1{position:relative;right:4.16667%}.el-col-md-push-1{position:relative;left:4.16667%}.el-col-md-2{width:8.33333%}.el-col-md-offset-2{margin-left:8.33333%}.el-col-md-pull-2{position:relative;right:8.33333%}.el-col-md-push-2{position:relative;left:8.33333%}.el-col-md-3{width:12.5%}.el-col-md-offset-3{margin-left:12.5%}.el-col-md-pull-3{position:relative;right:12.5%}.el-col-md-push-3{position:relative;left:12.5%}.el-col-md-4{width:16.66667%}.el-col-md-offset-4{margin-left:16.66667%}.el-col-md-pull-4{position:relative;right:16.66667%}.el-col-md-push-4{position:relative;left:16.66667%}.el-col-md-5{width:20.83333%}.el-col-md-offset-5{margin-left:20.83333%}.el-col-md-pull-5{position:relative;right:20.83333%}.el-col-md-push-5{position:relative;left:20.83333%}.el-col-md-6{width:25%}.el-col-md-offset-6{margin-left:25%}.el-col-md-pull-6{position:relative;right:25%}.el-col-md-push-6{position:relative;left:25%}.el-col-md-7{width:29.16667%}.el-col-md-offset-7{margin-left:29.16667%}.el-col-md-pull-7{position:relative;right:29.16667%}.el-col-md-push-7{position:relative;left:29.16667%}.el-col-md-8{width:33.33333%}.el-col-md-offset-8{margin-left:33.33333%}.el-col-md-pull-8{position:relative;right:33.33333%}.el-col-md-push-8{position:relative;left:33.33333%}.el-col-md-9{width:37.5%}.el-col-md-offset-9{margin-left:37.5%}.el-col-md-pull-9{position:relative;right:37.5%}.el-col-md-push-9{position:relative;left:37.5%}.el-col-md-10{width:41.66667%}.el-col-md-offset-10{margin-left:41.66667%}.el-col-md-pull-10{position:relative;right:41.66667%}.el-col-md-push-10{position:relative;left:41.66667%}.el-col-md-11{width:45.83333%}.el-col-md-offset-11{margin-left:45.83333%}.el-col-md-pull-11{position:relative;right:45.83333%}.el-col-md-push-11{position:relative;left:45.83333%}.el-col-md-12{width:50%}.el-col-md-offset-12{margin-left:50%}.el-col-md-pull-12{position:relative;right:50%}.el-col-md-push-12{position:relative;left:50%}.el-col-md-13{width:54.16667%}.el-col-md-offset-13{margin-left:54.16667%}.el-col-md-pull-13{position:relative;right:54.16667%}.el-col-md-push-13{position:relative;left:54.16667%}.el-col-md-14{width:58.33333%}.el-col-md-offset-14{margin-left:58.33333%}.el-col-md-pull-14{position:relative;right:58.33333%}.el-col-md-push-14{position:relative;left:58.33333%}.el-col-md-15{width:62.5%}.el-col-md-offset-15{margin-left:62.5%}.el-col-md-pull-15{position:relative;right:62.5%}.el-col-md-push-15{position:relative;left:62.5%}.el-col-md-16{width:66.66667%}.el-col-md-offset-16{margin-left:66.66667%}.el-col-md-pull-16{position:relative;right:66.66667%}.el-col-md-push-16{position:relative;left:66.66667%}.el-col-md-17{width:70.83333%}.el-col-md-offset-17{margin-left:70.83333%}.el-col-md-pull-17{position:relative;right:70.83333%}.el-col-md-push-17{position:relative;left:70.83333%}.el-col-md-18{width:75%}.el-col-md-offset-18{margin-left:75%}.el-col-md-pull-18{position:relative;right:75%}.el-col-md-push-18{position:relative;left:75%}.el-col-md-19{width:79.16667%}.el-col-md-offset-19{margin-left:79.16667%}.el-col-md-pull-19{position:relative;right:79.16667%}.el-col-md-push-19{position:relative;left:79.16667%}.el-col-md-20{width:83.33333%}.el-col-md-offset-20{margin-left:83.33333%}.el-col-md-pull-20{position:relative;right:83.33333%}.el-col-md-push-20{position:relative;left:83.33333%}.el-col-md-21{width:87.5%}.el-col-md-offset-21{margin-left:87.5%}.el-col-md-pull-21{position:relative;right:87.5%}.el-col-md-push-21{position:relative;left:87.5%}.el-col-md-22{width:91.66667%}.el-col-md-offset-22{margin-left:91.66667%}.el-col-md-pull-22{position:relative;right:91.66667%}.el-col-md-push-22{position:relative;left:91.66667%}.el-col-md-23{width:95.83333%}.el-col-md-offset-23{margin-left:95.83333%}.el-col-md-pull-23{position:relative;right:95.83333%}.el-col-md-push-23{position:relative;left:95.83333%}.el-col-md-24{width:100%}.el-col-md-offset-24{margin-left:100%}.el-col-md-pull-24{position:relative;right:100%}.el-col-md-push-24{position:relative;left:100%}}@media only screen and (min-width:1200px){.el-col-lg-0{display:none;width:0}.el-col-lg-offset-0{margin-left:0}.el-col-lg-pull-0{position:relative;right:0}.el-col-lg-push-0{position:relative;left:0}.el-col-lg-1{width:4.16667%}.el-col-lg-offset-1{margin-left:4.16667%}.el-col-lg-pull-1{position:relative;right:4.16667%}.el-col-lg-push-1{position:relative;left:4.16667%}.el-col-lg-2{width:8.33333%}.el-col-lg-offset-2{margin-left:8.33333%}.el-col-lg-pull-2{position:relative;right:8.33333%}.el-col-lg-push-2{position:relative;left:8.33333%}.el-col-lg-3{width:12.5%}.el-col-lg-offset-3{margin-left:12.5%}.el-col-lg-pull-3{position:relative;right:12.5%}.el-col-lg-push-3{position:relative;left:12.5%}.el-col-lg-4{width:16.66667%}.el-col-lg-offset-4{margin-left:16.66667%}.el-col-lg-pull-4{position:relative;right:16.66667%}.el-col-lg-push-4{position:relative;left:16.66667%}.el-col-lg-5{width:20.83333%}.el-col-lg-offset-5{margin-left:20.83333%}.el-col-lg-pull-5{position:relative;right:20.83333%}.el-col-lg-push-5{position:relative;left:20.83333%}.el-col-lg-6{width:25%}.el-col-lg-offset-6{margin-left:25%}.el-col-lg-pull-6{position:relative;right:25%}.el-col-lg-push-6{position:relative;left:25%}.el-col-lg-7{width:29.16667%}.el-col-lg-offset-7{margin-left:29.16667%}.el-col-lg-pull-7{position:relative;right:29.16667%}.el-col-lg-push-7{position:relative;left:29.16667%}.el-col-lg-8{width:33.33333%}.el-col-lg-offset-8{margin-left:33.33333%}.el-col-lg-pull-8{position:relative;right:33.33333%}.el-col-lg-push-8{position:relative;left:33.33333%}.el-col-lg-9{width:37.5%}.el-col-lg-offset-9{margin-left:37.5%}.el-col-lg-pull-9{position:relative;right:37.5%}.el-col-lg-push-9{position:relative;left:37.5%}.el-col-lg-10{width:41.66667%}.el-col-lg-offset-10{margin-left:41.66667%}.el-col-lg-pull-10{position:relative;right:41.66667%}.el-col-lg-push-10{position:relative;left:41.66667%}.el-col-lg-11{width:45.83333%}.el-col-lg-offset-11{margin-left:45.83333%}.el-col-lg-pull-11{position:relative;right:45.83333%}.el-col-lg-push-11{position:relative;left:45.83333%}.el-col-lg-12{width:50%}.el-col-lg-offset-12{margin-left:50%}.el-col-lg-pull-12{position:relative;right:50%}.el-col-lg-push-12{position:relative;left:50%}.el-col-lg-13{width:54.16667%}.el-col-lg-offset-13{margin-left:54.16667%}.el-col-lg-pull-13{position:relative;right:54.16667%}.el-col-lg-push-13{position:relative;left:54.16667%}.el-col-lg-14{width:58.33333%}.el-col-lg-offset-14{margin-left:58.33333%}.el-col-lg-pull-14{position:relative;right:58.33333%}.el-col-lg-push-14{position:relative;left:58.33333%}.el-col-lg-15{width:62.5%}.el-col-lg-offset-15{margin-left:62.5%}.el-col-lg-pull-15{position:relative;right:62.5%}.el-col-lg-push-15{position:relative;left:62.5%}.el-col-lg-16{width:66.66667%}.el-col-lg-offset-16{margin-left:66.66667%}.el-col-lg-pull-16{position:relative;right:66.66667%}.el-col-lg-push-16{position:relative;left:66.66667%}.el-col-lg-17{width:70.83333%}.el-col-lg-offset-17{margin-left:70.83333%}.el-col-lg-pull-17{position:relative;right:70.83333%}.el-col-lg-push-17{position:relative;left:70.83333%}.el-col-lg-18{width:75%}.el-col-lg-offset-18{margin-left:75%}.el-col-lg-pull-18{position:relative;right:75%}.el-col-lg-push-18{position:relative;left:75%}.el-col-lg-19{width:79.16667%}.el-col-lg-offset-19{margin-left:79.16667%}.el-col-lg-pull-19{position:relative;right:79.16667%}.el-col-lg-push-19{position:relative;left:79.16667%}.el-col-lg-20{width:83.33333%}.el-col-lg-offset-20{margin-left:83.33333%}.el-col-lg-pull-20{position:relative;right:83.33333%}.el-col-lg-push-20{position:relative;left:83.33333%}.el-col-lg-21{width:87.5%}.el-col-lg-offset-21{margin-left:87.5%}.el-col-lg-pull-21{position:relative;right:87.5%}.el-col-lg-push-21{position:relative;left:87.5%}.el-col-lg-22{width:91.66667%}.el-col-lg-offset-22{margin-left:91.66667%}.el-col-lg-pull-22{position:relative;right:91.66667%}.el-col-lg-push-22{position:relative;left:91.66667%}.el-col-lg-23{width:95.83333%}.el-col-lg-offset-23{margin-left:95.83333%}.el-col-lg-pull-23{position:relative;right:95.83333%}.el-col-lg-push-23{position:relative;left:95.83333%}.el-col-lg-24{width:100%}.el-col-lg-offset-24{margin-left:100%}.el-col-lg-pull-24{position:relative;right:100%}.el-col-lg-push-24{position:relative;left:100%}}@media only screen and (min-width:1920px){.el-col-xl-0{display:none;width:0}.el-col-xl-offset-0{margin-left:0}.el-col-xl-pull-0{position:relative;right:0}.el-col-xl-push-0{position:relative;left:0}.el-col-xl-1{width:4.16667%}.el-col-xl-offset-1{margin-left:4.16667%}.el-col-xl-pull-1{position:relative;right:4.16667%}.el-col-xl-push-1{position:relative;left:4.16667%}.el-col-xl-2{width:8.33333%}.el-col-xl-offset-2{margin-left:8.33333%}.el-col-xl-pull-2{position:relative;right:8.33333%}.el-col-xl-push-2{position:relative;left:8.33333%}.el-col-xl-3{width:12.5%}.el-col-xl-offset-3{margin-left:12.5%}.el-col-xl-pull-3{position:relative;right:12.5%}.el-col-xl-push-3{position:relative;left:12.5%}.el-col-xl-4{width:16.66667%}.el-col-xl-offset-4{margin-left:16.66667%}.el-col-xl-pull-4{position:relative;right:16.66667%}.el-col-xl-push-4{position:relative;left:16.66667%}.el-col-xl-5{width:20.83333%}.el-col-xl-offset-5{margin-left:20.83333%}.el-col-xl-pull-5{position:relative;right:20.83333%}.el-col-xl-push-5{position:relative;left:20.83333%}.el-col-xl-6{width:25%}.el-col-xl-offset-6{margin-left:25%}.el-col-xl-pull-6{position:relative;right:25%}.el-col-xl-push-6{position:relative;left:25%}.el-col-xl-7{width:29.16667%}.el-col-xl-offset-7{margin-left:29.16667%}.el-col-xl-pull-7{position:relative;right:29.16667%}.el-col-xl-push-7{position:relative;left:29.16667%}.el-col-xl-8{width:33.33333%}.el-col-xl-offset-8{margin-left:33.33333%}.el-col-xl-pull-8{position:relative;right:33.33333%}.el-col-xl-push-8{position:relative;left:33.33333%}.el-col-xl-9{width:37.5%}.el-col-xl-offset-9{margin-left:37.5%}.el-col-xl-pull-9{position:relative;right:37.5%}.el-col-xl-push-9{position:relative;left:37.5%}.el-col-xl-10{width:41.66667%}.el-col-xl-offset-10{margin-left:41.66667%}.el-col-xl-pull-10{position:relative;right:41.66667%}.el-col-xl-push-10{position:relative;left:41.66667%}.el-col-xl-11{width:45.83333%}.el-col-xl-offset-11{margin-left:45.83333%}.el-col-xl-pull-11{position:relative;right:45.83333%}.el-col-xl-push-11{position:relative;left:45.83333%}.el-col-xl-12{width:50%}.el-col-xl-offset-12{margin-left:50%}.el-col-xl-pull-12{position:relative;right:50%}.el-col-xl-push-12{position:relative;left:50%}.el-col-xl-13{width:54.16667%}.el-col-xl-offset-13{margin-left:54.16667%}.el-col-xl-pull-13{position:relative;right:54.16667%}.el-col-xl-push-13{position:relative;left:54.16667%}.el-col-xl-14{width:58.33333%}.el-col-xl-offset-14{margin-left:58.33333%}.el-col-xl-pull-14{position:relative;right:58.33333%}.el-col-xl-push-14{position:relative;left:58.33333%}.el-col-xl-15{width:62.5%}.el-col-xl-offset-15{margin-left:62.5%}.el-col-xl-pull-15{position:relative;right:62.5%}.el-col-xl-push-15{position:relative;left:62.5%}.el-col-xl-16{width:66.66667%}.el-col-xl-offset-16{margin-left:66.66667%}.el-col-xl-pull-16{position:relative;right:66.66667%}.el-col-xl-push-16{position:relative;left:66.66667%}.el-col-xl-17{width:70.83333%}.el-col-xl-offset-17{margin-left:70.83333%}.el-col-xl-pull-17{position:relative;right:70.83333%}.el-col-xl-push-17{position:relative;left:70.83333%}.el-col-xl-18{width:75%}.el-col-xl-offset-18{margin-left:75%}.el-col-xl-pull-18{position:relative;right:75%}.el-col-xl-push-18{position:relative;left:75%}.el-col-xl-19{width:79.16667%}.el-col-xl-offset-19{margin-left:79.16667%}.el-col-xl-pull-19{position:relative;right:79.16667%}.el-col-xl-push-19{position:relative;left:79.16667%}.el-col-xl-20{width:83.33333%}.el-col-xl-offset-20{margin-left:83.33333%}.el-col-xl-pull-20{position:relative;right:83.33333%}.el-col-xl-push-20{position:relative;left:83.33333%}.el-col-xl-21{width:87.5%}.el-col-xl-offset-21{margin-left:87.5%}.el-col-xl-pull-21{position:relative;right:87.5%}.el-col-xl-push-21{position:relative;left:87.5%}.el-col-xl-22{width:91.66667%}.el-col-xl-offset-22{margin-left:91.66667%}.el-col-xl-pull-22{position:relative;right:91.66667%}.el-col-xl-push-22{position:relative;left:91.66667%}.el-col-xl-23{width:95.83333%}.el-col-xl-offset-23{margin-left:95.83333%}.el-col-xl-pull-23{position:relative;right:95.83333%}.el-col-xl-push-23{position:relative;left:95.83333%}.el-col-xl-24{width:100%}.el-col-xl-offset-24{margin-left:100%}.el-col-xl-pull-24{position:relative;right:100%}.el-col-xl-push-24{position:relative;left:100%}}@-webkit-keyframes progress{0%{background-position:0 0}to{background-position:32px 0}}.el-upload{display:inline-block;text-align:center;cursor:pointer;outline:0}.el-upload__input{display:none}.el-upload__tip{font-size:12px;color:#606266;margin-top:7px}.el-upload iframe{position:absolute;z-index:-1;top:0;left:0;opacity:0;filter:alpha(opacity=0)}.el-upload--picture-card{background-color:#fbfdff;border:1px dashed #c0ccda;border-radius:6px;box-sizing:border-box;width:148px;height:148px;line-height:146px;vertical-align:top}.el-upload--picture-card i{font-size:28px;color:#8c939d}.el-upload--picture-card:hover,.el-upload:focus{border-color:#409eff;color:#409eff}.el-upload:focus .el-upload-dragger{border-color:#409eff}.el-upload-dragger{background-color:#fff;border:1px dashed #d9d9d9;border-radius:6px;box-sizing:border-box;width:360px;height:180px;text-align:center;position:relative;overflow:hidden}.el-upload-dragger .el-icon-upload{font-size:67px;color:#c0c4cc;margin:40px 0 16px;line-height:50px}.el-upload-dragger+.el-upload__tip{text-align:center}.el-upload-dragger~.el-upload__files{border-top:1px solid #dcdfe6;margin-top:7px;padding-top:5px}.el-upload-dragger .el-upload__text{color:#606266;font-size:14px;text-align:center}.el-upload-dragger .el-upload__text em{color:#409eff;font-style:normal}.el-upload-dragger:hover{border-color:#409eff}.el-upload-dragger.is-dragover{background-color:rgba(32,159,255,.06);border:2px dashed #409eff}.el-upload-list{margin:0;padding:0;list-style:none}.el-upload-list__item{transition:all .5s cubic-bezier(.55,0,.1,1);font-size:14px;color:#606266;line-height:1.8;margin-top:5px;position:relative;box-sizing:border-box;border-radius:4px;width:100%}.el-upload-list__item .el-progress{position:absolute;top:20px;width:100%}.el-upload-list__item .el-progress__text{position:absolute;right:0;top:-13px}.el-upload-list__item .el-progress-bar{margin-right:0;padding-right:0}.el-upload-list__item:first-child{margin-top:10px}.el-upload-list__item .el-icon-upload-success{color:#67c23a}.el-upload-list__item .el-icon-close{display:none;position:absolute;top:5px;right:5px;cursor:pointer;opacity:.75;color:#606266}.el-upload-list__item .el-icon-close:hover{opacity:1}.el-upload-list__item .el-icon-close-tip{display:none;position:absolute;top:5px;right:5px;font-size:12px;cursor:pointer;opacity:1;color:#409eff}.el-upload-list__item:hover{background-color:#f5f7fa}.el-upload-list__item:hover .el-icon-close{display:inline-block}.el-upload-list__item:hover .el-progress__text{display:none}.el-upload-list__item.is-success .el-upload-list__item-status-label{display:block}.el-upload-list__item.is-success .el-upload-list__item-name:focus,.el-upload-list__item.is-success .el-upload-list__item-name:hover{color:#409eff;cursor:pointer}.el-upload-list__item.is-success:focus:not(:hover) .el-icon-close-tip{display:inline-block}.el-upload-list__item.is-success:active .el-icon-close-tip,.el-upload-list__item.is-success:focus .el-upload-list__item-status-label,.el-upload-list__item.is-success:hover .el-upload-list__item-status-label,.el-upload-list__item.is-success:not(.focusing):focus .el-icon-close-tip{display:none}.el-upload-list.is-disabled .el-upload-list__item:hover .el-upload-list__item-status-label{display:block}.el-upload-list__item-name{color:#606266;display:block;margin-right:40px;overflow:hidden;padding-left:4px;text-overflow:ellipsis;transition:color .3s;white-space:nowrap}.el-upload-list__item-name [class^=el-icon]{height:100%;margin-right:7px;color:#909399;line-height:inherit}.el-upload-list__item-status-label{position:absolute;right:5px;top:0;line-height:inherit;display:none}.el-upload-list__item-delete{position:absolute;right:10px;top:0;font-size:12px;color:#606266;display:none}.el-upload-list__item-delete:hover{color:#409eff}.el-upload-list--picture-card{margin:0;display:inline;vertical-align:top}.el-upload-list--picture-card .el-upload-list__item{overflow:hidden;background-color:#fff;border:1px solid #c0ccda;border-radius:6px;box-sizing:border-box;width:148px;height:148px;margin:0 8px 8px 0;display:inline-block}.el-upload-list--picture-card .el-upload-list__item .el-icon-check,.el-upload-list--picture-card .el-upload-list__item .el-icon-circle-check{color:#fff}.el-upload-list--picture-card .el-upload-list__item .el-icon-close,.el-upload-list--picture-card .el-upload-list__item:hover .el-upload-list__item-status-label{display:none}.el-upload-list--picture-card .el-upload-list__item:hover .el-progress__text{display:block}.el-upload-list--picture-card .el-upload-list__item-name{display:none}.el-upload-list--picture-card .el-upload-list__item-thumbnail{width:100%;height:100%}.el-upload-list--picture-card .el-upload-list__item-status-label{position:absolute;right:-15px;top:-6px;width:40px;height:24px;background:#13ce66;text-align:center;transform:rotate(45deg);box-shadow:0 0 1pc 1px rgba(0,0,0,.2)}.el-upload-list--picture-card .el-upload-list__item-status-label i{font-size:12px;margin-top:11px;transform:rotate(-45deg)}.el-upload-list--picture-card .el-upload-list__item-actions{position:absolute;width:100%;height:100%;left:0;top:0;cursor:default;text-align:center;color:#fff;opacity:0;font-size:20px;background-color:rgba(0,0,0,.5);transition:opacity .3s}.el-upload-list--picture-card .el-upload-list__item-actions:after{display:inline-block;content:"";height:100%;vertical-align:middle}.el-upload-list--picture-card .el-upload-list__item-actions span{display:none;cursor:pointer}.el-upload-list--picture-card .el-upload-list__item-actions span+span{margin-left:15px}.el-upload-list--picture-card .el-upload-list__item-actions .el-upload-list__item-delete{position:static;font-size:inherit;color:inherit}.el-upload-list--picture-card .el-upload-list__item-actions:hover{opacity:1}.el-upload-list--picture-card .el-upload-list__item-actions:hover span{display:inline-block}.el-upload-list--picture-card .el-progress{top:50%;left:50%;transform:translate(-50%,-50%);bottom:auto;width:126px}.el-upload-list--picture-card .el-progress .el-progress__text{top:50%}.el-upload-list--picture .el-upload-list__item{overflow:hidden;z-index:0;background-color:#fff;border:1px solid #c0ccda;border-radius:6px;box-sizing:border-box;margin-top:10px;padding:10px 10px 10px 90px;height:92px}.el-upload-list--picture .el-upload-list__item .el-icon-check,.el-upload-list--picture .el-upload-list__item .el-icon-circle-check{color:#fff}.el-upload-list--picture .el-upload-list__item:hover .el-upload-list__item-status-label{background:0 0;box-shadow:none;top:-2px;right:-12px}.el-upload-list--picture .el-upload-list__item:hover .el-progress__text{display:block}.el-upload-list--picture .el-upload-list__item.is-success .el-upload-list__item-name{line-height:70px;margin-top:0}.el-upload-list--picture .el-upload-list__item.is-success .el-upload-list__item-name i{display:none}.el-upload-list--picture .el-upload-list__item-thumbnail{vertical-align:middle;display:inline-block;width:70px;height:70px;float:left;position:relative;z-index:1;margin-left:-80px;background-color:#fff}.el-upload-list--picture .el-upload-list__item-name{display:block;margin-top:20px}.el-upload-list--picture .el-upload-list__item-name i{font-size:70px;line-height:1;position:absolute;left:9px;top:10px}.el-upload-list--picture .el-upload-list__item-status-label{position:absolute;right:-17px;top:-7px;width:46px;height:26px;background:#13ce66;text-align:center;transform:rotate(45deg);box-shadow:0 1px 1px #ccc}.el-upload-list--picture .el-upload-list__item-status-label i{font-size:12px;margin-top:12px;transform:rotate(-45deg)}.el-upload-list--picture .el-progress{position:relative;top:-7px}.el-upload-cover{position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;z-index:10;cursor:default}.el-upload-cover:after{display:inline-block;height:100%;vertical-align:middle}.el-upload-cover img{display:block;width:100%;height:100%}.el-upload-cover__label{position:absolute;right:-15px;top:-6px;width:40px;height:24px;background:#13ce66;text-align:center;transform:rotate(45deg);box-shadow:0 0 1pc 1px rgba(0,0,0,.2)}.el-upload-cover__label i{font-size:12px;margin-top:11px;transform:rotate(-45deg);color:#fff}.el-upload-cover__progress{display:inline-block;vertical-align:middle;position:static;width:243px}.el-upload-cover__progress+.el-upload__inner{opacity:0}.el-upload-cover__content{position:absolute;top:0;left:0;width:100%;height:100%}.el-upload-cover__interact{position:absolute;bottom:0;left:0;width:100%;height:100%;background-color:rgba(0,0,0,.72);text-align:center}.el-upload-cover__interact .btn{display:inline-block;color:#fff;font-size:14px;cursor:pointer;vertical-align:middle;transition:transform .3s cubic-bezier(.23,1,.32,1),opacity .3s cubic-bezier(.23,1,.32,1);margin-top:60px}.el-upload-cover__interact .btn span{opacity:0;transition:opacity .15s linear}.el-upload-cover__interact .btn:not(:first-child){margin-left:35px}.el-upload-cover__interact .btn:hover{transform:translateY(-13px)}.el-upload-cover__interact .btn:hover span{opacity:1}.el-upload-cover__interact .btn i{color:#fff;display:block;font-size:24px;line-height:inherit;margin:0 auto 5px}.el-upload-cover__title{position:absolute;bottom:0;left:0;background-color:#fff;height:36px;width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:400;text-align:left;padding:0 10px;margin:0;line-height:36px;font-size:14px;color:#303133}.el-upload-cover+.el-upload__inner{opacity:0;position:relative;z-index:1}.el-progress{position:relative;line-height:1}.el-progress__text{font-size:14px;color:#606266;display:inline-block;vertical-align:middle;margin-left:10px;line-height:1}.el-progress__text i{vertical-align:middle;display:block}.el-progress--circle,.el-progress--dashboard{display:inline-block}.el-progress--circle .el-progress__text,.el-progress--dashboard .el-progress__text{position:absolute;top:50%;left:0;width:100%;text-align:center;margin:0;transform:translateY(-50%)}.el-progress--circle .el-progress__text i,.el-progress--dashboard .el-progress__text i{vertical-align:middle;display:inline-block}.el-progress--without-text .el-progress__text{display:none}.el-progress--without-text .el-progress-bar{padding-right:0;margin-right:0;display:block}.el-progress-bar,.el-progress-bar__inner:after,.el-progress-bar__innerText,.el-spinner{display:inline-block;vertical-align:middle}.el-progress--text-inside .el-progress-bar{padding-right:0;margin-right:0}.el-progress.is-success .el-progress-bar__inner{background-color:#67c23a}.el-progress.is-success .el-progress__text{color:#67c23a}.el-progress.is-warning .el-progress-bar__inner{background-color:#e6a23c}.el-progress.is-warning .el-progress__text{color:#e6a23c}.el-progress.is-exception .el-progress-bar__inner{background-color:#f56c6c}.el-progress.is-exception .el-progress__text{color:#f56c6c}.el-progress-bar{padding-right:50px;width:100%;margin-right:-55px;box-sizing:border-box}.el-progress-bar__outer{height:6px;border-radius:100px;background-color:#ebeef5;overflow:hidden;position:relative;vertical-align:middle}.el-progress-bar__inner{position:absolute;left:0;top:0;height:100%;background-color:#409eff;text-align:right;border-radius:100px;line-height:1;white-space:nowrap;transition:width .6s ease}.el-card,.el-message{border-radius:4px;overflow:hidden}.el-progress-bar__inner:after{height:100%}.el-progress-bar__innerText{color:#fff;font-size:12px;margin:0 5px}@keyframes progress{0%{background-position:0 0}to{background-position:32px 0}}.el-time-spinner{width:100%;white-space:nowrap}.el-spinner-inner{-webkit-animation:rotate 2s linear infinite;animation:rotate 2s linear infinite;width:50px;height:50px}.el-spinner-inner .path{stroke:#ececec;stroke-linecap:round;-webkit-animation:dash 1.5s ease-in-out infinite;animation:dash 1.5s ease-in-out infinite}@-webkit-keyframes rotate{to{transform:rotate(1turn)}}@keyframes rotate{to{transform:rotate(1turn)}}@-webkit-keyframes dash{0%{stroke-dasharray:1,150;stroke-dashoffset:0}50%{stroke-dasharray:90,150;stroke-dashoffset:-35}to{stroke-dasharray:90,150;stroke-dashoffset:-124}}@keyframes dash{0%{stroke-dasharray:1,150;stroke-dashoffset:0}50%{stroke-dasharray:90,150;stroke-dashoffset:-35}to{stroke-dasharray:90,150;stroke-dashoffset:-124}}.el-message{min-width:380px;box-sizing:border-box;border-width:1px;border-style:solid;border-color:#ebeef5;position:fixed;left:50%;top:20px;transform:translateX(-50%);background-color:#edf2fc;transition:opacity .3s,transform .4s,top .4s;padding:15px 15px 15px 20px;display:flex;align-items:center}.el-message.is-center{justify-content:center}.el-message.is-closable .el-message__content{padding-right:16px}.el-message p{margin:0}.el-message--info .el-message__content{color:#909399}.el-message--success{background-color:#f0f9eb;border-color:#e1f3d8}.el-message--success .el-message__content{color:#67c23a}.el-message--warning{background-color:#fdf6ec;border-color:#faecd8}.el-message--warning .el-message__content{color:#e6a23c}.el-message--error{background-color:#fef0f0;border-color:#fde2e2}.el-message--error .el-message__content{color:#f56c6c}.el-message__icon{margin-right:10px}.el-message__content{padding:0;font-size:14px;line-height:1}.el-message__closeBtn{position:absolute;top:50%;right:15px;transform:translateY(-50%);cursor:pointer;color:#c0c4cc;font-size:16px}.el-message__closeBtn:hover{color:#909399}.el-message .el-icon-success{color:#67c23a}.el-message .el-icon-error{color:#f56c6c}.el-message .el-icon-info{color:#909399}.el-message .el-icon-warning{color:#e6a23c}.el-message-fade-enter,.el-message-fade-leave-active{opacity:0;transform:translate(-50%,-100%)}.el-badge{position:relative;vertical-align:middle;display:inline-block}.el-badge__content{background-color:#f56c6c;border-radius:10px;color:#fff;display:inline-block;font-size:12px;height:18px;line-height:18px;padding:0 6px;text-align:center;white-space:nowrap;border:1px solid #fff}.el-badge__content.is-fixed{position:absolute;top:0;right:10px;transform:translateY(-50%) translateX(100%)}.el-rate__icon,.el-rate__item{position:relative;display:inline-block}.el-badge__content.is-fixed.is-dot{right:5px}.el-badge__content.is-dot{height:8px;width:8px;padding:0;right:0;border-radius:50%}.el-badge__content--primary{background-color:#409eff}.el-badge__content--success{background-color:#67c23a}.el-badge__content--warning{background-color:#e6a23c}.el-badge__content--info{background-color:#909399}.el-badge__content--danger{background-color:#f56c6c}.el-card{border:1px solid #ebeef5;background-color:#fff;color:#303133;transition:.3s}.el-card.is-always-shadow,.el-card.is-hover-shadow:focus,.el-card.is-hover-shadow:hover{box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-card__header{padding:18px 20px;border-bottom:1px solid #ebeef5;box-sizing:border-box}.el-card__body{padding:20px}.el-rate{height:20px;line-height:1}.el-rate__item{font-size:0;vertical-align:middle}.el-rate__icon{font-size:18px;margin-right:6px;color:#c0c4cc;transition:.3s}.el-rate__decimal,.el-rate__icon .path2{position:absolute;top:0;left:0}.el-rate__icon.hover{transform:scale(1.15)}.el-rate__decimal{display:inline-block;overflow:hidden}.el-step.is-vertical,.el-steps{display:-ms-flexbox}.el-rate__text{font-size:14px;vertical-align:middle}.el-steps{display:flex}.el-steps--simple{padding:13px 8%;border-radius:4px;background:#f5f7fa}.el-steps--horizontal{white-space:nowrap}.el-steps--vertical{height:100%;flex-flow:column}.el-step{position:relative;flex-shrink:1}.el-step:last-of-type .el-step__line{display:none}.el-step:last-of-type.is-flex{flex-basis:auto!important;flex-shrink:0;flex-grow:0}.el-step:last-of-type .el-step__description,.el-step:last-of-type .el-step__main{padding-right:0}.el-step__head{position:relative;width:100%}.el-step__head.is-process{color:#303133;border-color:#303133}.el-step__head.is-wait{color:#c0c4cc;border-color:#c0c4cc}.el-step__head.is-success{color:#67c23a;border-color:#67c23a}.el-step__head.is-error{color:#f56c6c;border-color:#f56c6c}.el-step__head.is-finish{color:#409eff;border-color:#409eff}.el-step__icon{position:relative;z-index:1;display:inline-flex;justify-content:center;align-items:center;width:24px;height:24px;font-size:14px;box-sizing:border-box;background:#fff;transition:.15s ease-out}.el-step__icon.is-text{border-radius:50%;border:2px solid;border-color:inherit}.el-step__icon.is-icon{width:40px}.el-step__icon-inner{display:inline-block;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;text-align:center;font-weight:700;line-height:1;color:inherit}.el-step__icon-inner[class*=el-icon]:not(.is-status){font-size:25px;font-weight:400}.el-step__icon-inner.is-status{transform:translateY(1px)}.el-step__line{position:absolute;border-color:inherit;background-color:#c0c4cc}.el-step__line-inner{display:block;border-width:1px;border-style:solid;border-color:inherit;transition:.15s ease-out;box-sizing:border-box;width:0;height:0}.el-step__main{white-space:normal;text-align:left}.el-step__title{font-size:16px;line-height:38px}.el-step__title.is-process{font-weight:700;color:#303133}.el-step__title.is-wait{color:#c0c4cc}.el-step__title.is-success{color:#67c23a}.el-step__title.is-error{color:#f56c6c}.el-step__title.is-finish{color:#409eff}.el-step__description{padding-right:10%;margin-top:-5px;font-size:12px;line-height:20px;font-weight:400}.el-step__description.is-process{color:#303133}.el-step__description.is-wait{color:#c0c4cc}.el-step__description.is-success{color:#67c23a}.el-step__description.is-error{color:#f56c6c}.el-step__description.is-finish{color:#409eff}.el-step.is-horizontal{display:inline-block}.el-step.is-horizontal .el-step__line{height:2px;top:11px;left:0;right:0}.el-step.is-vertical{display:flex}.el-step.is-vertical .el-step__head{flex-grow:0;width:24px}.el-step.is-vertical .el-step__main{padding-left:10px;flex-grow:1}.el-step.is-vertical .el-step__title{line-height:24px;padding-bottom:8px}.el-step.is-vertical .el-step__line{width:2px;top:0;bottom:0;left:11px}.el-step.is-vertical .el-step__icon.is-icon{width:24px}.el-step.is-center .el-step__head,.el-step.is-center .el-step__main{text-align:center}.el-step.is-center .el-step__description{padding-left:20%;padding-right:20%}.el-step.is-center .el-step__line{left:50%;right:-50%}.el-step.is-simple{display:flex;align-items:center}.el-step.is-simple .el-step__head{width:auto;font-size:0;padding-right:10px}.el-step.is-simple .el-step__icon{background:0 0;width:16px;height:16px;font-size:12px}.el-step.is-simple .el-step__icon-inner[class*=el-icon]:not(.is-status){font-size:18px}.el-step.is-simple .el-step__icon-inner.is-status{transform:scale(.8) translateY(1px)}.el-step.is-simple .el-step__main{position:relative;display:flex;align-items:stretch;flex-grow:1}.el-step.is-simple .el-step__title{font-size:16px;line-height:20px}.el-step.is-simple:not(:last-of-type) .el-step__title{max-width:50%;word-break:break-all}.el-step.is-simple .el-step__arrow{flex-grow:1;display:flex;align-items:center;justify-content:center}.el-step.is-simple .el-step__arrow:after,.el-step.is-simple .el-step__arrow:before{content:"";display:inline-block;position:absolute;height:15px;width:1px;background:#c0c4cc}.el-step.is-simple .el-step__arrow:before{transform:rotate(-45deg) translateY(-4px);transform-origin:0 0}.el-step.is-simple .el-step__arrow:after{transform:rotate(45deg) translateY(4px);transform-origin:100% 100%}.el-step.is-simple:last-of-type .el-step__arrow{display:none}.el-carousel{position:relative}.el-carousel--horizontal{overflow-x:hidden}.el-carousel--vertical{overflow-y:hidden}.el-carousel__container{position:relative;height:300px}.el-carousel__arrow{border:none;outline:0;padding:0;margin:0;height:36px;width:36px;cursor:pointer;transition:.3s;border-radius:50%;background-color:rgba(31,45,61,.11);color:#fff;position:absolute;top:50%;z-index:10;transform:translateY(-50%);text-align:center;font-size:12px}.el-carousel__arrow--left{left:16px}.el-carousel__arrow--right{right:16px}.el-carousel__arrow:hover{background-color:rgba(31,45,61,.23)}.el-carousel__arrow i{cursor:pointer}.el-carousel__indicators{position:absolute;list-style:none;margin:0;padding:0;z-index:2}.el-carousel__indicators--horizontal{bottom:0;left:50%;transform:translateX(-50%)}.el-carousel__indicators--vertical{right:0;top:50%;transform:translateY(-50%)}.el-carousel__indicators--outside{bottom:26px;text-align:center;position:static;transform:none}.el-carousel__indicators--outside .el-carousel__indicator:hover button{opacity:.64}.el-carousel__indicators--outside button{background-color:#c0c4cc;opacity:.24}.el-carousel__indicators--labels{left:0;right:0;transform:none;text-align:center}.el-carousel__indicators--labels .el-carousel__button{height:auto;width:auto;padding:2px 18px;font-size:12px}.el-carousel__indicators--labels .el-carousel__indicator{padding:6px 4px}.el-carousel__indicator{background-color:transparent;cursor:pointer}.el-carousel__indicator:hover button{opacity:.72}.el-carousel__indicator--horizontal{display:inline-block;padding:12px 4px}.el-carousel__indicator--vertical{padding:4px 12px}.el-carousel__indicator--vertical .el-carousel__button{width:2px;height:15px}.el-carousel__indicator.is-active button{opacity:1}.el-carousel__button{display:block;opacity:.48;width:30px;height:2px;background-color:#fff;border:none;outline:0;padding:0;margin:0;cursor:pointer;transition:.3s}.el-carousel__item,.el-carousel__mask{height:100%;top:0;left:0;position:absolute}.carousel-arrow-left-enter,.carousel-arrow-left-leave-active{transform:translateY(-50%) translateX(-10px);opacity:0}.carousel-arrow-right-enter,.carousel-arrow-right-leave-active{transform:translateY(-50%) translateX(10px);opacity:0}.el-carousel__item{width:100%;display:inline-block;overflow:hidden;z-index:0}.el-carousel__item.is-active{z-index:2}.el-carousel__item--card,.el-carousel__item.is-animating{transition:transform .4s ease-in-out}.el-carousel__item--card{width:50%}.el-carousel__item--card.is-in-stage{cursor:pointer;z-index:1}.el-carousel__item--card.is-in-stage.is-hover .el-carousel__mask,.el-carousel__item--card.is-in-stage:hover .el-carousel__mask{opacity:.12}.el-carousel__item--card.is-active{z-index:2}.el-carousel__mask{width:100%;background-color:#fff;opacity:.24;transition:.2s}.el-fade-in-enter,.el-fade-in-leave-active,.el-fade-in-linear-enter,.el-fade-in-linear-leave,.el-fade-in-linear-leave-active,.fade-in-linear-enter,.fade-in-linear-leave,.fade-in-linear-leave-active{opacity:0}.el-fade-in-linear-enter-active,.el-fade-in-linear-leave-active,.fade-in-linear-enter-active,.fade-in-linear-leave-active{transition:opacity .2s linear}.el-fade-in-enter-active,.el-fade-in-leave-active,.el-zoom-in-center-enter-active,.el-zoom-in-center-leave-active{transition:all .3s cubic-bezier(.55,0,.1,1)}.el-zoom-in-center-enter,.el-zoom-in-center-leave-active{opacity:0;transform:scaleX(0)}.el-zoom-in-top-enter-active,.el-zoom-in-top-leave-active{opacity:1;transform:scaleY(1);transition:transform .3s cubic-bezier(.23,1,.32,1),opacity .3s cubic-bezier(.23,1,.32,1);transform-origin:center top}.el-zoom-in-top-enter,.el-zoom-in-top-leave-active{opacity:0;transform:scaleY(0)}.el-zoom-in-bottom-enter-active,.el-zoom-in-bottom-leave-active{opacity:1;transform:scaleY(1);transition:transform .3s cubic-bezier(.23,1,.32,1),opacity .3s cubic-bezier(.23,1,.32,1);transform-origin:center bottom}.el-zoom-in-bottom-enter,.el-zoom-in-bottom-leave-active{opacity:0;transform:scaleY(0)}.el-zoom-in-left-enter-active,.el-zoom-in-left-leave-active{opacity:1;transform:scale(1);transition:transform .3s cubic-bezier(.23,1,.32,1),opacity .3s cubic-bezier(.23,1,.32,1);transform-origin:top left}.el-zoom-in-left-enter,.el-zoom-in-left-leave-active{opacity:0;transform:scale(.45)}.collapse-transition{transition:height .3s ease-in-out,padding-top .3s ease-in-out,padding-bottom .3s ease-in-out}.horizontal-collapse-transition{transition:width .3s ease-in-out,padding-left .3s ease-in-out,padding-right .3s ease-in-out}.el-list-enter-active,.el-list-leave-active{transition:all 1s}.el-list-enter,.el-list-leave-active{opacity:0;transform:translateY(-30px)}.el-opacity-transition{transition:opacity .3s cubic-bezier(.55,0,.1,1)}.el-collapse{border-top:1px solid #ebeef5;border-bottom:1px solid #ebeef5}.el-collapse-item.is-disabled .el-collapse-item__header{color:#bbb;cursor:not-allowed}.el-collapse-item__header{display:flex;align-items:center;height:48px;line-height:48px;background-color:#fff;color:#303133;cursor:pointer;border-bottom:1px solid #ebeef5;font-size:13px;font-weight:500;transition:border-bottom-color .3s;outline:0}.el-collapse-item__arrow{margin:0 8px 0 auto;transition:transform .3s;font-weight:300}.el-collapse-item__arrow.is-active{transform:rotate(90deg)}.el-collapse-item__header.focusing:focus:not(:hover){color:#409eff}.el-collapse-item__header.is-active{border-bottom-color:transparent}.el-collapse-item__wrap{will-change:height;background-color:#fff;overflow:hidden;box-sizing:border-box;border-bottom:1px solid #ebeef5}.el-cascader__tags,.el-tag{-webkit-box-sizing:border-box}.el-collapse-item__content{padding-bottom:25px;font-size:13px;color:#303133;line-height:1.769230769230769}.el-collapse-item:last-child{margin-bottom:-1px}.el-popper .popper__arrow,.el-popper .popper__arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.el-popper .popper__arrow{border-width:6px;filter:drop-shadow(0 2px 12px rgba(0,0,0,.03))}.el-popper .popper__arrow:after{content:" ";border-width:6px}.el-popper[x-placement^=top]{margin-bottom:12px}.el-popper[x-placement^=top] .popper__arrow{bottom:-6px;left:50%;margin-right:3px;border-top-color:#ebeef5;border-bottom-width:0}.el-popper[x-placement^=top] .popper__arrow:after{bottom:1px;margin-left:-6px;border-top-color:#fff;border-bottom-width:0}.el-popper[x-placement^=bottom]{margin-top:12px}.el-popper[x-placement^=bottom] .popper__arrow{top:-6px;left:50%;margin-right:3px;border-top-width:0;border-bottom-color:#ebeef5}.el-popper[x-placement^=bottom] .popper__arrow:after{top:1px;margin-left:-6px;border-top-width:0;border-bottom-color:#fff}.el-popper[x-placement^=right]{margin-left:12px}.el-popper[x-placement^=right] .popper__arrow{top:50%;left:-6px;margin-bottom:3px;border-right-color:#ebeef5;border-left-width:0}.el-popper[x-placement^=right] .popper__arrow:after{bottom:-6px;left:1px;border-right-color:#fff;border-left-width:0}.el-popper[x-placement^=left]{margin-right:12px}.el-popper[x-placement^=left] .popper__arrow{top:50%;right:-6px;margin-bottom:3px;border-right-width:0;border-left-color:#ebeef5}.el-popper[x-placement^=left] .popper__arrow:after{right:1px;bottom:-6px;margin-left:-6px;border-right-width:0;border-left-color:#fff}.el-tag{background-color:#ecf5ff;border-color:#d9ecff;display:inline-block;height:32px;padding:0 10px;line-height:30px;font-size:12px;color:#409eff;border-width:1px;border-style:solid;border-radius:4px;box-sizing:border-box;white-space:nowrap}.el-tag.is-hit{border-color:#409eff}.el-tag .el-tag__close{color:#409eff}.el-tag .el-tag__close:hover{color:#fff;background-color:#409eff}.el-tag.el-tag--info{background-color:#f4f4f5;border-color:#e9e9eb;color:#909399}.el-tag.el-tag--info.is-hit{border-color:#909399}.el-tag.el-tag--info .el-tag__close{color:#909399}.el-tag.el-tag--info .el-tag__close:hover{color:#fff;background-color:#909399}.el-tag.el-tag--success{background-color:#f0f9eb;border-color:#e1f3d8;color:#67c23a}.el-tag.el-tag--success.is-hit{border-color:#67c23a}.el-tag.el-tag--success .el-tag__close{color:#67c23a}.el-tag.el-tag--success .el-tag__close:hover{color:#fff;background-color:#67c23a}.el-tag.el-tag--warning{background-color:#fdf6ec;border-color:#faecd8;color:#e6a23c}.el-tag.el-tag--warning.is-hit{border-color:#e6a23c}.el-tag.el-tag--warning .el-tag__close{color:#e6a23c}.el-tag.el-tag--warning .el-tag__close:hover{color:#fff;background-color:#e6a23c}.el-tag.el-tag--danger{background-color:#fef0f0;border-color:#fde2e2;color:#f56c6c}.el-tag.el-tag--danger.is-hit{border-color:#f56c6c}.el-tag.el-tag--danger .el-tag__close{color:#f56c6c}.el-tag.el-tag--danger .el-tag__close:hover{color:#fff;background-color:#f56c6c}.el-tag .el-icon-close{border-radius:50%;text-align:center;position:relative;cursor:pointer;font-size:12px;height:16px;width:16px;line-height:16px;vertical-align:middle;top:-1px;right:-5px}.el-tag .el-icon-close:before{display:block}.el-tag--dark{background-color:#409eff;color:#fff}.el-tag--dark,.el-tag--dark.is-hit{border-color:#409eff}.el-tag--dark .el-tag__close{color:#fff}.el-tag--dark .el-tag__close:hover{color:#fff;background-color:#66b1ff}.el-tag--dark.el-tag--info{background-color:#909399;border-color:#909399;color:#fff}.el-tag--dark.el-tag--info.is-hit{border-color:#909399}.el-tag--dark.el-tag--info .el-tag__close{color:#fff}.el-tag--dark.el-tag--info .el-tag__close:hover{color:#fff;background-color:#a6a9ad}.el-tag--dark.el-tag--success{background-color:#67c23a;border-color:#67c23a;color:#fff}.el-tag--dark.el-tag--success.is-hit{border-color:#67c23a}.el-tag--dark.el-tag--success .el-tag__close{color:#fff}.el-tag--dark.el-tag--success .el-tag__close:hover{color:#fff;background-color:#85ce61}.el-tag--dark.el-tag--warning{background-color:#e6a23c;border-color:#e6a23c;color:#fff}.el-tag--dark.el-tag--warning.is-hit{border-color:#e6a23c}.el-tag--dark.el-tag--warning .el-tag__close{color:#fff}.el-tag--dark.el-tag--warning .el-tag__close:hover{color:#fff;background-color:#ebb563}.el-tag--dark.el-tag--danger{background-color:#f56c6c;border-color:#f56c6c;color:#fff}.el-tag--dark.el-tag--danger.is-hit{border-color:#f56c6c}.el-tag--dark.el-tag--danger .el-tag__close{color:#fff}.el-tag--dark.el-tag--danger .el-tag__close:hover{color:#fff;background-color:#f78989}.el-tag--plain{background-color:#fff;border-color:#b3d8ff;color:#409eff}.el-tag--plain.is-hit{border-color:#409eff}.el-tag--plain .el-tag__close{color:#409eff}.el-tag--plain .el-tag__close:hover{color:#fff;background-color:#409eff}.el-tag--plain.el-tag--info{background-color:#fff;border-color:#d3d4d6;color:#909399}.el-tag--plain.el-tag--info.is-hit{border-color:#909399}.el-tag--plain.el-tag--info .el-tag__close{color:#909399}.el-tag--plain.el-tag--info .el-tag__close:hover{color:#fff;background-color:#909399}.el-tag--plain.el-tag--success{background-color:#fff;border-color:#c2e7b0;color:#67c23a}.el-tag--plain.el-tag--success.is-hit{border-color:#67c23a}.el-tag--plain.el-tag--success .el-tag__close{color:#67c23a}.el-tag--plain.el-tag--success .el-tag__close:hover{color:#fff;background-color:#67c23a}.el-tag--plain.el-tag--warning{background-color:#fff;border-color:#f5dab1;color:#e6a23c}.el-tag--plain.el-tag--warning.is-hit{border-color:#e6a23c}.el-tag--plain.el-tag--warning .el-tag__close{color:#e6a23c}.el-tag--plain.el-tag--warning .el-tag__close:hover{color:#fff;background-color:#e6a23c}.el-tag--plain.el-tag--danger{background-color:#fff;border-color:#fbc4c4;color:#f56c6c}.el-tag--plain.el-tag--danger.is-hit{border-color:#f56c6c}.el-tag--plain.el-tag--danger .el-tag__close{color:#f56c6c}.el-tag--plain.el-tag--danger .el-tag__close:hover{color:#fff;background-color:#f56c6c}.el-tag--medium{height:28px;line-height:26px}.el-tag--medium .el-icon-close{transform:scale(.8)}.el-tag--small{height:24px;padding:0 8px;line-height:22px}.el-tag--small .el-icon-close{transform:scale(.8)}.el-tag--mini{height:20px;padding:0 5px;line-height:19px}.el-tag--mini .el-icon-close{margin-left:-3px;transform:scale(.7)}.el-cascader{display:inline-block;position:relative;font-size:14px;line-height:40px}.el-cascader:not(.is-disabled):hover .el-input__inner{cursor:pointer;border-color:#c0c4cc}.el-cascader .el-input .el-input__inner:focus,.el-cascader .el-input.is-focus .el-input__inner{border-color:#409eff}.el-cascader .el-input{cursor:pointer}.el-cascader .el-input .el-input__inner{text-overflow:ellipsis}.el-cascader .el-input .el-icon-arrow-down{transition:transform .3s;font-size:14px}.el-cascader .el-input .el-icon-arrow-down.is-reverse{transform:rotate(180deg)}.el-cascader .el-input .el-icon-circle-close:hover{color:#909399}.el-cascader--medium{font-size:14px;line-height:36px}.el-cascader--small{font-size:13px;line-height:32px}.el-cascader--mini{font-size:12px;line-height:28px}.el-cascader.is-disabled .el-cascader__label{z-index:2;color:#c0c4cc}.el-cascader__dropdown{margin:5px 0;font-size:14px;background:#fff;border:1px solid #e4e7ed;border-radius:4px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-cascader__tags{position:absolute;left:0;right:30px;top:50%;transform:translateY(-50%);display:flex;flex-wrap:wrap;line-height:normal;text-align:left;box-sizing:border-box}.el-cascader__tags .el-tag{display:inline-flex;align-items:center;max-width:100%;margin:2px 0 2px 6px;text-overflow:ellipsis;background:#f0f2f5}.el-cascader__tags .el-tag:not(.is-hit){border-color:transparent}.el-cascader__tags .el-tag>span{flex:1;overflow:hidden;text-overflow:ellipsis}.el-cascader__tags .el-tag .el-icon-close{flex:none;background-color:#c0c4cc;color:#fff}.el-cascader__tags .el-tag .el-icon-close:hover{background-color:#909399}.el-cascader__suggestion-panel{border-radius:4px}.el-cascader__suggestion-list{max-height:204px;margin:0;padding:6px 0;font-size:14px;color:#606266;text-align:center}.el-cascader__suggestion-item{display:flex;justify-content:space-between;align-items:center;height:34px;padding:0 15px;text-align:left;outline:0;cursor:pointer}.el-cascader__suggestion-item:focus,.el-cascader__suggestion-item:hover{background:#f5f7fa}.el-cascader__suggestion-item.is-checked{color:#409eff;font-weight:700}.el-cascader__suggestion-item>span{margin-right:10px}.el-cascader__empty-text{margin:10px 0;color:#c0c4cc}.el-cascader__search-input{flex:1;height:24px;min-width:60px;margin:2px 0 2px 15px;padding:0;color:#606266;border:none;outline:0;box-sizing:border-box}.el-cascader__search-input:-ms-input-placeholder{color:#c0c4cc}.el-cascader__search-input::-moz-placeholder{color:#c0c4cc}.el-cascader__search-input::placeholder{color:#c0c4cc}.el-color-predefine{display:flex;font-size:12px;margin-top:8px;width:280px}.el-color-predefine__colors{display:flex;flex:1;flex-wrap:wrap}.el-color-predefine__color-selector{margin:0 0 8px 8px;width:20px;height:20px;border-radius:4px;cursor:pointer}.el-color-predefine__color-selector:nth-child(10n+1){margin-left:0}.el-color-predefine__color-selector.selected{box-shadow:0 0 3px 2px #409eff}.el-color-predefine__color-selector>div{display:flex;height:100%;border-radius:3px}.el-color-predefine__color-selector.is-alpha{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAMCAIAAADZF8uwAAAAGUlEQVQYV2M4gwH+YwCGIasIUwhT25BVBADtzYNYrHvv4gAAAABJRU5ErkJggg==)}.el-color-hue-slider{position:relative;box-sizing:border-box;width:280px;height:12px;background-color:red;padding:0 2px}.el-color-hue-slider__bar{position:relative;background:linear-gradient(90deg,red 0,#ff0 17%,#0f0 33%,#0ff 50%,#00f 67%,#f0f 83%,red);height:100%}.el-color-hue-slider__thumb{position:absolute;cursor:pointer;box-sizing:border-box;left:0;top:0;width:4px;height:100%;border-radius:1px;background:#fff;border:1px solid #f0f0f0;box-shadow:0 0 2px rgba(0,0,0,.6);z-index:1}.el-color-hue-slider.is-vertical{width:12px;height:180px;padding:2px 0}.el-color-hue-slider.is-vertical .el-color-hue-slider__bar{background:linear-gradient(180deg,red 0,#ff0 17%,#0f0 33%,#0ff 50%,#00f 67%,#f0f 83%,red)}.el-color-hue-slider.is-vertical .el-color-hue-slider__thumb{left:0;top:0;width:100%;height:4px}.el-color-svpanel{position:relative;width:280px;height:180px}.el-color-svpanel__black,.el-color-svpanel__white{position:absolute;top:0;left:0;right:0;bottom:0}.el-color-svpanel__white{background:linear-gradient(90deg,#fff,hsla(0,0%,100%,0))}.el-color-svpanel__black{background:linear-gradient(0deg,#000,transparent)}.el-color-svpanel__cursor{position:absolute}.el-color-svpanel__cursor>div{cursor:head;width:4px;height:4px;box-shadow:0 0 0 1.5px #fff,inset 0 0 1px 1px rgba(0,0,0,.3),0 0 1px 2px rgba(0,0,0,.4);border-radius:50%;transform:translate(-2px,-2px)}.el-color-alpha-slider{position:relative;box-sizing:border-box;width:280px;height:12px;background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAMCAIAAADZF8uwAAAAGUlEQVQYV2M4gwH+YwCGIasIUwhT25BVBADtzYNYrHvv4gAAAABJRU5ErkJggg==)}.el-color-alpha-slider__bar{position:relative;background:linear-gradient(90deg,hsla(0,0%,100%,0) 0,#fff);height:100%}.el-color-alpha-slider__thumb{position:absolute;cursor:pointer;box-sizing:border-box;left:0;top:0;width:4px;height:100%;border-radius:1px;background:#fff;border:1px solid #f0f0f0;box-shadow:0 0 2px rgba(0,0,0,.6);z-index:1}.el-color-alpha-slider.is-vertical{width:20px;height:180px}.el-color-alpha-slider.is-vertical .el-color-alpha-slider__bar{background:linear-gradient(180deg,hsla(0,0%,100%,0) 0,#fff)}.el-color-alpha-slider.is-vertical .el-color-alpha-slider__thumb{left:0;top:0;width:100%;height:4px}.el-color-dropdown{width:300px}.el-color-dropdown__main-wrapper{margin-bottom:6px}.el-color-dropdown__main-wrapper:after{content:"";display:table;clear:both}.el-color-dropdown__btns{margin-top:6px;text-align:right}.el-color-dropdown__value{float:left;line-height:26px;font-size:12px;color:#000;width:160px}.el-color-dropdown__btn{border:1px solid #dcdcdc;color:#333;line-height:24px;border-radius:2px;padding:0 20px;cursor:pointer;background-color:transparent;outline:0;font-size:12px}.el-color-dropdown__btn[disabled]{color:#ccc;cursor:not-allowed}.el-color-dropdown__btn:hover{color:#409eff;border-color:#409eff}.el-color-dropdown__link-btn{cursor:pointer;color:#409eff;text-decoration:none;padding:15px;font-size:12px}.el-color-dropdown__link-btn:hover{color:tint(#409eff,20%)}.el-color-picker{display:inline-block;position:relative;line-height:normal;height:40px}.el-color-picker.is-disabled .el-color-picker__trigger{cursor:not-allowed}.el-color-picker--medium{height:36px}.el-color-picker--medium .el-color-picker__trigger{height:36px;width:36px}.el-color-picker--medium .el-color-picker__mask{height:34px;width:34px}.el-color-picker--small{height:32px}.el-color-picker--small .el-color-picker__trigger{height:32px;width:32px}.el-color-picker--small .el-color-picker__mask{height:30px;width:30px}.el-color-picker--small .el-color-picker__empty,.el-color-picker--small .el-color-picker__icon{transform:translate3d(-50%,-50%,0) scale(.8)}.el-color-picker--mini{height:28px}.el-color-picker--mini .el-color-picker__trigger{height:28px;width:28px}.el-color-picker--mini .el-color-picker__mask{height:26px;width:26px}.el-color-picker--mini .el-color-picker__empty,.el-color-picker--mini .el-color-picker__icon{transform:translate3d(-50%,-50%,0) scale(.8)}.el-color-picker__mask{height:38px;width:38px;border-radius:4px;position:absolute;top:1px;left:1px;z-index:1;cursor:not-allowed;background-color:hsla(0,0%,100%,.7)}.el-color-picker__trigger{display:inline-block;box-sizing:border-box;height:40px;width:40px;padding:4px;border:1px solid #e6e6e6;border-radius:4px;font-size:0;position:relative;cursor:pointer}.el-color-picker__color{position:relative;display:block;box-sizing:border-box;border:1px solid #999;border-radius:2px;width:100%;height:100%;text-align:center}.el-color-picker__color.is-alpha{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAMCAIAAADZF8uwAAAAGUlEQVQYV2M4gwH+YwCGIasIUwhT25BVBADtzYNYrHvv4gAAAABJRU5ErkJggg==)}.el-color-picker__color-inner{position:absolute;left:0;top:0;right:0;bottom:0}.el-color-picker__empty,.el-color-picker__icon{top:50%;left:50%;font-size:12px;position:absolute}.el-color-picker__empty{color:#999;transform:translate3d(-50%,-50%,0)}.el-color-picker__icon{display:inline-block;width:100%;transform:translate3d(-50%,-50%,0);color:#fff;text-align:center}.el-color-picker__panel{position:absolute;z-index:10;padding:6px;box-sizing:content-box;background-color:#fff;border:1px solid #ebeef5;border-radius:4px;box-shadow:0 2px 12px 0 rgba(0,0,0,.1)}.el-textarea{position:relative;display:inline-block;width:100%;vertical-align:bottom;font-size:14px}.el-textarea__inner{display:block;resize:vertical;padding:5px 15px;line-height:1.5;box-sizing:border-box;width:100%;font-size:inherit;color:#606266;background-color:#fff;background-image:none;border:1px solid #dcdfe6;border-radius:4px;transition:border-color .2s cubic-bezier(.645,.045,.355,1)}.el-textarea__inner:-ms-input-placeholder{color:#c0c4cc}.el-textarea__inner::-moz-placeholder{color:#c0c4cc}.el-textarea__inner::placeholder{color:#c0c4cc}.el-textarea__inner:hover{border-color:#c0c4cc}.el-textarea__inner:focus{outline:0;border-color:#409eff}.el-textarea .el-input__count{color:#909399;background:#fff;position:absolute;font-size:12px;bottom:5px;right:10px}.el-textarea.is-disabled .el-textarea__inner{background-color:#f5f7fa;border-color:#e4e7ed;color:#c0c4cc;cursor:not-allowed}.el-textarea.is-disabled .el-textarea__inner:-ms-input-placeholder{color:#c0c4cc}.el-textarea.is-disabled .el-textarea__inner::-moz-placeholder{color:#c0c4cc}.el-textarea.is-disabled .el-textarea__inner::placeholder{color:#c0c4cc}.el-textarea.is-exceed .el-textarea__inner{border-color:#f56c6c}.el-textarea.is-exceed .el-input__count{color:#f56c6c}.el-input{position:relative;font-size:14px;display:inline-block;width:100%}.el-input::-webkit-scrollbar{z-index:11;width:6px}.el-input::-webkit-scrollbar:horizontal{height:6px}.el-input::-webkit-scrollbar-thumb{border-radius:5px;width:6px;background:#b4bccc}.el-input::-webkit-scrollbar-corner,.el-input::-webkit-scrollbar-track{background:#fff}.el-input::-webkit-scrollbar-track-piece{background:#fff;width:6px}.el-input .el-input__clear{color:#c0c4cc;font-size:14px;cursor:pointer;transition:color .2s cubic-bezier(.645,.045,.355,1)}.el-input .el-input__clear:hover{color:#909399}.el-input .el-input__count{height:100%;display:inline-flex;align-items:center;color:#909399;font-size:12px}.el-input .el-input__count .el-input__count-inner{background:#fff;line-height:normal;display:inline-block;padding:0 5px}.el-input__inner{-webkit-appearance:none;background-color:#fff;background-image:none;border-radius:4px;border:1px solid #dcdfe6;box-sizing:border-box;color:#606266;display:inline-block;font-size:inherit;height:40px;line-height:40px;outline:0;padding:0 15px;transition:border-color .2s cubic-bezier(.645,.045,.355,1);width:100%}.el-input__prefix,.el-input__suffix{position:absolute;top:0;-webkit-transition:all .3s;height:100%;color:#c0c4cc;text-align:center}.el-input__inner::-ms-reveal{display:none}.el-input__inner:-ms-input-placeholder{color:#c0c4cc}.el-input__inner::-moz-placeholder{color:#c0c4cc}.el-input__inner::placeholder{color:#c0c4cc}.el-input__inner:hover{border-color:#c0c4cc}.el-input.is-active .el-input__inner,.el-input__inner:focus{border-color:#409eff;outline:0}.el-input__suffix{right:5px;transition:all .3s}.el-input__suffix-inner{pointer-events:all}.el-input__prefix{left:5px;transition:all .3s}.el-input__icon{height:100%;width:25px;text-align:center;transition:all .3s;line-height:40px}.el-input__icon:after{content:"";height:100%;width:0;display:inline-block;vertical-align:middle}.el-input__validateIcon{pointer-events:none}.el-input.is-disabled .el-input__inner{background-color:#f5f7fa;border-color:#e4e7ed;color:#c0c4cc;cursor:not-allowed}.el-input.is-disabled .el-input__inner:-ms-input-placeholder{color:#c0c4cc}.el-input.is-disabled .el-input__inner::-moz-placeholder{color:#c0c4cc}.el-input.is-disabled .el-input__inner::placeholder{color:#c0c4cc}.el-input.is-disabled .el-input__icon{cursor:not-allowed}.el-link,.el-transfer-panel__filter .el-icon-circle-close{cursor:pointer}.el-input.is-exceed .el-input__inner{border-color:#f56c6c}.el-input.is-exceed .el-input__suffix .el-input__count{color:#f56c6c}.el-input--suffix .el-input__inner{padding-right:30px}.el-input--prefix .el-input__inner{padding-left:30px}.el-input--medium{font-size:14px}.el-input--medium .el-input__inner{height:36px;line-height:36px}.el-input--medium .el-input__icon{line-height:36px}.el-input--small{font-size:13px}.el-input--small .el-input__inner{height:32px;line-height:32px}.el-input--small .el-input__icon{line-height:32px}.el-input--mini{font-size:12px}.el-input--mini .el-input__inner{height:28px;line-height:28px}.el-input--mini .el-input__icon{line-height:28px}.el-input-group{line-height:normal;display:inline-table;width:100%;border-collapse:separate;border-spacing:0}.el-input-group>.el-input__inner{vertical-align:middle;display:table-cell}.el-input-group__append,.el-input-group__prepend{background-color:#f5f7fa;color:#909399;vertical-align:middle;display:table-cell;position:relative;border:1px solid #dcdfe6;border-radius:4px;padding:0 20px;width:1px;white-space:nowrap}.el-input-group--prepend .el-input__inner,.el-input-group__append{border-top-left-radius:0;border-bottom-left-radius:0}.el-input-group--append .el-input__inner,.el-input-group__prepend{border-top-right-radius:0;border-bottom-right-radius:0}.el-input-group__append:focus,.el-input-group__prepend:focus{outline:0}.el-input-group__append .el-button,.el-input-group__append .el-select,.el-input-group__prepend .el-button,.el-input-group__prepend .el-select{display:inline-block;margin:-10px -20px}.el-input-group__append button.el-button,.el-input-group__append div.el-select .el-input__inner,.el-input-group__append div.el-select:hover .el-input__inner,.el-input-group__prepend button.el-button,.el-input-group__prepend div.el-select .el-input__inner,.el-input-group__prepend div.el-select:hover .el-input__inner{border-color:transparent;background-color:transparent;color:inherit;border-top:0;border-bottom:0}.el-input-group__append .el-button,.el-input-group__append .el-input,.el-input-group__prepend .el-button,.el-input-group__prepend .el-input{font-size:inherit}.el-input-group__prepend{border-right:0}.el-input-group__append{border-left:0}.el-input-group--append .el-select .el-input.is-focus .el-input__inner,.el-input-group--prepend .el-select .el-input.is-focus .el-input__inner{border-color:transparent}.el-input__inner::-ms-clear{display:none;width:0;height:0}.el-transfer{font-size:14px}.el-transfer__buttons{display:inline-block;vertical-align:middle;padding:0 30px}.el-transfer__button{display:block;margin:0 auto;padding:10px;border-radius:50%;color:#fff;background-color:#409eff;font-size:0}.el-transfer-panel__item+.el-transfer-panel__item,.el-transfer__button [class*=el-icon-]+span{margin-left:0}.el-transfer__button.is-with-texts{border-radius:4px}.el-transfer__button.is-disabled,.el-transfer__button.is-disabled:hover{border:1px solid #dcdfe6;background-color:#f5f7fa;color:#c0c4cc}.el-transfer__button:first-child{margin-bottom:10px}.el-transfer__button:nth-child(2){margin:0}.el-transfer__button i,.el-transfer__button span{font-size:14px}.el-transfer-panel{border:1px solid #ebeef5;border-radius:4px;overflow:hidden;background:#fff;display:inline-block;vertical-align:middle;width:200px;max-height:100%;box-sizing:border-box;position:relative}.el-transfer-panel__body{height:246px}.el-transfer-panel__body.is-with-footer{padding-bottom:40px}.el-transfer-panel__list{margin:0;padding:6px 0;list-style:none;height:246px;overflow:auto;box-sizing:border-box}.el-transfer-panel__list.is-filterable{height:194px;padding-top:0}.el-transfer-panel__item{height:30px;line-height:30px;padding-left:15px;display:block!important}.el-transfer-panel__item.el-checkbox{color:#606266}.el-transfer-panel__item:hover{color:#409eff}.el-transfer-panel__item.el-checkbox .el-checkbox__label{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:block;box-sizing:border-box;padding-left:24px;line-height:30px}.el-transfer-panel__item .el-checkbox__input{position:absolute;top:8px}.el-transfer-panel__filter{text-align:center;margin:15px;box-sizing:border-box;display:block;width:auto}.el-transfer-panel__filter .el-input__inner{height:32px;width:100%;font-size:12px;display:inline-block;box-sizing:border-box;border-radius:16px;padding-right:10px;padding-left:30px}.el-transfer-panel__filter .el-input__icon{margin-left:5px}.el-transfer-panel .el-transfer-panel__header{height:40px;line-height:40px;background:#f5f7fa;margin:0;padding-left:15px;border-bottom:1px solid #ebeef5;box-sizing:border-box;color:#000}.el-transfer-panel .el-transfer-panel__header .el-checkbox{display:block;line-height:40px}.el-transfer-panel .el-transfer-panel__header .el-checkbox .el-checkbox__label{font-size:16px;color:#303133;font-weight:400}.el-transfer-panel .el-transfer-panel__header .el-checkbox .el-checkbox__label span{position:absolute;right:15px;color:#909399;font-size:12px;font-weight:400}.el-divider__text,.el-link{font-weight:500;font-size:14px}.el-transfer-panel .el-transfer-panel__footer{height:40px;background:#fff;margin:0;padding:0;border-top:1px solid #ebeef5;position:absolute;bottom:0;left:0;width:100%;z-index:1}.el-transfer-panel .el-transfer-panel__footer:after{display:inline-block;content:"";height:100%;vertical-align:middle}.el-container,.el-timeline-item__node{display:-ms-flexbox}.el-transfer-panel .el-transfer-panel__footer .el-checkbox{padding-left:20px;color:#606266}.el-transfer-panel .el-transfer-panel__empty{margin:0;height:30px;line-height:30px;padding:6px 15px 0;color:#909399;text-align:center}.el-transfer-panel .el-checkbox__label{padding-left:8px}.el-transfer-panel .el-checkbox__inner{height:14px;width:14px;border-radius:3px}.el-transfer-panel .el-checkbox__inner:after{height:6px;width:3px;left:4px}.el-container{display:flex;flex-direction:row;flex:1;flex-basis:auto;box-sizing:border-box;min-width:0}.el-aside,.el-header{-webkit-box-sizing:border-box}.el-container.is-vertical{flex-direction:column}.el-header{padding:0 20px}.el-aside,.el-header{box-sizing:border-box;flex-shrink:0}.el-aside{overflow:auto}.el-footer,.el-main{-webkit-box-sizing:border-box}.el-main{display:block;flex:1;flex-basis:auto;overflow:auto;padding:20px}.el-footer,.el-main{box-sizing:border-box}.el-footer{padding:0 20px;flex-shrink:0}.el-timeline{margin:0;font-size:14px;list-style:none}.el-timeline .el-timeline-item:last-child .el-timeline-item__tail{display:none}.el-timeline-item{position:relative;padding-bottom:20px}.el-timeline-item__wrapper{position:relative;padding-left:28px;top:-3px}.el-timeline-item__tail{position:absolute;left:4px;height:100%;border-left:2px solid #e4e7ed}.el-timeline-item__icon{color:#fff;font-size:13px}.el-timeline-item__node{position:absolute;background-color:#e4e7ed;border-radius:50%;display:flex;justify-content:center;align-items:center}.el-image__error,.el-timeline-item__dot{display:-ms-flexbox}.el-timeline-item__node--normal{left:-1px;width:12px;height:12px}.el-timeline-item__node--large{left:-2px;width:14px;height:14px}.el-timeline-item__node--primary{background-color:#409eff}.el-timeline-item__node--success{background-color:#67c23a}.el-timeline-item__node--warning{background-color:#e6a23c}.el-timeline-item__node--danger{background-color:#f56c6c}.el-timeline-item__node--info{background-color:#909399}.el-timeline-item__dot{position:absolute;display:flex;justify-content:center;align-items:center}.el-timeline-item__content{color:#303133}.el-timeline-item__timestamp{color:#909399;line-height:1;font-size:13px}.el-timeline-item__timestamp.is-top{margin-bottom:8px;padding-top:4px}.el-timeline-item__timestamp.is-bottom{margin-top:8px}.el-link{display:inline-flex;flex-direction:row;align-items:center;justify-content:center;vertical-align:middle;position:relative;text-decoration:none;outline:0;padding:0}.el-drawer,.el-empty,.el-result{-webkit-box-orient:vertical}.el-link.is-underline:hover:after{content:"";position:absolute;left:0;right:0;height:0;bottom:0;border-bottom:1px solid #409eff}.el-link.el-link--default:after,.el-link.el-link--primary.is-underline:hover:after,.el-link.el-link--primary:after{border-color:#409eff}.el-link.is-disabled{cursor:not-allowed}.el-link [class*=el-icon-]+span{margin-left:5px}.el-link.el-link--default{color:#606266}.el-link.el-link--default:hover{color:#409eff}.el-link.el-link--default.is-disabled{color:#c0c4cc}.el-link.el-link--primary{color:#409eff}.el-link.el-link--primary:hover{color:#66b1ff}.el-link.el-link--primary.is-disabled{color:#a0cfff}.el-link.el-link--danger.is-underline:hover:after,.el-link.el-link--danger:after{border-color:#f56c6c}.el-link.el-link--danger{color:#f56c6c}.el-link.el-link--danger:hover{color:#f78989}.el-link.el-link--danger.is-disabled{color:#fab6b6}.el-link.el-link--success.is-underline:hover:after,.el-link.el-link--success:after{border-color:#67c23a}.el-link.el-link--success{color:#67c23a}.el-link.el-link--success:hover{color:#85ce61}.el-link.el-link--success.is-disabled{color:#b3e19d}.el-link.el-link--warning.is-underline:hover:after,.el-link.el-link--warning:after{border-color:#e6a23c}.el-link.el-link--warning{color:#e6a23c}.el-link.el-link--warning:hover{color:#ebb563}.el-link.el-link--warning.is-disabled{color:#f3d19e}.el-link.el-link--info.is-underline:hover:after,.el-link.el-link--info:after{border-color:#909399}.el-link.el-link--info{color:#909399}.el-link.el-link--info:hover{color:#a6a9ad}.el-link.el-link--info.is-disabled{color:#c8c9cc}.el-divider{background-color:#dcdfe6;position:relative}.el-divider--horizontal{display:block;height:1px;width:100%;margin:24px 0}.el-divider--vertical{display:inline-block;width:1px;height:1em;margin:0 8px;vertical-align:middle;position:relative}.el-divider__text{position:absolute;background-color:#fff;padding:0 20px;color:#303133}.el-image__error,.el-image__placeholder{background:#f5f7fa}.el-divider__text.is-left{left:20px;transform:translateY(-50%)}.el-divider__text.is-center{left:50%;transform:translateX(-50%) translateY(-50%)}.el-divider__text.is-right{right:20px;transform:translateY(-50%)}.el-image__error,.el-image__inner,.el-image__placeholder{width:100%;height:100%}.el-image{position:relative;display:inline-block;overflow:hidden}.el-image__inner{vertical-align:top}.el-image__inner--center{position:relative;top:50%;left:50%;transform:translate(-50%,-50%);display:block}.el-image__error{display:flex;justify-content:center;align-items:center;font-size:14px;color:#c0c4cc;vertical-align:middle}.el-image__preview{cursor:pointer}.el-image-viewer__wrapper{position:fixed;top:0;right:0;bottom:0;left:0}.el-image-viewer__btn{position:absolute;z-index:1;display:flex;align-items:center;justify-content:center;border-radius:50%;opacity:.8;cursor:pointer;box-sizing:border-box;user-select:none}.el-button,.el-checkbox,.el-image-viewer__btn{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none}.el-image-viewer__close{top:40px;right:40px;width:40px;height:40px;font-size:24px;color:#fff;background-color:#606266}.el-image-viewer__canvas{width:100%;height:100%;display:flex;justify-content:center;align-items:center}.el-image-viewer__actions{left:50%;bottom:30px;transform:translateX(-50%);width:282px;height:44px;padding:0 23px;background-color:#606266;border-color:#fff;border-radius:22px}.el-image-viewer__actions__inner{width:100%;height:100%;text-align:justify;cursor:default;font-size:23px;color:#fff;display:flex;align-items:center;justify-content:space-around}.el-image-viewer__next,.el-image-viewer__prev{top:50%;width:44px;height:44px;font-size:24px;color:#fff;background-color:#606266;border-color:#fff}.el-image-viewer__prev{transform:translateY(-50%);left:40px}.el-image-viewer__next{transform:translateY(-50%);right:40px;text-indent:2px}.el-image-viewer__mask{position:absolute;width:100%;height:100%;top:0;left:0;opacity:.5;background:#000}.viewer-fade-enter-active{-webkit-animation:viewer-fade-in .3s;animation:viewer-fade-in .3s}.viewer-fade-leave-active{-webkit-animation:viewer-fade-out .3s;animation:viewer-fade-out .3s}@-webkit-keyframes viewer-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@keyframes viewer-fade-in{0%{transform:translate3d(0,-20px,0);opacity:0}to{transform:translateZ(0);opacity:1}}@-webkit-keyframes viewer-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}@keyframes viewer-fade-out{0%{transform:translateZ(0);opacity:1}to{transform:translate3d(0,-20px,0);opacity:0}}.el-button{display:inline-block;line-height:1;white-space:nowrap;cursor:pointer;background:#fff;border:1px solid #dcdfe6;color:#606266;-webkit-appearance:none;text-align:center;box-sizing:border-box;outline:0;margin:0;transition:.1s;font-weight:500;padding:12px 20px;font-size:14px;border-radius:4px}.el-button+.el-button{margin-left:10px}.el-button:focus,.el-button:hover{color:#409eff;border-color:#c6e2ff;background-color:#ecf5ff}.el-button:active{color:#3a8ee6;border-color:#3a8ee6;outline:0}.el-button::-moz-focus-inner{border:0}.el-button [class*=el-icon-]+span{margin-left:5px}.el-button.is-plain:focus,.el-button.is-plain:hover{background:#fff;border-color:#409eff;color:#409eff}.el-button.is-active,.el-button.is-plain:active{color:#3a8ee6;border-color:#3a8ee6}.el-button.is-plain:active{background:#fff;outline:0}.el-button.is-disabled,.el-button.is-disabled:focus,.el-button.is-disabled:hover{color:#c0c4cc;cursor:not-allowed;background-image:none;background-color:#fff;border-color:#ebeef5}.el-button.is-disabled.el-button--text{background-color:transparent}.el-button.is-disabled.is-plain,.el-button.is-disabled.is-plain:focus,.el-button.is-disabled.is-plain:hover{background-color:#fff;border-color:#ebeef5;color:#c0c4cc}.el-button.is-loading{position:relative;pointer-events:none}.el-button.is-loading:before{pointer-events:none;content:"";position:absolute;left:-1px;top:-1px;right:-1px;bottom:-1px;border-radius:inherit;background-color:hsla(0,0%,100%,.35)}.el-button.is-round{border-radius:20px;padding:12px 23px}.el-button.is-circle{border-radius:50%;padding:12px}.el-button--primary{color:#fff;background-color:#409eff;border-color:#409eff}.el-button--primary:focus,.el-button--primary:hover{background:#66b1ff;border-color:#66b1ff;color:#fff}.el-button--primary.is-active,.el-button--primary:active{background:#3a8ee6;border-color:#3a8ee6;color:#fff}.el-button--primary:active{outline:0}.el-button--primary.is-disabled,.el-button--primary.is-disabled:active,.el-button--primary.is-disabled:focus,.el-button--primary.is-disabled:hover{color:#fff;background-color:#a0cfff;border-color:#a0cfff}.el-button--primary.is-plain{color:#409eff;background:#ecf5ff;border-color:#b3d8ff}.el-button--primary.is-plain:focus,.el-button--primary.is-plain:hover{background:#409eff;border-color:#409eff;color:#fff}.el-button--primary.is-plain:active{background:#3a8ee6;border-color:#3a8ee6;color:#fff;outline:0}.el-button--primary.is-plain.is-disabled,.el-button--primary.is-plain.is-disabled:active,.el-button--primary.is-plain.is-disabled:focus,.el-button--primary.is-plain.is-disabled:hover{color:#8cc5ff;background-color:#ecf5ff;border-color:#d9ecff}.el-button--success{color:#fff;background-color:#67c23a;border-color:#67c23a}.el-button--success:focus,.el-button--success:hover{background:#85ce61;border-color:#85ce61;color:#fff}.el-button--success.is-active,.el-button--success:active{background:#5daf34;border-color:#5daf34;color:#fff}.el-button--success:active{outline:0}.el-button--success.is-disabled,.el-button--success.is-disabled:active,.el-button--success.is-disabled:focus,.el-button--success.is-disabled:hover{color:#fff;background-color:#b3e19d;border-color:#b3e19d}.el-button--success.is-plain{color:#67c23a;background:#f0f9eb;border-color:#c2e7b0}.el-button--success.is-plain:focus,.el-button--success.is-plain:hover{background:#67c23a;border-color:#67c23a;color:#fff}.el-button--success.is-plain:active{background:#5daf34;border-color:#5daf34;color:#fff;outline:0}.el-button--success.is-plain.is-disabled,.el-button--success.is-plain.is-disabled:active,.el-button--success.is-plain.is-disabled:focus,.el-button--success.is-plain.is-disabled:hover{color:#a4da89;background-color:#f0f9eb;border-color:#e1f3d8}.el-button--warning{color:#fff;background-color:#e6a23c;border-color:#e6a23c}.el-button--warning:focus,.el-button--warning:hover{background:#ebb563;border-color:#ebb563;color:#fff}.el-button--warning.is-active,.el-button--warning:active{background:#cf9236;border-color:#cf9236;color:#fff}.el-button--warning:active{outline:0}.el-button--warning.is-disabled,.el-button--warning.is-disabled:active,.el-button--warning.is-disabled:focus,.el-button--warning.is-disabled:hover{color:#fff;background-color:#f3d19e;border-color:#f3d19e}.el-button--warning.is-plain{color:#e6a23c;background:#fdf6ec;border-color:#f5dab1}.el-button--warning.is-plain:focus,.el-button--warning.is-plain:hover{background:#e6a23c;border-color:#e6a23c;color:#fff}.el-button--warning.is-plain:active{background:#cf9236;border-color:#cf9236;color:#fff;outline:0}.el-button--warning.is-plain.is-disabled,.el-button--warning.is-plain.is-disabled:active,.el-button--warning.is-plain.is-disabled:focus,.el-button--warning.is-plain.is-disabled:hover{color:#f0c78a;background-color:#fdf6ec;border-color:#faecd8}.el-button--danger{color:#fff;background-color:#f56c6c;border-color:#f56c6c}.el-button--danger:focus,.el-button--danger:hover{background:#f78989;border-color:#f78989;color:#fff}.el-button--danger.is-active,.el-button--danger:active{background:#dd6161;border-color:#dd6161;color:#fff}.el-button--danger:active{outline:0}.el-button--danger.is-disabled,.el-button--danger.is-disabled:active,.el-button--danger.is-disabled:focus,.el-button--danger.is-disabled:hover{color:#fff;background-color:#fab6b6;border-color:#fab6b6}.el-button--danger.is-plain{color:#f56c6c;background:#fef0f0;border-color:#fbc4c4}.el-button--danger.is-plain:focus,.el-button--danger.is-plain:hover{background:#f56c6c;border-color:#f56c6c;color:#fff}.el-button--danger.is-plain:active{background:#dd6161;border-color:#dd6161;color:#fff;outline:0}.el-button--danger.is-plain.is-disabled,.el-button--danger.is-plain.is-disabled:active,.el-button--danger.is-plain.is-disabled:focus,.el-button--danger.is-plain.is-disabled:hover{color:#f9a7a7;background-color:#fef0f0;border-color:#fde2e2}.el-button--info{color:#fff;background-color:#909399;border-color:#909399}.el-button--info:focus,.el-button--info:hover{background:#a6a9ad;border-color:#a6a9ad;color:#fff}.el-button--info.is-active,.el-button--info:active{background:#82848a;border-color:#82848a;color:#fff}.el-button--info:active{outline:0}.el-button--info.is-disabled,.el-button--info.is-disabled:active,.el-button--info.is-disabled:focus,.el-button--info.is-disabled:hover{color:#fff;background-color:#c8c9cc;border-color:#c8c9cc}.el-button--info.is-plain{color:#909399;background:#f4f4f5;border-color:#d3d4d6}.el-button--info.is-plain:focus,.el-button--info.is-plain:hover{background:#909399;border-color:#909399;color:#fff}.el-button--info.is-plain:active{background:#82848a;border-color:#82848a;color:#fff;outline:0}.el-button--info.is-plain.is-disabled,.el-button--info.is-plain.is-disabled:active,.el-button--info.is-plain.is-disabled:focus,.el-button--info.is-plain.is-disabled:hover{color:#bcbec2;background-color:#f4f4f5;border-color:#e9e9eb}.el-button--text,.el-button--text.is-disabled,.el-button--text.is-disabled:focus,.el-button--text.is-disabled:hover,.el-button--text:active{border-color:transparent}.el-button--medium{padding:10px 20px;font-size:14px;border-radius:4px}.el-button--mini,.el-button--small{font-size:12px;border-radius:3px}.el-button--medium.is-round{padding:10px 20px}.el-button--medium.is-circle{padding:10px}.el-button--small,.el-button--small.is-round{padding:9px 15px}.el-button--small.is-circle{padding:9px}.el-button--mini,.el-button--mini.is-round{padding:7px 15px}.el-button--mini.is-circle{padding:7px}.el-button--text{color:#409eff;background:0 0;padding-left:0;padding-right:0}.el-button--text:focus,.el-button--text:hover{color:#66b1ff;border-color:transparent;background-color:transparent}.el-button--text:active{color:#3a8ee6;background-color:transparent}.el-button-group{display:inline-block;vertical-align:middle}.el-button-group:after,.el-button-group:before{display:table;content:""}.el-button-group:after{clear:both}.el-button-group>.el-button{float:left;position:relative}.el-button-group>.el-button+.el-button{margin-left:0}.el-button-group>.el-button.is-disabled{z-index:1}.el-button-group>.el-button:first-child{border-top-right-radius:0;border-bottom-right-radius:0}.el-button-group>.el-button:last-child{border-top-left-radius:0;border-bottom-left-radius:0}.el-button-group>.el-button:first-child:last-child{border-radius:4px}.el-button-group>.el-button:first-child:last-child.is-round{border-radius:20px}.el-button-group>.el-button:first-child:last-child.is-circle{border-radius:50%}.el-button-group>.el-button:not(:first-child):not(:last-child){border-radius:0}.el-button-group>.el-button:not(:last-child){margin-right:-1px}.el-button-group>.el-button.is-active,.el-button-group>.el-button:not(.is-disabled):active,.el-button-group>.el-button:not(.is-disabled):focus,.el-button-group>.el-button:not(.is-disabled):hover{z-index:1}.el-button-group>.el-dropdown>.el-button{border-top-left-radius:0;border-bottom-left-radius:0;border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--primary:first-child{border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--primary:last-child{border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--primary:not(:first-child):not(:last-child){border-left-color:hsla(0,0%,100%,.5);border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--success:first-child{border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--success:last-child{border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--success:not(:first-child):not(:last-child){border-left-color:hsla(0,0%,100%,.5);border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--warning:first-child{border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--warning:last-child{border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--warning:not(:first-child):not(:last-child){border-left-color:hsla(0,0%,100%,.5);border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--danger:first-child{border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--danger:last-child{border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--danger:not(:first-child):not(:last-child){border-left-color:hsla(0,0%,100%,.5);border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--info:first-child{border-right-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--info:last-child{border-left-color:hsla(0,0%,100%,.5)}.el-button-group .el-button--info:not(:first-child):not(:last-child){border-left-color:hsla(0,0%,100%,.5);border-right-color:hsla(0,0%,100%,.5)}.el-calendar{background-color:#fff}.el-calendar__header{display:flex;justify-content:space-between;padding:12px 20px;border-bottom:1px solid #ebeef5}.el-backtop,.el-page-header{display:-ms-flexbox}.el-calendar__title{color:#000;align-self:center}.el-calendar__body{padding:12px 20px 35px}.el-calendar-table{table-layout:fixed;width:100%}.el-calendar-table thead th{padding:12px 0;color:#606266;font-weight:400}.el-calendar-table:not(.is-range) td.next,.el-calendar-table:not(.is-range) td.prev{color:#c0c4cc}.el-backtop,.el-calendar-table td.is-today{color:#409eff}.el-calendar-table td{border-bottom:1px solid #ebeef5;border-right:1px solid #ebeef5;vertical-align:top;transition:background-color .2s ease}.el-calendar-table td.is-selected{background-color:#f2f8fe}.el-calendar-table tr:first-child td{border-top:1px solid #ebeef5}.el-calendar-table tr td:first-child{border-left:1px solid #ebeef5}.el-calendar-table tr.el-calendar-table__row--hide-border td{border-top:none}.el-calendar-table .el-calendar-day{box-sizing:border-box;padding:8px;height:85px}.el-calendar-table .el-calendar-day:hover{cursor:pointer;background-color:#f2f8fe}.el-backtop{position:fixed;background-color:#fff;width:40px;height:40px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:20px;box-shadow:0 0 6px rgba(0,0,0,.12);cursor:pointer;z-index:5}.el-backtop:hover{background-color:#f2f6fc}.el-page-header{display:flex;line-height:24px}.el-page-header__left{display:flex;cursor:pointer;margin-right:40px;position:relative}.el-page-header__left:after{content:"";position:absolute;width:1px;height:16px;right:-20px;top:50%;transform:translateY(-50%);background-color:#dcdfe6}.el-checkbox,.el-checkbox__input{display:inline-block;position:relative;white-space:nowrap}.el-page-header__left .el-icon-back{font-size:18px;margin-right:6px;align-self:center}.el-page-header__title{font-size:14px;font-weight:500}.el-page-header__content{font-size:18px;color:#303133}.el-checkbox{color:#606266;font-weight:500;font-size:14px;cursor:pointer;user-select:none;margin-right:30px}.el-checkbox,.el-checkbox-button__inner,.el-empty__image img,.el-radio{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none}.el-checkbox.is-bordered{padding:9px 20px 9px 10px;border-radius:4px;border:1px solid #dcdfe6;box-sizing:border-box;line-height:normal;height:40px}.el-checkbox.is-bordered.is-checked{border-color:#409eff}.el-checkbox.is-bordered.is-disabled{border-color:#ebeef5;cursor:not-allowed}.el-checkbox.is-bordered+.el-checkbox.is-bordered{margin-left:10px}.el-checkbox.is-bordered.el-checkbox--medium{padding:7px 20px 7px 10px;border-radius:4px;height:36px}.el-checkbox.is-bordered.el-checkbox--medium .el-checkbox__label{line-height:17px;font-size:14px}.el-checkbox.is-bordered.el-checkbox--medium .el-checkbox__inner{height:14px;width:14px}.el-checkbox.is-bordered.el-checkbox--small{padding:5px 15px 5px 10px;border-radius:3px;height:32px}.el-checkbox.is-bordered.el-checkbox--small .el-checkbox__label{line-height:15px;font-size:12px}.el-checkbox.is-bordered.el-checkbox--small .el-checkbox__inner{height:12px;width:12px}.el-checkbox.is-bordered.el-checkbox--small .el-checkbox__inner:after{height:6px;width:2px}.el-checkbox.is-bordered.el-checkbox--mini{padding:3px 15px 3px 10px;border-radius:3px;height:28px}.el-checkbox.is-bordered.el-checkbox--mini .el-checkbox__label{line-height:12px;font-size:12px}.el-checkbox.is-bordered.el-checkbox--mini .el-checkbox__inner{height:12px;width:12px}.el-checkbox.is-bordered.el-checkbox--mini .el-checkbox__inner:after{height:6px;width:2px}.el-checkbox__input{cursor:pointer;outline:0;line-height:1;vertical-align:middle}.el-checkbox__input.is-disabled .el-checkbox__inner{background-color:#edf2fc;border-color:#dcdfe6;cursor:not-allowed}.el-checkbox__input.is-disabled .el-checkbox__inner:after{cursor:not-allowed;border-color:#c0c4cc}.el-checkbox__input.is-disabled .el-checkbox__inner+.el-checkbox__label{cursor:not-allowed}.el-checkbox__input.is-disabled.is-checked .el-checkbox__inner{background-color:#f2f6fc;border-color:#dcdfe6}.el-checkbox__input.is-disabled.is-checked .el-checkbox__inner:after{border-color:#c0c4cc}.el-checkbox__input.is-disabled.is-indeterminate .el-checkbox__inner{background-color:#f2f6fc;border-color:#dcdfe6}.el-checkbox__input.is-disabled.is-indeterminate .el-checkbox__inner:before{background-color:#c0c4cc;border-color:#c0c4cc}.el-checkbox__input.is-checked .el-checkbox__inner,.el-checkbox__input.is-indeterminate .el-checkbox__inner{background-color:#409eff;border-color:#409eff}.el-checkbox__input.is-disabled+span.el-checkbox__label{color:#c0c4cc;cursor:not-allowed}.el-checkbox__input.is-checked .el-checkbox__inner:after{transform:rotate(45deg) scaleY(1)}.el-checkbox__input.is-checked+.el-checkbox__label{color:#409eff}.el-checkbox__input.is-focus .el-checkbox__inner{border-color:#409eff}.el-checkbox__input.is-indeterminate .el-checkbox__inner:before{content:"";position:absolute;display:block;background-color:#fff;height:2px;transform:scale(.5);left:0;right:0;top:5px}.el-checkbox__input.is-indeterminate .el-checkbox__inner:after{display:none}.el-checkbox__inner{display:inline-block;position:relative;border:1px solid #dcdfe6;border-radius:2px;box-sizing:border-box;width:14px;height:14px;background-color:#fff;z-index:1;transition:border-color .25s cubic-bezier(.71,-.46,.29,1.46),background-color .25s cubic-bezier(.71,-.46,.29,1.46)}.el-checkbox__inner:hover{border-color:#409eff}.el-checkbox__inner:after{box-sizing:content-box;content:"";border:1px solid #fff;border-left:0;border-top:0;height:7px;left:4px;position:absolute;top:1px;transform:rotate(45deg) scaleY(0);width:3px;transition:transform .15s ease-in .05s;transform-origin:center}.el-checkbox__original{opacity:0;outline:0;position:absolute;margin:0;width:0;height:0;z-index:-1}.el-checkbox-button,.el-checkbox-button__inner{display:inline-block;position:relative}.el-checkbox__label{display:inline-block;padding-left:10px;line-height:19px;font-size:14px}.el-checkbox:last-of-type{margin-right:0}.el-checkbox-button__inner{line-height:1;font-weight:500;white-space:nowrap;vertical-align:middle;cursor:pointer;background:#fff;border:1px solid #dcdfe6;border-left:0;color:#606266;-webkit-appearance:none;text-align:center;box-sizing:border-box;outline:0;margin:0;transition:all .3s cubic-bezier(.645,.045,.355,1);padding:12px 20px;font-size:14px;border-radius:0}.el-checkbox-button__inner.is-round{padding:12px 20px}.el-checkbox-button__inner:hover{color:#409eff}.el-checkbox-button__inner [class*=el-icon-]{line-height:.9}.el-radio,.el-radio__input{line-height:1;white-space:nowrap;outline:0}.el-checkbox-button__inner [class*=el-icon-]+span{margin-left:5px}.el-checkbox-button__original{opacity:0;outline:0;position:absolute;margin:0;z-index:-1}.el-radio,.el-radio__inner,.el-radio__input{position:relative;display:inline-block}.el-checkbox-button.is-checked .el-checkbox-button__inner{color:#fff;background-color:#409eff;border-color:#409eff;box-shadow:-1px 0 0 0 #8cc5ff}.el-checkbox-button.is-checked:first-child .el-checkbox-button__inner{border-left-color:#409eff}.el-checkbox-button.is-disabled .el-checkbox-button__inner{color:#c0c4cc;cursor:not-allowed;background-image:none;background-color:#fff;border-color:#ebeef5;box-shadow:none}.el-checkbox-button.is-disabled:first-child .el-checkbox-button__inner{border-left-color:#ebeef5}.el-checkbox-button:first-child .el-checkbox-button__inner{border-left:1px solid #dcdfe6;border-radius:4px 0 0 4px;box-shadow:none!important}.el-checkbox-button.is-focus .el-checkbox-button__inner{border-color:#409eff}.el-checkbox-button:last-child .el-checkbox-button__inner{border-radius:0 4px 4px 0}.el-checkbox-button--medium .el-checkbox-button__inner{padding:10px 20px;font-size:14px;border-radius:0}.el-checkbox-button--medium .el-checkbox-button__inner.is-round{padding:10px 20px}.el-checkbox-button--small .el-checkbox-button__inner{padding:9px 15px;font-size:12px;border-radius:0}.el-checkbox-button--small .el-checkbox-button__inner.is-round{padding:9px 15px}.el-checkbox-button--mini .el-checkbox-button__inner{padding:7px 15px;font-size:12px;border-radius:0}.el-checkbox-button--mini .el-checkbox-button__inner.is-round{padding:7px 15px}.el-checkbox-group{font-size:0}.el-radio,.el-radio--medium.is-bordered .el-radio__label{font-size:14px}.el-radio{color:#606266;font-weight:500;cursor:pointer;margin-right:30px}.el-cascader-node>.el-radio,.el-radio:last-child{margin-right:0}.el-radio.is-bordered{padding:12px 20px 0 10px;border-radius:4px;border:1px solid #dcdfe6;box-sizing:border-box;height:40px}.el-radio.is-bordered.is-checked{border-color:#409eff}.el-radio.is-bordered.is-disabled{cursor:not-allowed;border-color:#ebeef5}.el-radio__input.is-disabled .el-radio__inner,.el-radio__input.is-disabled.is-checked .el-radio__inner{background-color:#f5f7fa;border-color:#e4e7ed}.el-radio.is-bordered+.el-radio.is-bordered{margin-left:10px}.el-radio--medium.is-bordered{padding:10px 20px 0 10px;border-radius:4px;height:36px}.el-radio--mini.is-bordered .el-radio__label,.el-radio--small.is-bordered .el-radio__label{font-size:12px}.el-radio--medium.is-bordered .el-radio__inner{height:14px;width:14px}.el-radio--small.is-bordered{padding:8px 15px 0 10px;border-radius:3px;height:32px}.el-radio--small.is-bordered .el-radio__inner{height:12px;width:12px}.el-radio--mini.is-bordered{padding:6px 15px 0 10px;border-radius:3px;height:28px}.el-radio--mini.is-bordered .el-radio__inner{height:12px;width:12px}.el-radio__input{cursor:pointer;vertical-align:middle}.el-radio__input.is-disabled .el-radio__inner{cursor:not-allowed}.el-radio__input.is-disabled .el-radio__inner:after{cursor:not-allowed;background-color:#f5f7fa}.el-radio__input.is-disabled .el-radio__inner+.el-radio__label{cursor:not-allowed}.el-radio__input.is-disabled.is-checked .el-radio__inner:after{background-color:#c0c4cc}.el-radio__input.is-disabled+span.el-radio__label{color:#c0c4cc;cursor:not-allowed}.el-radio__input.is-checked .el-radio__inner{border-color:#409eff;background:#409eff}.el-radio__input.is-checked .el-radio__inner:after{transform:translate(-50%,-50%) scale(1)}.el-radio__input.is-checked+.el-radio__label{color:#409eff}.el-radio__input.is-focus .el-radio__inner{border-color:#409eff}.el-radio__inner{border:1px solid #dcdfe6;border-radius:100%;width:14px;height:14px;background-color:#fff;cursor:pointer;box-sizing:border-box}.el-radio__inner:hover{border-color:#409eff}.el-radio__inner:after{width:4px;height:4px;border-radius:100%;background-color:#fff;content:"";position:absolute;left:50%;top:50%;transform:translate(-50%,-50%) scale(0);transition:transform .15s ease-in}.el-radio__original{opacity:0;outline:0;position:absolute;z-index:-1;top:0;left:0;right:0;bottom:0;margin:0}.el-radio:focus:not(.is-focus):not(:active):not(.is-disabled) .el-radio__inner{box-shadow:0 0 2px 2px #409eff}.el-radio__label{font-size:14px;padding-left:10px}.el-scrollbar{overflow:hidden;position:relative}.el-scrollbar:active>.el-scrollbar__bar,.el-scrollbar:focus>.el-scrollbar__bar,.el-scrollbar:hover>.el-scrollbar__bar{opacity:1;transition:opacity .34s ease-out}.el-scrollbar__wrap{overflow:scroll;height:100%}.el-scrollbar__wrap--hidden-default{scrollbar-width:none}.el-scrollbar__wrap--hidden-default::-webkit-scrollbar{width:0;height:0}.el-scrollbar__thumb{position:relative;display:block;width:0;height:0;cursor:pointer;border-radius:inherit;background-color:rgba(144,147,153,.3);transition:background-color .3s}.el-scrollbar__thumb:hover{background-color:rgba(144,147,153,.5)}.el-scrollbar__bar{position:absolute;right:2px;bottom:2px;z-index:1;border-radius:4px;opacity:0;transition:opacity .12s ease-out}.el-scrollbar__bar.is-vertical{width:6px;top:2px}.el-scrollbar__bar.is-vertical>div{width:100%}.el-scrollbar__bar.is-horizontal{height:6px;left:2px}.el-scrollbar__bar.is-horizontal>div{height:100%}.el-cascader-panel{display:flex;border-radius:4px;font-size:14px}.el-cascader-panel.is-bordered{border:1px solid #e4e7ed;border-radius:4px}.el-cascader-menu{min-width:180px;box-sizing:border-box;color:#606266;border-right:1px solid #e4e7ed}.el-cascader-menu:last-child{border-right:none}.el-cascader-menu:last-child .el-cascader-node{padding-right:20px}.el-cascader-menu__wrap{height:204px}.el-cascader-menu__list{position:relative;min-height:100%;margin:0;padding:6px 0;list-style:none;box-sizing:border-box}.el-avatar,.el-drawer{-webkit-box-sizing:border-box;overflow:hidden}.el-cascader-menu__hover-zone{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none}.el-cascader-menu__empty-text{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);text-align:center;color:#c0c4cc}.el-cascader-node{position:relative;display:flex;align-items:center;padding:0 30px 0 20px;height:34px;line-height:34px;outline:0}.el-cascader-node.is-selectable.in-active-path{color:#606266}.el-cascader-node.in-active-path,.el-cascader-node.is-active,.el-cascader-node.is-selectable.in-checked-path{color:#409eff;font-weight:700}.el-cascader-node:not(.is-disabled){cursor:pointer}.el-cascader-node:not(.is-disabled):focus,.el-cascader-node:not(.is-disabled):hover{background:#f5f7fa}.el-cascader-node.is-disabled{color:#c0c4cc;cursor:not-allowed}.el-cascader-node__prefix{position:absolute;left:10px}.el-cascader-node__postfix{position:absolute;right:10px}.el-cascader-node__label{flex:1;padding:0 10px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.el-cascader-node>.el-radio .el-radio__label{padding-left:0}.el-avatar{display:inline-block;box-sizing:border-box;text-align:center;color:#fff;background:#c0c4cc;width:40px;height:40px;line-height:40px;font-size:14px}.el-avatar>img{display:block;height:100%;vertical-align:middle}.el-drawer,.el-drawer__header{display:-ms-flexbox}.el-empty__image img,.el-empty__image svg{vertical-align:top;height:100%;width:100%}.el-avatar--circle{border-radius:50%}.el-avatar--square{border-radius:4px}.el-avatar--icon{font-size:18px}.el-avatar--large{width:40px;height:40px;line-height:40px}.el-avatar--medium{width:36px;height:36px;line-height:36px}.el-avatar--small{width:28px;height:28px;line-height:28px}.el-drawer.ltr,.el-drawer.rtl,.el-drawer__container{top:0;bottom:0;height:100%}@-webkit-keyframes el-drawer-fade-in{0%{opacity:0}to{opacity:1}}@keyframes el-drawer-fade-in{0%{opacity:0}to{opacity:1}}@-webkit-keyframes rtl-drawer-in{0%{transform:translate(100%)}to{transform:translate(0)}}@keyframes rtl-drawer-in{0%{transform:translate(100%)}to{transform:translate(0)}}@-webkit-keyframes rtl-drawer-out{0%{transform:translate(0)}to{transform:translate(100%)}}@keyframes rtl-drawer-out{0%{transform:translate(0)}to{transform:translate(100%)}}@-webkit-keyframes ltr-drawer-in{0%{transform:translate(-100%)}to{transform:translate(0)}}@keyframes ltr-drawer-in{0%{transform:translate(-100%)}to{transform:translate(0)}}@-webkit-keyframes ltr-drawer-out{0%{transform:translate(0)}to{transform:translate(-100%)}}@keyframes ltr-drawer-out{0%{transform:translate(0)}to{transform:translate(-100%)}}@-webkit-keyframes ttb-drawer-in{0%{transform:translateY(-100%)}to{transform:translate(0)}}@keyframes ttb-drawer-in{0%{transform:translateY(-100%)}to{transform:translate(0)}}@-webkit-keyframes ttb-drawer-out{0%{transform:translate(0)}to{transform:translateY(-100%)}}@keyframes ttb-drawer-out{0%{transform:translate(0)}to{transform:translateY(-100%)}}@-webkit-keyframes btt-drawer-in{0%{transform:translateY(100%)}to{transform:translate(0)}}@keyframes btt-drawer-in{0%{transform:translateY(100%)}to{transform:translate(0)}}@-webkit-keyframes btt-drawer-out{0%{transform:translate(0)}to{transform:translateY(100%)}}@keyframes btt-drawer-out{0%{transform:translate(0)}to{transform:translateY(100%)}}.el-drawer{position:absolute;box-sizing:border-box;background-color:#fff;display:flex;flex-direction:column;box-shadow:0 8px 10px -5px rgba(0,0,0,.2),0 16px 24px 2px rgba(0,0,0,.14),0 6px 30px 5px rgba(0,0,0,.12);outline:0}.el-drawer__body>*,.el-empty{-webkit-box-sizing:border-box}.el-drawer.rtl{-webkit-animation:rtl-drawer-out .3s;animation:rtl-drawer-out .3s;right:0}.el-drawer__open .el-drawer.rtl{-webkit-animation:rtl-drawer-in .3s 1ms;animation:rtl-drawer-in .3s 1ms}.el-drawer.ltr{-webkit-animation:ltr-drawer-out .3s;animation:ltr-drawer-out .3s;left:0}.el-drawer__open .el-drawer.ltr{-webkit-animation:ltr-drawer-in .3s 1ms;animation:ltr-drawer-in .3s 1ms}.el-drawer.ttb{-webkit-animation:ttb-drawer-out .3s;animation:ttb-drawer-out .3s;top:0}.el-drawer__open .el-drawer.ttb{-webkit-animation:ttb-drawer-in .3s 1ms;animation:ttb-drawer-in .3s 1ms}.el-drawer.btt{-webkit-animation:btt-drawer-out .3s;animation:btt-drawer-out .3s;bottom:0}.el-drawer__open .el-drawer.btt{-webkit-animation:btt-drawer-in .3s 1ms;animation:btt-drawer-in .3s 1ms}.el-drawer__wrapper{position:fixed;top:0;right:0;bottom:0;left:0;overflow:hidden;margin:0}.el-drawer__header{align-items:center;color:#72767b;display:flex;margin-bottom:32px;padding:20px 20px 0}.el-drawer__header>:first-child{flex:1}.el-drawer__title{margin:0;flex:1;line-height:inherit;font-size:1rem}.el-drawer__close-btn{border:none;cursor:pointer;font-size:20px;color:inherit;background-color:transparent}.el-drawer__body{flex:1;overflow:auto}.el-drawer__body>*{box-sizing:border-box}.el-drawer.btt,.el-drawer.ttb,.el-drawer__container{width:100%;left:0;right:0}.el-drawer__container{position:relative}.el-drawer-fade-enter-active{-webkit-animation:el-drawer-fade-in .3s;animation:el-drawer-fade-in .3s}.el-drawer-fade-leave-active{animation:el-drawer-fade-in .3s reverse}.el-popconfirm__main{display:flex;align-items:center}.el-popconfirm__icon{margin-right:5px}.el-popconfirm__action{text-align:right;margin:0}@-webkit-keyframes el-skeleton-loading{0%{background-position:100% 50%}to{background-position:0 50%}}@keyframes el-skeleton-loading{0%{background-position:100% 50%}to{background-position:0 50%}}.el-skeleton{width:100%}.el-skeleton__first-line,.el-skeleton__paragraph{height:16px;margin-top:16px;background:#f2f2f2}.el-skeleton.is-animated .el-skeleton__item{background:linear-gradient(90deg,#f2f2f2 25%,#e6e6e6 37%,#f2f2f2 63%);background-size:400% 100%;-webkit-animation:el-skeleton-loading 1.4s ease infinite;animation:el-skeleton-loading 1.4s ease infinite}.el-skeleton__item{background:#f2f2f2;display:inline-block;height:16px;border-radius:4px;width:100%}.el-empty,.el-skeleton__image{display:-ms-flexbox}.el-skeleton__circle{border-radius:50%;width:36px;height:36px;line-height:36px}.el-skeleton__circle--lg{width:40px;height:40px;line-height:40px}.el-skeleton__circle--md{width:28px;height:28px;line-height:28px}.el-skeleton__button{height:40px;width:64px;border-radius:4px}.el-skeleton__p{width:100%}.el-skeleton__p.is-last{width:61%}.el-skeleton__p.is-first{width:33%}.el-skeleton__text{width:100%;height:13px}.el-skeleton__caption{height:12px}.el-skeleton__h1{height:20px}.el-skeleton__h3{height:18px}.el-skeleton__h5{height:16px}.el-skeleton__image{width:unset;display:flex;align-items:center;justify-content:center;border-radius:0}.el-skeleton__image svg{fill:#dcdde0;width:22%;height:22%}.el-empty{display:flex;justify-content:center;align-items:center;flex-direction:column;text-align:center;box-sizing:border-box;padding:40px 0}.el-empty__image{width:160px}.el-empty__image img{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-o-object-fit:contain;object-fit:contain}.el-empty__image svg{fill:#dcdde0}.el-empty__description{margin-top:20px}.el-empty__description p{margin:0;font-size:14px;color:#909399}.el-empty__bottom,.el-result__title{margin-top:20px}.el-descriptions{box-sizing:border-box;font-size:14px;color:#303133}.el-descriptions__header{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px}.el-descriptions__title{font-size:16px;font-weight:700}.el-descriptions--mini,.el-descriptions--small{font-size:12px}.el-descriptions__body{color:#606266;background-color:#fff}.el-descriptions__body .el-descriptions__table{border-collapse:collapse;width:100%;table-layout:fixed}.el-descriptions__body .el-descriptions__table .el-descriptions-item__cell{box-sizing:border-box;text-align:left;font-weight:400;line-height:1.5}.el-descriptions__body .el-descriptions__table .el-descriptions-item__cell.is-left{text-align:left}.el-descriptions__body .el-descriptions__table .el-descriptions-item__cell.is-center{text-align:center}.el-descriptions__body .el-descriptions__table .el-descriptions-item__cell.is-right{text-align:right}.el-descriptions .is-bordered{table-layout:auto}.el-descriptions .is-bordered .el-descriptions-item__cell{border:1px solid #ebeef5;padding:12px 10px}.el-descriptions :not(.is-bordered) .el-descriptions-item__cell{padding-bottom:12px}.el-descriptions--medium.is-bordered .el-descriptions-item__cell{padding:10px}.el-descriptions--medium:not(.is-bordered) .el-descriptions-item__cell{padding-bottom:10px}.el-descriptions--small.is-bordered .el-descriptions-item__cell{padding:8px 10px}.el-descriptions--small:not(.is-bordered) .el-descriptions-item__cell{padding-bottom:8px}.el-descriptions--mini.is-bordered .el-descriptions-item__cell{padding:6px 10px}.el-descriptions--mini:not(.is-bordered) .el-descriptions-item__cell{padding-bottom:6px}.el-descriptions-item__container{display:flex}.el-descriptions-item__label.has-colon:after{content:":";position:relative;top:-.5px}.el-descriptions-item__label.is-bordered-label{font-weight:700;color:#909399;background:#fafafa}.el-descriptions-item__label:not(.is-bordered-label){margin-right:10px}.el-result{display:flex;justify-content:center;align-items:center;flex-direction:column;text-align:center;box-sizing:border-box;padding:40px 30px}.el-result__icon svg{width:64px;height:64px}.el-result__title p{margin:0;font-size:20px;color:#303133;line-height:1.3}.el-result__subtitle{margin-top:10px}.el-result__subtitle p{margin:0;font-size:14px;color:#606266;line-height:1.3}.el-result__extra{margin-top:30px}.el-result .icon-success{fill:#67c23a}.el-result .icon-error{fill:#f56c6c}.el-result .icon-info{fill:#909399}.el-result .icon-warning{fill:#e6a23c} \ No newline at end of file diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/favicon.ico b/src/main/resources/com/fr/plugin/sxka/sso/registe/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..df36fcfb72584e00488330b560ebcf34a41c64c2 GIT binary patch literal 4286 zcmds*O-Phc6o&64GDVCEQHxsW(p4>LW*W<827=Unuo8sGpRux(DN@jWP-e29Wl%wj zY84_aq9}^Am9-cWTD5GGEo#+5Fi2wX_P*bo+xO!)p*7B;iKlbFd(U~_d(U?#hLj56 zPhFkj-|A6~Qk#@g^#D^U0XT1cu=c-vu1+SElX9NR;kzAUV(q0|dl0|%h|dI$%VICy zJnu2^L*Te9JrJMGh%-P79CL0}dq92RGU6gI{v2~|)p}sG5x0U*z<8U;Ij*hB9z?ei z@g6Xq-pDoPl=MANPiR7%172VA%r)kevtV-_5H*QJKFmd;8yA$98zCxBZYXTNZ#QFk2(TX0;Y2dt&WitL#$96|gJY=3xX zpCoi|YNzgO3R`f@IiEeSmKrPSf#h#Qd<$%Ej^RIeeYfsxhPMOG`S`Pz8q``=511zm zAm)MX5AV^5xIWPyEu7u>qYs?pn$I4nL9J!=K=SGlKLXpE<5x+2cDTXq?brj?n6sp= zphe9;_JHf40^9~}9i08r{XM$7HB!`{Ys~TK0kx<}ZQng`UPvH*11|q7&l9?@FQz;8 zx!=3<4seY*%=OlbCbcae?5^V_}*K>Uo6ZWV8mTyE^B=DKy7-sdLYkR5Z?paTgK-zyIkKjIcpyO z{+uIt&YSa_$QnN_@t~L014dyK(fOOo+W*MIxbA6Ndgr=Y!f#Tokqv}n<7-9qfHkc3 z=>a|HWqcX8fzQCT=dqVbogRq!-S>H%yA{1w#2Pn;=e>JiEj7Hl;zdt-2f+j2%DeVD zsW0Ab)ZK@0cIW%W7z}H{&~yGhn~D;aiP4=;m-HCo`BEI+Kd6 z={Xwx{TKxD#iCLfl2vQGDitKtN>z|-AdCN|$jTFDg0m3O`WLD4_s#$S literal 0 HcmV?d00001 diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/fonts/element-icons.535877f5.woff b/src/main/resources/com/fr/plugin/sxka/sso/registe/fonts/element-icons.535877f5.woff new file mode 100644 index 0000000000000000000000000000000000000000..02b9a2539e425a7a8c244faba92527602be76212 GIT binary patch literal 28200 zcmY(IQ*>obw1wkzY}@FV9ou%twr$%sPI!WjZQD-Aw(aEhfA7;>W6ZI?HTS9-^|Y(@ zDt85OaS%|De_=-r0{7o@E#?36|M>rhgo>Il2ngtpe=h4k3DwAvi$RS|K+0p zq|S#a)oE;N=LIoGXa4i@|K$Y#L=L?Lk!4});_=Vx{g-2afIyi18w6rwZ~R}~Ul0&5 zw*TZCR$*Xk=<#nZQ}}=$p z3j%@wci;?(=aFMWSW#Pr zM-sk`m0uq8xYb`Cmsw(7J!k}vp6qi1VS~jP7&6A5mE-EG{5)pI7l~c<3JjAJf7Ao{ z%?06O$C!E2hN3FRmRCu5Ow%tiyBh2ns`-x@zc75e`(i)8rv=+je8;kh-i@>exF|8Zoy0d%E ze^yR-Rn9=!jEdV-)~sl5yJK;fvbNWAZT=0qvKdpinc}dSaI={~ycm_gm}Gd^0er~R z)M9-DIXmj{IvSw8>#@8WklyP7dhek4qeA$TB>3Zo_|qu(V@mi_%=j`yUn2T(`yTQ; zqHm61jJ91ll zVp~T9dV8jNyJ~v-x_ZZaTgTx12W0$5X#9t){Ks&gcFBydQ8lk&_OJ3ir{DE4*RO$x zAEV#D`xGh<%>8yX{Px|y4AcrzlvS)!*GlBewa-%DN&>&QaZ`s&q%5_vQjbc+EH$-K z*`?3tfsOQ+56~*ljNeyZ-{0)jU)J+W*Qx@kC-zG!MBuUtn9Q>kDG@^I6k_nrv_eJ^ zr!eGUS$Sec8K>psVcB^KMj>irsAO_8bj;%w8dybgGtA7x529$sax)yv(+??V`*Jfp z%zY0BXlQacg0d_npv(DUULP)9)=1cYE2euqQ_K9?BF>tg?x+Ykm43d!xh;gizD4>E3L9epi+%` zorRj_F_Y3X_zqm8;Ac8yye*)KjEtAfl=ZQZHs3>2kw*h$p=Q5Krfd!#1JS9vnGU&7 zfF@M)DYt{^z(%TWmP7vArgG2-ds$sUA8RYfJsuSSWEnX*Av#u9sN1e`z6c^&K4Cge zcG$Z9MfyPnU>b>f)?3)i>LTwTBM_0)kG%=yHoH7MVp|SD?8ESk)+n{SX%tt*Ke0(x zPJEfe6<2d)(auCyWhU`aHdbPp)0JqocQMFBM1?3RR(48~gTs}4b#O7wL`B6uX-XDB znuF7oX0?B@!bC=;C#gzSPNtc|m0@*wvD-vj1u6MbHdeNo)0K6#Z*l%03)oG$!otqk z)?7X?<|=C|@5c7Xy*jpdbI=Z~rdnZb;&1CN{~kk-l?m9GZG;((l|2vG_}hp!DkmEq zcww`KXo9s6Ma;>53FE}NP*2>E#R1jUW@($SDccde(cdUIdIh8xwzJftI8X=r3ftLg z(H?LBr-bdSwHOcFfCM6T_F8NQh(KGBD+?{I19@PV$d!#2{{aIKLG+2Kiln~O5-YJw z7B2F_c1`-A8n`5SWwxepa0R3gyE0r;J;(#Pid~tmX&!6=hs3Uo*Ypm$ff(Xf=4-|W zUqDlFLW4DngFs-DIHAd!?Li+9Qi9NE&FP>3s3t*Zw&s4Y3oMZ!G+gsJNCZAg5Sp$9 z9?Sv7Bngez!VcT#(v7JXLXJ@ z){p&>^Um%ZZtNVhmcz^GoNgQ*JD2Oo>FjHq9mA8;&g~p)TpP=ld(Z70YCIUzmdnoT zoNBxpTbJVjbPhDWjPb~=13D*MAQRlPuR!kz7fc1WtlLpW-(^?8JbO;4hVkq?4_ z+Ce^}E@}x#*;jCPC<`S*{8sH;qa(5_(66nhh$H|eU2+ru1zTZ$%Xa0_QrTx%u3ne6 z1aLV{c&<^Gsf1uTcLc6Mm)!(~Y&!y{vePq?@XRYBr`A(cQi%*ZQm5imZc>TND{`mC zQzOz5?6XIF>!kv~e&tCnzJ1Br2aI~fG{E8?Nc{u<;fe`bD(!M^|ESc8`%~*cP6rd8;|6V2x@2uxge@=KyBC$ zi|`bR5K!rXMgz%-+SGYrU?UxdcEKn0MB{=ow_;1K8@Ik?DUSk+>#z`~?)SGAcL>qe+6j#(>P6M{$6J#k$uU#{R z-s{lpIh;j{n>TN#5M7|;A&LN1S5Gb5Z@ugDY*&{Z*Za%xtn`OuARbR}-%5Hcw^6D#e_2aE~PSe-7MjKb4wJ!33 z(UO00wX^f|aZYJ;{}Bj8$PK4MAY^41k{Y=@QXe(UE}6SS=V6B{B+j9W3ZjN_70#Z8 ze2jW9VXfX0r9)+Z(b4nQx^_;mAkB;{k(_6jbV@{qX~iG>E99ftViOjF*0<}%b3h6d zC08EgJC5_Dkaga%63kZv-zn>M`Ou=?caQ$DJnbbILNgE&t0i--sRVb;I1yO|gu@g*36P2j+4 z$rd6RhpMY$mQ__g$Ig_Ja`Ja{6uWErwOlScZqYlvM(_P_qf)zCTaw)CYQE%s+LMfJ zO(DqM#Jk1j^Keb=>NVQmtFrGoY7?~~*~lS_J>!F28Wfa^A*0z0~`fAN#`t$O( zy5#bxO@mI$t3XMB(*Hh|_>>5ttM0ut`nW@*>ho}!zRS2f%-)y?R=n(3%CY7b>2HW0 zCUP6(X*34R>aaC4FSNhlme{6B#*|YG*;4IPqOqi^{9uphXu)g*6Y$FZ#CSX5$hO04 zZU*T?ERi_mnCy)SKN=OGnQ>#f$!CTI1e2`d>hc19*rtTV5s|VX@nJl)Pv5uK&OE*C z2}Rqb)wQTiw>;sRpVIZU*2EQKPBn@bUhDwoj(VmS);oLJRz%?2cgi;DITjQfPMYJP z9^Xh!_U@qI91`~QR@CE9>JuHaWgcc7BV$9UY}Rc!mM{0O9OkJ6@Ggmq$)v@7#%jHJ z^O&i$E|-7tWIgs-KJJGKiiiZ@%CY)9d0#iZn`OkffC>1oHm92#C+lz9xpG&nr#e2+ z-+I*%4~C>LsU*~z8lsnaf9QcXqOu8+iz1{_%JrR$L-Ho-L>)jGrVSTpzS!KnMUDu4 zLX6me!Ucs$j#b);7sfVojBBtp&o>Xk>vF8FizA+D6J5nX4ZS9IUFSSygS3m zHi(kIix6ZDUj9hVGyQyCXIE;>-N_~qDhN_`+%O|_XfCP^MHPtppE@bzt*L~ z{_Q(lz)u=OkiCOy1~;HcrO%BO2{})w&mH<{FMDjjK%GjrLXRo;UFUpHT z`_V1WfO(#mz+cgGdoqeSvoK#0&rT;eTjHl%skfy~wD8zaL3i^tU?zw6p>+kDOji7x z8hy0SzG~Id#U6)C%6=={;CZP9d0tsTFF1M%@Il};%S8x*-z0^({Jv?T@0We8%{ zt78~Q>;b}GCK$nn2BNpX#bnjM#p^EU?MWI@WrnsTFg19NRP0*^x_3_O@X&j`{uqC` z{r%hbmk?^Aoo=Pj)(Y~1tHjQo&fWVP-bzhR;)kT0d*XmoFff}iy||DZgZx9HrtN@3 z+P-6O11*u%vcV@)xhQ+evUSc_zae=(_m0dd5WS$}w=>tqO_QiYW!mtYfEoC(B#Ti<;t7f~Vs`Xf`N(Q6xm^eE#1-Y3 zT`9C(n+;;oh&(htVZ9)uwhNb6b;(19DVsdvkma1^&tG6A&zB78x#Hk)K~rsGyN}!) zx9wwK7$E1wK4Jkg#D5`ckkJc;c?2_q{eF}Fa6Abw?kkh%v}YPF*o^%OfTjr)2 z$vkbnEmR=&8&M&$jC0~!*Ym6b&#$|9B|Y!hvbKqReN7tp^0t3h?W}g^*O{|&PvOMg zcTrz8tDh1(#@i^7%mnu~4w4M>HY}90`0p!7RHkNc1Qq%QYCC3{NQ{#s=%MxFPi3MS zK2LI(i z(`8yUH)YgFb&}h^?X6Bl@$9z#CE%CFDD1HyUwt53(s%%XTQk=PDj$I+<3m2j04g7V zK1-lDff@BEtPFbqwk`Va&~NmDnKTb_t?sju3!#(DH0!!si*51vbd2e>-1O@VEYpJc zl#{y);fp(%@o1u2l3xB{gdtZ$pr~zZ!{GMKB~bj&bl2>Pk=+Aw!_>-V29EVv?%XzY z(?~;ZZl;NLyK5+Wy7rlErWAlBa?k>Ca+SQtPb_iwQl46)CwSP%q-18b$FVh8t_zoQ>{liC%y|> z>3YN1WMK@~ch4(H`L`FId5=6X%fZHY)ok;8=}vY*C90)u z#4~^%i>K8bV)&fgE6x)J&6Y0}hWEb}?10!ovua#D?;)*~g1Sena|R;34k7+ZKj_o^ zqny~-?P&K1!ajr|9pYgVhVn1?s{s9U@GIIe+O(p0c|h*iW_Ekc^?J2&i%p%b14^V` zx8b9Gb=%QT`l%w%dAG`|r48S5@AvxP1^YG~zwbgg8|}NIDSG|3qpa=9Fh>iMmqQ_o zZMMl$&wduessya*aOG8E*xi$R9_kNCbZR^4$&wRdHm-TG)Q{`>8^=eVC^1tHbd_K~a&#uAI0o0B&j#&Q(-lfAuW{)0$J z{*(Wj1Qz9hEjHWzJSAhBu?;uh>uJw>x2Lo9V}?i^iD#RfWwx&FAtnuy9kGMxM0WK! zfozwL(_*s5+`Oh-2wQU~2JBM_=(}TD=Pi&2hN)K9!n*^M=^`?WhrW104QIP-=Pjq! zs1?dpG09!Y#1I@R4hGh*$b((^=C0zKD|G%>%kB&;bWKBu9Y=6FYH$*Q3DECN1XEI_ z2~l+T#DHBi@HG5cah5C)tAvRg7|6=fz7wNL=p_CNebNlsr^$Q)9O-ErTL2c21%3=% z~Yzh^L<@QvQuEWJOAZoiMs`StnunB{Qk$O6s5<(>5x|!PFXz_vK4s&@n&dQ3JX ztm)8tC&?Mw?qv}ajGfqu1Vp36g2i{6K4q)EW>i#K{fQ~13R)gfCjNnv49Yj8so)k} zF{!I9f~c7JV!5@mGS`QEg_#go7JAg%O06V>I#S-~@939vONBI64+ih*_qZlZBH(wa zvD9w-iXeQh>dJ^!Hp>T6-F|dfe^9lTxY-dO0Z+#*W@!S&8|n^1Ub0ma6&{eXoPbPQDjVXp&vBq$nSso=nfEl8C1@v${QKYX1*X|(bh!x@idwn@x_4O>f) zyFU7drfQZr4hD^3R$+%arp8raXeOgpI=voJb&KZAxu;Jg!LZb(}BF>+H3<)2NQaWa-&3RTIggc1U@!%Ld+ zN!mDIq?0KE62X58Wedq1S{A7OXhxlvh6YKL1>vWu^)jImVH5KNqYMQvB`HEfiqMG2 z2I0mMT!M6(GBQM%j+BLXP5;nh={SMLxzPJFA{7^5I!f(8vGzlC93d`1<`utY+nwnq?y)207lDC(quzEp0}@ zXJ+Bzk;5ATa+?U!(*kj41&U;nT%8gI0W}m-3QdF!CW(8W@nO6#hE9T5412^e_qP8q zuD{(iJ==-Qi`0J%m3=}YOlq{Xu*M!zQ$kC2;{82s!akY1SJB^gm1CjX?%V38i-F@S zLY&kJ~Q`-)%5q%!j%M*jH4ibKgzNI)6}I-USwsL=m_Eo*+Ruvw%*f zADgLC9jdAOVZ+USQtT@4Fg{jX>@Iq zM0uM8==%J$1iqPUU1ioVJnGllmp@wQmR5#JN6sHi_AvdPO00X%=zPat)y5x{;2{$t z9duj$wQ~LDxP_PL=U3#;k=zMB4L8&1T?IbGo&0?5t~PW&KZ<**>guLulwT z2cd0DA+W8;GxCRIr_z zmL=^hD?{-eW*fjOdcs<73vPggQw#UHm0@GgzU~WY)WZH3fn!y;*yy-4o&MeBc(!+; zqc+{0kB@0mQ8odV<&16ntF!M%lG5om1$qxgjt)9BB$YwCp5c$-vO-!#HE1qz)mCD3 zpdnrwji%lJ_&iTVt9!R1 z;c?NTNdQ}{bGn0&5_uacNCQStRu+W5fTj*HSfEV{N5Nj{sk$~Tb(4$s)FJ zcPPF*ES6TK`a~#(9;jy@`GO#L)76ylI~awK0SYwOzwTu)4wgnTQ|C#1$2@UO#5kJZ zH9u)@uU#C8Z{9YN<+sn`*x)D@;@P>cjFOT@!YJby$Ucld=r68&7Ux*qys4Lg^b2dV zJ8$~Uo^-hP5%uwBr^}j*?{EQuvR*BN+G&%lb=DBInmJtRnWiK)`d&bGPacRRIGDup zOgPW(19eG}Wm=McVrC`jcC(L<7@_lKV`u}lww==$z>%;Hto|m zOc>M%Gcc=YaMOfLa}M6qY1q1iZxZ!JU*q8drrP}9FLxIYEh`V%%{u%J%cJp;oOw1Z z%VJ%=&3BgH$tyVL1S^>XY?xZiS+$321B<-(7mzUC_m>lKjK9s^7YBYG=ZZ~7P4QVT zf6*U(HQ9g9b!CaZWa2(i#i;QP@JhtlJufrLGq2~#N5C?>x1wHx9P|J_ z50`d^P9ddnnTMUDDd-wgC$!gePjPK)O7xpH`n+YYb}@#+a!~TD@Uc7!Py4ZdTM=gc z*Nvn}?G{TX`%ihK@o(0eU>PQY`-p-%k(tBoDQFs#nC9@KuWE6XS}}WjsnLl{h?E)u zpCz?$jGSAJ8wtb$r3etJ5!c~S`IpUM$$ok(>ePzZNv6FcGRStOY+Xqrj}7-d%5RNo zjLZjDuu=(WbQb}Bw~LVj%|%X>cAnUc*?t{`nvZQH0a=~;K(yTcI-+wI0m`Xe18Zxh z$s>O9?LcrR$OV)vTF6jFaxlf<6bH%1-o!}Wmhsv%+qbjr>6jR6yb%cP2 z9j0)DzpY1cHMScsO+3q^a5zkN-mrY+OwcB`>T}atq0ASfYZdod&a^rRX-CT74I>Go z;=nHl14`?yj+>xAFh6yvNPs@l5>GZ85BR$0h%Cb>`pyq@vF>hs-ZVeIuq7gnH`5~u ze&|4g4-n>3uiuOOh0AJ^)C&XNNX_DPPxAvntOwn21~;W^r?9P!qt%qz3%zAv>BA+NgAOpuh81?gt}nnhV;V-* z%Kr`Hg>xFQ)PVm{%xo#>iWGq5T++~H!jNDKYLg<{iI4x@d(9-Ud=j1?mB9 zq0fybLmD}W!;XPaOMBN1#Om4JwQs7@Q~{iM^ca8nNP^XkAL?ZHI3G<;pX5n8_n+fu zYMWc$aY#Ig{;|&z$vYYi_W|Ci7D1ww^jqv3927Hg@@Qc|mP{zsx7hLOY zo+5^^pg7n76HkJ}9*QyYQH`6RVfLCV;SRnm8?(-1{N@L);9S><#dNsrjcOj3j%wn$ z@%KPe$3YasyWj{aJoLQ`m)y zT%OvYm-06wu>0s&ha{x|zLz0>GaSy&Fl0PXdj|qq*PcUf)83-*Qcl+MKC+rbIIP{H z0=~gkWh0w?s4Ma=wz`1Clnx27+r=^?{tf5Bk-{Jt7l*cklel{n<3_BfgfRSoq4V2S z9(R;)xpjfGhK*h8d!g`;b>lqGcohGT4t@EP#S({aMjZE$r0yx8(rY1IF4k|(C8em_ zXsKXQ`wW7+@5mp%m^knyG(d=nGQ>pvhic3B;)2)cSRZf7QT*Dqokvu$+nVLXa<1JmSfM zac@$*tg%_oo5ajpFfH)efc63PGBmtHz(M~C~lUE6q5d8MuSK6YqS$a z=v*P4L~>;yrksG7j*jwvSLBS&c8(eA$c1M#g?)Uc?Sf?GCLt%!-I2J=mMrfhW~cG( zPAZqZ<-_l_!)IVYFt|=Hg2$}<-6i4+y4~-)g!H0Za$rGkn5Whm-{1zrcQFA!djsd> z3(SU~KAaCYk2S6oHTQ&s0lYWP<8e^viV&(42>VKGua{RMWcV9)M;%no2C9otZ9AX% ztArWr!yO>XLul<4k{1mJ&SS3yvs5blIoK@vP~m~PBgFo%sU>hPuis*@H3RED%8qc2 z?|7fP5x=&LdRf#U&zq8Kid>D~KzJ@cQ8`hX`dZq7P@U}xOrX2OU{E+urqwet>~$4J zbvAn3nu3>bHzR#aZyQw~1?z_|@%gkleq^vGglfz;^R#a-KBB`{h@82J47X%d;Vsf{ zUA_@zM?FyH?c`?0(N}(F#1%%wyz_fz(AMeGR{QPlcl>GYWuM))b)(JC$rR1E!ou^P zOlst>YWK}D%k3j>Dk!iCroC#`O>F6NLa@HFSO7H2>f;VO7(LyX(^Y zZ63iW{YtGlHBbQKXPBRZaU-I(Kl3ef*O#9l7GKq?H#Qa=Q z5@+wM%5-}N4+{a;Rr{U#l0hNTZA}P9y8Z&4fIzK)0@-`lr}SaZfg4p!azL>36ZdzP zZ_1VS{xcFCnaOH^zMa;`PoI5_Xh#Dqx->9ZRJHE!t#9v7+66ac4^FY#uaHL(PSz$X z#L5e*a{Zt3mL+;_CDj#nXqGcfH$@g>XJR!N@ub5ka&%FG`+IvbPzU$`Y)3I(pWZv> ztYtk1BGMzxunIEDBS{@0`6#grt&&1v$nIez^f{0kh@6zaIJpVMNuqG|ie^6=CxuYB ztok2yP4F$ccII9nFhtcYA}#UmO^*VY2;P54ZhcJn0y!{BaBz{m+$h3G31H$Ht;(+V7aFgXPuwp|Y(JLiPRh*kvUFOx|0 zATAPBbz6`?LT&f5p^n~z>LY2+p;5^b=khxCBZB8UZAlaHJA$2(>j(;EIonADcS@W9 zGN1GWB_u?9WAYCs1G17!H%MwS&ZkTkZPMbi&o|BHsd~)5ZWgs4I4P4q%G&1W1gx9} zR3ashye80}*_akVx8s-uJHw$c7W%H_RD?_W8)4G|vE*5taVOVm=uhqeo)A%8#oUERPxuJ+?W%65frzV2MP=KhY}=p9nNV_UU+ z&ZmX+e;6jKClkj4JmD0GW6<%D$z+f}2 zInWYK^V4T*->xFQzBbac^#zXEXDBanCszCP^5 z9{Z5Q+1WV>Jz6Bz20;$3V#PhHwc01)r`g02z!i%c8!pIgwX<9QbOBkY#GvHtG|0jcaoT7Q((gKxUO)4jJ=%_fSd^0 zQQ9?9qyb%g&!`|D2JlZ$bxu|@MWa=wGxaoc{}9s@N+z|tc-1=%8f*?;wvI9*+?-i3 z_W`q2>eq#vk>i;9E@YMx@)b7c*vkR#uD#@d-=v*PLmwYg1(7Q&` zNy1n?RwkT33Kn$xLPmYphcK)Y@?(Su;CJE46N22IGD?L+BpZ%c&u#MRMY?1N3ZPrq zU1_NvpAwk*MQVNnMkIX8;s7z~=fls=s{Kypm%qao;GLn1r=1DB0sP0Uhy#{ zxdw&X7?(aKE(>qO3c1l82Ny3UDp1#&AoHgh%7Rg*edgQDj3bPPLxQ2^VT}88Cz_$~ z7l|T7hI}^lsQDH)@n)Zp4V*jzNFf6yG?j_5>;;}D-m?d0Jilzqz6+zJ4&Ls&Q?R^E zynoY$4Nw)|{CZ9_zQ1#{OBVuGIJ~+;BmCt5z8EeD=1c?Tk)Qrn`?)5qg~*yDpo@*|IK>$>@J>Rk0Qy$^|2RKPV^rc%*x-*O^zk3izLp6rQ*0 z_-Q;6`9$wFM9h-?xD4TeVL2sIwBs$TRuDu|ZXMyB1a-xUu|T+kKEZvB$J(%*!(hPv zklS55?~1J%#Y$@Ddw$=*y86|VQ5{V`6Ag@JxPY7D_tIGH*$&G(jK5jV-fafM0+Z&$Czpc&FZzyd4gk68!lrq{D- zDbK(?VbErfa*@lyjZA6%&Y>qeRFpn0(Y$%abiK95(`t4p*Eols$7jTCO>OC>&)x2U zhJX|!uibcD`9}6CbA@u+q}{T)P=(RzjAQBdXLia*ZW(qxBs$c(4a1ujQLwU{ zOa*dG1>Nu#)*MYvRo5X@7HOqTRd>;Z(oLhh;h=>+_6R-7BG+sU>UTNXk~)pErNj_| zE;{XT3Et$9e9kkCGudP2?M@%w5N_oUU-|ngN+K_iJE2o77V1x6(hRhUVE9QfF838@ z{=lO+A@EOJ{?cIZ3pxHxM=UeGzf$8ic2k5{P1mmu+kvm2lAjpwoQ+eq`mM&t;m6m% z|9)v=L?V;O?#K=|Xh(WZRj64XAlY}F1)IvG(Y^1`#<4N&@=L(dsV4x>GR0jau`xn) zFbEgWt71Yk_R#VPz`ds08M@4PL3CtmLN1?qFdBK?pV9`6HFRBNO|H_*3OLu%EdhLg4>1SaC&$>Rhz5x~j-ITEH)7u}#)cl_JTLUSCTX2JqE~&`qSrE={qBo$3 zV=!d>n*Bgp9V697`&EbmvN`lArWKlQu*wRfQ`V0Bo`}_RcXW;w&9!h1_8$?~awY#w5P;59sB}ZW^CyijuN^3whUkJcPNxHsGO%t@!&9SCKZ&6r-lo zSh`_#Q(WaaZpT*B9aym6r_;6EU0dq#%Zq4%^9-|p2uH7h@Wx1Ds+Q@&Gb?=hu2ZNq z*)8HDj}&gI*hU{9qy<0!aLuMWvfHi*tn*36BtyoWXylf>S1P6#)&=s zo@w$HPM<2h(M;h#%51Y;XRs?@+PntWOh-=disri8PIY6!`WMeep{(0KwOg(adkU7- zF(=RS8t7Yx{}D5e;t!~No;H>7yR&+O;g(G*X8IT|sgHvrh_~s@7E}6pA?5xI5>Id* z2j(vBlv#Wt{bq#IwP#-LUgCR;?;ImFNo*6fFHH*)oCi1|E&i$0u1z{r_0-P&uC4?N z0D%C5euZn^UOnhZ;C46eR!En_mojnnCI7JNz-i4VbK_)AUst1DX#1tu?zh;HixSET zRtGi+JqU{oph5%BC*wz+WwmtKKy3_()IQdHLngYh6Ri)u@jy8MCJQSiMMEOkX8!3$ zpz%Z+^q`ywt{tjiM28(JoK&`vuqDt6DV~LN%>e)Hm0GLxmqF)&xhWH(A>4Ya3rdMk z$|;+=!TL7&SAK_1GxRDeFAR$Pe7v=UH;IZHi=>y;a#xk|`Yo-M$8X1Qb*%f(anOjV z`5h90=9Vm5!4!XE)|RzEVZVR}{3iD%t?21$Hbj~-894L_6SYj4MLH$82+ig+II%N? zP}*Nj`8Y&0Ij)IoMFZx8VbVtd-;tp|q7syXp>Z|$<4}u&fKrH-Ik<5o(bJXch*Fvk zO`7wqr4|)j8vA>KHM>qAlvI$Whb!r@p-}|OqZf}e(f7akgcai}nKXXud7BJ^Q&%1D ziKh%EiR%8y+|i@!_Ap9-ilIKkCOc^x`pC0Vm+7vqnV3K0NYuYC`Z#u68in^|T{hzL zR(Os91|t69qnNg>tM2?!1Ju4yj(wX(09@LX^JJGCU@jL`z5%cJ%(b=6{?ac%XPH?{ z|7=8gpM!n`3^SDpdMvGGL6TAf!R$Lbt;83Iy%ZoQr3V)f%hceVs}Gvj?R(_%5=OZG zkjCGqAvqNx%1E8Nc@$79*pye)3iN!JfiV zLF$les_t$V?o4_0W>2OO&N=C+XoRVDDIa~DEUF_k!YRmWMN`v&o?b!RWcYbJLD&{wRKdo78c_Xt)^SZgvExSJk{}~ zc1LoA!j{WIGU;lY+rLY%q90x|a)-AzuB&i`3p4OM9iQ|fDTqxk9k~P54J@53nGLGi z6|~>OR>nR^+PD=z_Jc4}tv{B}u)gofD6?B%`XuBy5ODG4S}W)Ji;x&FZGjSm_!zc9 zdpvroF1@Ws-dxY>%9sTQvtIm~&>xP;(hz5a@eW6jCAfq8VnaW37zJU{U{y7}mG>m> zR#m995+&=^VZ`7nO!b7PZ1c+=%V6$xDE z&A9&iVKMBPOJI2pA?ub&$6_1a?3|>U&w+}TkyT1I?4qmW%&?Gl(bQ|S)5o>vI*SWE z^Eh4(HM%M)7@WUc#=_7;9Eqw2j+^mW)uKmZ4k-Pp3i4LVV~1d^lsoyv?xsBgZ(~ik ze+9=LAjuYi)+@@0=x5YUUe);l@8&EU)k1Zc%_!46@*QbLK*)VRCqbAi#mC+%;rL`t zxnTWm_dHfVBcJsl|GMzX+qQNJp!;b6AAr6Pwiw2ZkR(HwJUz&g_pJs=XjH%a@?D5~ zz-K}busXd`IZcj_^_JnKDC)SHbwbZZ{HVJ`xzulCKla^VzWU+nt=h#JUqS}sxx>GZ zB{o@#uV!uJm9*Pn1Y%2)j43J~*DFF9Ktrb01D^+0FD&kPMzudw&(*6m`7=XyM?z;g z92nPmr_vcqxt+AwRz)mSNGc{2+j1B5YjTai*y~4|D8a(j5)Q&{u|UqmG6kApQ9;}b zI9;J2VqB|UhC`JYX{KClFBs#d!+@O0yIjKfvrT8tgHE^m_2C^}`ZWdCh%mvI&}o6G z`2LYbIvwl;k}WNR7P57G*gCG+6o2y~Q_IJu949ZRe);x1f05&=$b5be8TvUqqt;!; zNAT0%Ah97isDXLo26OgCF*cS?JqPBqR>Cd?1d=Q~bmu`5+FHRDR;`rK4>3)x-kd?Bmx1tYVoRK|sT+ID;L9Dx}^-lW;_}3%* zb`OW`pb2rGC*>7!r!8Oi$Ldw`ZRc%WK9>TbZ6ue%W`u@Ncpe^=i}83IdB31qY9~)q zzoAtt6dlN4NGA6UAx(luO}vR_Pm!7@j>e>ROq9E_fcs-GC}JxIl^MH4x($PwTQgp` zYusc|pJH=&E3YX5MIsBE=*j$!BECe+zJQMacFYE#n}R}EHW_(Vj$JI<1gOU{VP&ZX z$0GDP8Q)z|IeKRkHeqP8iSIA;I=L0@btDVOxvs}A)k*;_R?aHMtxIoX$x=KPkBcw< z^rkU;qWbm&=bJHj1F0_E+ipu}1SpRZXu^lr+Y*uv(m!{vhUjP5j0s?f7J;;Xa6f&z zaH_w}5-Iafg-IDmj9Lm}>pd8+pmDK!)c}Ril&Rc(qSju$v+fQCxfAS*Tx;_SuG2lP zZdHhEbUwx%<@WogclH|oz81@|(LuWeEm!tz;z#;27bLosO{UWX_cyQWHvKnJEq~tE zUX_e*>g^f0*<{|{taN`he@;Qh1}^C?gg@I~kh#0I(8(jTuW|Aw|K@S91sDqAwi(;W z&;hM8omYpu=ar`x4?S*mv483khvyU7_5yPIbWSWuquRSLO|A-NG(p&#=@}P7g{&$s)f?<(~nLM(BVfSMGUpl=J|G6_0eT)0l|`0%u17p{qXG_5}un_}qKy39Da!F83b5)#Q_k zsdMpFsR5W1@k2~j-oI)na;Tls>LXx@mAEzA0;tZcsU}?BrJA1#6Nf}^QnBuPXJ;Im zI9O4K|FHde<RXh%dnq#?Q$dj@l%%TygRLpIvLK}|z3 z{{BQ9$ER=n%Il=((Y#2{qL)I?B$Uwz@%^=QPm#)-g?f`rcM=@Dm?mmEo+*m&qjLtz z|5-t4E{bc}1k^S+W&@sIfF?Jg__1dt@eZ`fR?2DOZeIa-7O_wCXQcqHnL&21x z%uH>0IwN0oxQq2>f{PVKR?DZpYJlppYOC9V8H-T=>benjT7ij))qH=3hPHB#9tKoC1aJzAlVS)90p~v z_Eyw@lh53J!Woa_&%U128LQr}XIw98Cxyr33t8)de^=aawcZI;rsmd^LP-#)V`*~v z2EoOw{VDuv@*s#|LV@!blIM)&y%XeR8H^Z%`*+qBI3jR3H0X-Ebfj%50m5lvk;P^7 zisuYilDo6F^9Ykz#DCYc=6IYo{*F=T>p+8lm_@uS_Wp{xINAe6cU+=DatkOH=*^GD zV~WBMf=jwZLiJ3BQ2Fu-V^;9VFeb(BG9}XfTyNk=8~3}qaxES;NcE2Z;;_=!2a}^n zjZa4aHp_9{BV1OCVxe@9ZED>{R2sC*F{hKhugM%lgs*bD3tz(2_8|Ti_%e$p_oq|a zME0jR`(t!;Iz~XlKtFyX!Rda_~q!Dh=+44tpS7C?BH~Ig< zUT{_}lgu2r(G>$UI;})v%|U~G65$(mTg3uIs+CuJ2OQ~!5AMOkbcri5oAbZDqD*wg zD{NdrLnerBj1w|)X5hLK*^WMV*A7!s!O|$Bl7Q`QI4^ER!1vK(9`MH{8M3tSFcuOT zJ~zFyPF4A=ihgCQrPW)A4FvYBnoGs`R9I=|!bP9<#%RtlDUzm9Gn-4eXBmyB>T}y) zj2O9vFvU9?PgRTjpObkrCr$WDX-y4qN$@M(tnxTBi6GI5KN0=ogfHP)IT zgiSXWeWOZF^M~goG^&F&HRpbMj90$VI7HJKB}DuID2@GAOdX}LFf?gaLvZ?o{a$P7 zvShIk{-@{q>h#>v9}qVYgc}{=csAZEk-|>?T~C2)OVTIs^5M5lgw5cC^x_11WEt_= zr-1c_J*`AZtIZdNc%z0(WP5K~vF1eNN}Xkg4vDy_iDfMIb1z`>mrm-!&^~WWz3_0V zJ>}E7j-HpGXJ&b5MrvhQQ>fa`p}Gf2HRN(C52V)8be_5b=^2cpKW{7A*U{1G)KvUU zun(v}oVAc2g$M0q?u+^(0PJ0xZYve;Mgr@m5U#ES{L3XX$?LNfnKCeuf%WhQ`CKvd ztk5+vR?K|XeZq-AODvO*|4&CRu2}b|oV3+4Mdu}kqmtbjLW&UJF zYCyBAR_W>YOd{F01d`?T)AW%&UKZbXMw{~6ygqzbj}Oc|1Izl>>|cZMH(7pIT13V7 zqsFegTRH!B4)qg{628QJQ$17j<-#?g>;=6XAs+6D;NN0U=JPJPYk{(V3+y&iP{uwGeq<*w(S{5rL1stpVq@yFZ`oX+Af#HF6d>HkX0km(v}3OQ(8Wf9#JR zj<7)Dv{_dsX$FLpC$Cc`_VCl6z!(V3l%|(qwH53^?`2JIE3Nuzw#)8j^AvBAi{n6= z)@5`~Zw6GVJ}{fAqD%RcvC`}ALb&r6FG{4VZ5+lJWp^PQh}@!cY92+0Hd%aQZ&@ef zglV@7tbWqOLf9^X%k>s5$s6rpT?<1wV66_t-{qRDOl{Aeb~`rsPzi*!i`=Ax0iBte zT%b#M(&|$PLt0)r6BvT9Ue7uGMfA3E@-pqhR#bwcmsUtVil?LpB2*_ve1s0a+!HPECKTm3r{ZP7jRd+*NM$`M&5F%V=o1Z z5DRX_-5!$%^E*1plQm%u3kTPDL_$#rAU{1XNAP`8ouLQE;~q)FI!0KRi2pfKH=Zp2 zij+IJ+Ge)ZE-%w zaw^d!Mp`o$^xPEw{gECpxFbJ&wAa|XQ-S*Pnz{%5%{Z`@&~%kLhciAqD@F_HWZKZ$ z*2IXYT$A(t3=$mhi#uWm8d4}7!DH{=A;12eBHTq) zVP3+wN>weaDD>?z2wbo$N2Y|RFmQeB8waJ%RUQ*p@69A^mO0ltG}mG1ah@GJmQ=4Z z{q%Su!~>YV{gTt$ZL6lY*Dp=}VzI+(wUZ%1Y9Fc*Do0FN+2&$+kDj4IUpjLi*b8Mt zoPY0Joy4qXJ?^SpOg>gTl>_yo)b*_@m-(0K=SWcrHOd)KtgubY|9o&c@0f7J^+a(- zVjg)ef+$k7N@Oh))r4B8VQJ|vfX;7%Pa!x2nNU(n1>mpxD54|TO|ya~>Nouy=4-=7HNpn zCA+<<*7PNFi8KY9wRfUFx$SOW4~pcdQQ1nw%k*8tIx!ef^05ClQc_(z3Yn1NhnqCA%xvU ziph=*F1v!_z7xh6h#&7z-aWd#6R&81%HAa{u!gK#XC~$%a^2?%S3RWwm|LnVs4FjL z9;#lraoD_z;2ph!4wj2G>7F|K6EB8aVlk3L$!m?R^{Y{>sA&!48ZsDfC)!n-F!9iM zg6v?(iEzoY$FzwZzDd~Z3&d=ByuK>kziO$s+@-K=kY$Lyw>tt8y0mGuW%;78f2{td z)TpNZLqo)ql-8&)=rJUD4Jie=`(wcHvfh+H+xZE>F>IDD#L#WZ0J&%)RAdv2GF$vn z6K?D^VLVZ19s@?y=?$c29$8R^|NP-3&7*lLktm~KszLPFF^QdA^%&V-S3;+!{nPE0 zf%7w~qp@<8!<~DT&9}NLGsTRP`%nNW7L|ot)Mi?|{_iCRPNYW_g=N%~CW8Q_RA|+L zS3p5#vl@>5Z1v0>X>z-RdpwF^IdR#ogsMG}e{XQMAvMa5@pxivn+wNrR4eJJ3H;v# z{Nh9E8?VQM_6QNp&v%OKXtVMW$GHCqqb*$0F1BFhf|%}lehm5s7Z3WL2zJT>eQ2rY zfpB(?^D}kP&dw1a;n(xyxZA;35$ByYdEDurwy3jn(KMD`5Q;`aNf+5E=L^HS@R#y= zd7R)kBb`J!3f#v_;hj`mjB@5uVI%6QYWX22tJIsdRL^R>C1@rLb0g~28@P!G5TXF0 z$XY{erHZ_34np}b!yrIr@}i@`uNy1U(hQl#9jgb@?J0@e@J#A(h@dEs#ZWJwW(fd9YBR&z~Wjx-$OqK^wLs zlt8~=-mtKnmC5GQL(9gMHRY<^kE94!$pC?pC5%zaeS=WBCIf0bF`*3*xrakc^W!Bc z%r(5sH6Qnqk(AwY*kqIol|5A|Hs}E0ssSFA%Ak0~at%9IN%u0(kE!n0@+Em7)IxNx z+cdk{$ZQ3VDGVSNp(B$u|@=1DBNwa>P$Kc|MW(k)lyoiUQ6iuDxGqhU(?6o+Nh^g zE@+&iN4UQ<5sIX!ekr@Fzx)v?!f^S~jk zO|BN_v}vW+rcHCUxJ+i{n)Xeb<_N>}iGo<*zXH-|I;%P(`B3#Wxk5gqe5vF_uBgg6 zA>js0THCQ6=54cLnKUB$gINmLT{BOCi^RZBabQN0v1Hog;=F0bMP@%I3eU;A$OBHx z8zw$aO>bBx5L{9y^fdJ-tfnZuQ+kKCy(3vaFxyIxv5C6MX8ynmf^;9okaNJ!!OTL_{n)( zyo_E2QrW7PKNVfxG{veEV5$UEY@vdnptvjWm1U=5&!MR>Y9)TPD0pBNGm11BZ|c=B zBr!EKaFIf3syPEv@;jcX;*O26sHmg_r{eo06cznPQPGDKwd)LAAdSr6+$fXABPgoR zCNYGCmzb`GXrLVb*B7Bhw*!SThr57rtvCb~Uk=9v;oRj5xJ3iSRagbU{CNf;heZn~ z*Y#PXGA@5fvEjC({Z_A1kn#zsa3~5}%C|Ygedfp$N{rCy{8&1Nu^+&@Md@azN6b@~ zO_t#D>ZiypD@*?tR)XLW6oC0%R%t7gUMVGboW6B0ii8;+aP91rfR>Ld`4OqHeQk`NX)QglRgR070 z)$P@VlJF;Mvv|^&L${1i+<4@obI$4T%tQ#|A{tBmHRRUlHpe-$L?cznSE1yzb=Za)|t# zSbss{Mx*=_;OG9EO)8hOygv8p@_Jz&4WWC|DlIFCh}h&PCB>A;eXL*9Q9w6C$zhcRXMMes3RZ_K@Flx)p)AW( z`o5LHg=4HzCBBpG=PU%2upEnV~;h{w?l_Q0RP;yH<>2BiyV zjrVfuDI$FU)E^$XbSGawC&OUINLdpT^uU%a2Pi%8f`)f9m1&ewqjzLBK;nwIVpCB| zt%A>2^Md51{AA>jLfc*SAGD^xf081YI8aC_mJNN}+Gnkz{H5)5}fr%wHw0(z+=&`C8YR{1Yz#`Khs=U~j@uP{kyTSki|XjTDbv{Qx|j=+j; zu)y{K^$JbEdvu~d0!X_!;&SDpjA)2-u^3IcS$07QZoiAz3e zG|3M!g0s$KBs*N3zvptVs6@Nzt$~41GvCcL^WD8-(u0~ie>UgAEmkqkym1`5FsunQ z`UVoO8++cVU*2-S+F*XC=beV-E!S8ZOmt!jJOlqqPbNuYizRTLNwg40oBYQXQ~frR zXr1K0iZi6IY^~%NMYCkJ3QlH2LpZthjKNvkH5Y-9?@oQQaU^sT5Xk?T_P5}0)6M39 zS=ol-RQJN4uusgXZ!{Qu=NhSTqHDsh^TL@)sQ4u@+*rr95TdKJ{FoX%) zSuHkspTr#FW~z;v1#Xy8EK$HB6mV-_G=sr_p0tMauN?F9R~7Xyj17KW;GX^XIsRIM zgwr{#hyF0~AW(`@Sg=*IHdfv9F?ULxm{R(a*M)mAN&kyFoFVLD)p*a<80(od+)euw zLd$+gF=83Mm=J%b4tEgh#@RoV>WcVps*ye}kCXg3qpNTtkMmPSzkgIjDK^R^D%IgP zrqPZu0U?6ke<{L(#2N{1@Q?t>8$ANKGoB(oDZzP><@;=gjNmFM`5AIwQS8B50_NQ&ytIqmN&yU)JX$%=Ua_rNmJRMM`HAqMGt1o ze|dp0%(N&1hO2~$@N#fY@a573>f8W_egt#tBS53baLoIH&-VrT3=)}N0H*x5(fDn^ zm147_;!`;RP16iqC$2$Sh%0kq$(S+574%hG%wSt#B<89xO1YXB^yo#4FS-|guL50T z-NPCJKnbHZN)B_c_Q$IZ1?*O6r!e<=EKT6r2U#GR;A5I~)fy2(Q2buMA^u9-4kND~ zFs*joNSa6d8zg!cn;7UC86m~be$`y}Z%2>36_i5qhfh8EYrXgb(oQxzUwHG}<2TPW z$PsbYaOgjde(q(R_{6PW`+>>zx2GQc3z6@??S-xu!`z#XpDR?gBhnog)4;-f^+nQb z?5kre5X%Mhv1BeR7EegP1eYXLz47AW+jC^$;%jrj4lpfhiH(+tzlVSFlQ6H>PXQk^ zvVGPfg3w7^dP6eq^634!c-9|4br{~@-mu8MP+&ym!w!dh*i826^<-aj2WhF7uhHw} zYwBA_2f0*|B3XJcLusaT9sO2@kc^mUE?rk2)8TH8x>!9u*qm5jk`!L=KVVKvtbSIY ztSVP6AYYGbfC-DPllI{*DEQN(JtCP4KwS`nj|0zKERA&@LT`yfou&1iWHvt)C8V!F z*%6a8zzz8ikQ^^Rue2}c;V>cuix-E|CfofGP$G9VL0O}gWsXb$6cgOR06j68C8PxC zjAUy#!9)8MIbJ&tke$SkUJYk=6~=F|`HH&Cg~BRfC%`yag$c}}qQZ2kYR=>-Dq+;= zRVy_ET2U{jOt6IN!3-57|I*Xr4%JyqCQDt&-P3dDq{}-8CI5^DJN#>y;g<%hFLxq` z$uS#4X&8Q(7L-rr52~{wUgcU+@{&KO&YO6Z>jLL;^UAbE|MhIUqE}OK4(=B?C8Fsd z91WpPJkB?y2=M(Vl4Qpz2<26dY3M?RSOU1*Aag~w{+oDQ?1hmyjeE2cV|j;nz^ggjLct&4ySTv2ggKcLJs7#w zC?*MR-wD+FgmrWZn*i%-8Y8@#U)>e(zibuu2Xf!K_RUO7;PFJe%xLM?R z4=RYDVwhCoOS66TI@qpy>e3j_mU8X^_)*ljC{L6CB%-85;Xx%8bA&=Ima>Z+*Je>k zv*|MMq1;&tK9Yx{Aq& zF_u;=r!8cXJ*gHyg%nN{UJc7{hJQVtGKV~*+Z{5e#>)yP^0?NPtl7kjG7(ymHr9DO zbsMz^2Bvt$PCQ4mg_%(HZJ&aMzj!WS2A8EW`X@<^DEUFB{1ULuevM#p9y9q8+mUt0e9^3hRpcS_#b z*9W)A?0CFwds2QE1znQpl;3stq+9JEpB-V(<(EcB;S=(?lzjfc(OG?cWH!8>NWcfU zBMpAwaoAgXyWJWeMAX;JRc!x^6RhTY5$XA+;E#O~)GFxlp{q9~LNhr;p9|v`ib~*D zBB;I)MuRh_iP``lI|WvH1OstT$A z#iEj%{6!^qe7gv!9XPgm>~oft{0u?65#*wwhkB5s{6dtETby@3q8Yj{Y%*LSf=UpK zjv&KuZG2D;6AbUCbow&1n*j|bLP?;~gAX!I<+!Rn#*m=+LbWcJm&@&FwaP|e6~#C- z%!ND%DGMV3)iW5~AjCbTPvz+~J@SKvU(FO< zR=TXz&uB9M02402y*5aZsp$cy|JrKDjof&I5=WkUYG~FrVO?w1bn4noSuH;HpA{b# zR|~jrx`o*xgj~Rr6azU=AO~!Ko^<1C0N<-GPQ3V0QHv+-CE%*H1R6}LXJgU-XQD{E)fp$Ha=zdLSF>P zPlXq+_Fqz>d1^SffaW~+3GYK+BF84PJ-`63@POHsUUgucjI7uzInsCNc8M{PA~tue)00ODY1BIh@>2evGp0}(oHn>Y-8~JHh*gE#_542 zJ?BS*zFB9@i&>kV?OM|wTy@Tnu7ZPzx`(ph(byZ~HO{qLQib9}B(6+KRqRz0KyfFuGF;>IM)+%ok76@p@TW#G!wl5% zcrE?CP!F7ZZp!d(r0GAV4&c^w#njQ+%5opdMNXy_VSC24ZpB_8%IHivt+3@w%!)wS_VfM%4+1A72 zC2N&8FR9`QoxokU3&P|X6lbenKw^kujAl`ToAN5d4ioCcJWHeHVbS_WOUUwhbJK%m z1XKz5;&A`RJd5RF61CZ$u@Vw50x@SOIA>=*YD}gCea>{$az>SPNUBdV5`ZEq5)%a zR)IlCV>FtMM&p!ZOfG|&tkXBO#LjLZc&WFDYmH5@o{?(E{@Bvn0)O)73|{kWvxVv` z#MjiOBmL8z7Is5#l|N`m8cE-zv0GmavB;zI@NFKepo;qI$fa0i`Ifp#%`y*ehyDJl zcy0A)ch=?{h#CSOW}ty4C@*=co)C>u8lavg52VpX9=@fjq-PS1fG=Gxz@3c=Ss+aq zt);1|TrZ3MukC%cDCU8d<{=>yY=J8BCDj1%GW}T1IeD9TcxdR-@UUxmQPP^NMhNqi zvWX25DOou@yvy&MF|$1y^358ZQJ$Lxn49RQ+l;=*W$!3pvm@2p!N#aCp;2Jc5PGte zH-B|dNuv-g4QqFK#i?g5)4a*{cJ#hxiy>Vx5oC%0THJwCh@iKsE9UaB70a;*O5rsX4U-|ah>-*fG}(gfMD?y}ENNs?%I z#jQQ{!wI(|KF2@w^{qSa3bXvKt?u zCyMle8!vl{?q9cVKV>PoXxcls-ulk8uaG0^El8C--(mBDVP)XPq2CRtaxf%~$y_1{ z-Ji`RbAfCi7ZA%-1JKcl!G_(t8wPU^=GLr%r0VJt?PAUAq}9dM(&qeTzaJ9qh5VSt zQ9?_rj3CFmm_G*UcCbfCl887yisK~-6^2)&j+5D)^6!U;fKFX>LX!WJ-}(djSw62B z7Z@ubSoS?kGqs$N#h%SE9!U&DsKWTag}wbm7~M%R*~WbAI8#4P!{g)sUtQN18b=Yv zcV=#HFL%3px4ZWzIon(=m&-M^sYx%_)8$yE7^2pw~M(z(0PQHz`Ma1D?JTp6LU2ljS_NE%1S$GB3gj`hbD1!;47=6Bc%J zJvKLeV>KRMy)iu(Ykt^~B@SP$$5(&md*Fx8T%cc4pd}XtZ9`atG;Jv1!n8H|!r{8W%Z6f{PX-x4d!HMmfj=eJs|CF8G0m2|9FI!%-T)Xa!y4~>AP6zo$Y;5VHZpwIzu1jt%;tybq97uY(uYqc5|){)xYmghlt57vQF zF)yO|l|c7V$$NoikkQQZpj-2uE!n;~IO-u9-qkoxD@CM6BiN2(UT-fxIfZv2Rm*GB zMQF{VOQTEvf6QyyyrU!of&Fv`HgA4EZTv#qGoOhV2s|4IQb_OzlM&ZO?rEbvXR0GU z$B(cGEA|k}$k@!Ty9bEd{Pe{J03A(xgS_qDbkCEgUh&42%}stB@#ctNYriKACLQ>~ z@)aT+34kvn%v&A57b@gRYr0;4_#|cUF!JW`Dj^01U6p*0ss>x~vyYMFT2q_-0G~qu1wflB;BRMZ7yp;;-;X^^r5>tTaGsa#5ab@M1W?MqmX@Af zj_-*tM~Ifz$zeUM5f6vy;=2oUb&G53h~5Z}XqC%;&GNzbbt?tbtf@@mC=Q>=H*kTE}Lf;D7!kJ7(jUxlIIrHlNTtxa8g}72L-7& ze*R8{9W3uLfocV)oM2D#>5RPr3~Dl>SY`~J%{TXLAPxHmB@~HAnWdXPj=I^PzpUQ&yO@A zMb;s8$5h=_UR)!in$b?H<`glse$_D4e$BYfld!*EZQ)vfvo{#{bDsugK`2L3X`mki zKDrkWQ`F%r$h@xZMF%Ac{{wQ1EV4jchr(5|>lzt8V=_7HI+28Isy)_&2$Kmrc>9HO zqf_>`=aV}%GsMDL;+p%@ndAHEyS!LNkEVx|M0mFxQs}+oGmAN*#N}UQrflQI-;)y& zMyt`W+3(K3JUXRDt!yMNt3AhO-sC6yKE#wlW;~JM#~$K!we-fb$l5MQV|Z7sI8*@| zMmf)ACWgN85d#tL&+~vA%#fM@0|g)`)C@5FTH{l|1}FjajT}E=)7&5K<@rzHSp5)949E_&BQ;_m(Q9;UVAWnGbe< zOdTO%H*2{4^402dM+sffV__PK$BM?>-KQ(1V+XEJQzD1LD@G)mkadMjsB-+M>yo({ zg~>Z)J)BGSXh~UTcDt@IsQaUrT=(@$)#oEoUMOQkViTofb9eWRM8*jV>+)rOie80< zzKZJPiHlYDHq-@mCbcJ%xiFLd10vsvod5uMoMT{QU|;~^O#A7&@%%Pl8Ms*(K;Xvn zy=@5k|4bGJ<^~{_gMkSo3IH~J3rYZZoMT{QU|??e-@p*V!Tv7Aupj&&S|GL|0wHK2s3IUDq9Yh1awFO#6eN};_9coYCMKXJ{wH21wkPx`WGI>` z4k=tIqAB1iE-Iud@+(#=z${KIek|ZEDlLL7;4V-uh%V+YBrm=&7%+4&+%Y6E=rT+) zm@@1$WHazINHm-^5;d+h{5DWFpf?sbsyHk-dN}wwHaUhl(mEbGdOEf{06Q!@cstfS zJUoaz+&w@&ay`;M96oM7%0D(glt17=I6!JZ(m@VEK0$s#zCsW}q(bmROhd3k>O@{d zltk=BGDUzz%0?zeU`D`42uCnSSVyKv97tG5m`Kn`8cAA7j!DKz{7O1XY)Yg`;!6xm zI!lgBI!s7RR!n3}a!jsF@J%93kWIW!7*149XimIN@J}*Nc2BrZ^iWPvdQi4e08utk zc2S~Hyiwdz7*aw~h*GXn;8Pk?FjHDnic`W<`cxoPJXCB{npCn>&Q%&!I#p6tdR3ZL z=2kRTh*r8*-d6%wgjeiXMp(vpoMT{QU|^JF=waYv00AZ-<^nvc1-N6DcL<;RKw36VTFd z3Oar}g9NcPGvE9>GalOjuJ8#Dr|X7xVh>$rCvK4Mgq!4h;TE|s+(r*0;STjDVIPl} z3ioi0oD;m(1+zY0ggsp1Rk%TZ6K;~d5Jp zS{~IlHhE%l=j&8wI(G}b-lvh3OhTw_xiz^O1w&EhI@k7hMtN9|ol8_=O{Qk1YDgZ&N>f;9L~!&gC@gWL-y(+L$4F}LSf`QFGFp`{7}wZSi|YQr zXaBR1(W2zUYLenl2rxXWnb)zZJKv+kfzKIJb=*bKEazmTnQT@~O34aEeYT?#QxCAI zy9!J&;GLY+2lX3fKVSxHu>b&goNZPGnB%$;-rs8qZT9WnJt{N0?OvIgnHdyWNz~Yu zPm(t;S7v5rW@ct)W@cvQj^reJ_u714>=|h^8vMr_!AAS*Zv5XLPD6lAgoqF$L5dE# z=%J4RwlKstPQng$aR`TTGETv%B!4>2g0tdmI6KaPbK+b$H_n6e;(RziE`ST-Lbxz4 zf{P-<#c*+40(&@uOX5JcThrk#UOd)Z1 z%ut|21%(<%p|dwfd!7?9=Ip&g?r;ZxG(O9`{Mz4ARdGV;~{t`9)^eG5qKmX zg-7Etcq|@=$KwfjBA$dN<0*J5o`$F68F(h1g=gbAcrKoY=i>!cr9Ls*W(R%Bi@8J<1KhA-iEj19e5|+g?HmUcrV_E_u~WjAU=c-<0JSe zK8BCu6Zj-Pg-_!%_$)q$&*KaDBEEz#<16?ozJ{;k8~7%^g>U0K_%6PO@8bvfA%27( z<0tqjeukgp7x*Q9gVRjg3~vKl8cOM!OBdlrpmVu zcyqL2TBL<43R$aqP%F!<%8b>rHfbq~S!M<6xC6PC)huxot;Af7$3nzPvuYy3S}+~4 zx-LY_r$XyRch0QPr6^PtO*E@TUyHGp6QN1H-kGRTA?)(@Y}^#Z;Dn{#l5;z8OLw^{ z^45rMdwIs2y5sNh)KuBbbDgz&NiK{L+D4|CFx|0?6wOI}JZdzV(w$XuOxG(t>$*o~ zYNe`#PbHs;DjX}7$GJ4qY%g>#?}8w<5Mw)7G33&$z{T1h&=>89xt9jKsPCRYtrrw;1McB~w zaZ?qF&qDXuw5smVe<|xIrz`SoIAVMjkCe5l?6D1*nXEd6Q|(gI^^{-i&Lyd@ z)m-R^Duz!J|IGFxD@&n!tYEryH}YA(WaN|L%t}=a+c>ZJKFjkpb7)0mvZ7)tJ-xkN zTxLD03&urC<;2y#(1Wqm#%4_B*-TOZwW_C!Y%gw!s1!LX693HhI)>uw4c#myPe;s% z5u^4nigTe;s#fdxE^W+&CsSjY&Zt)gT-6K8EpJLu*`DjF%ut7jYGCHlxjt$rCDkUA zWytC7ROPB9S9Rzj(&tihDnVaVTUwN4`pTi*<({j$b@h)36pl@sa70zQl$B%I z2BS;%I|r$tcWt99XJU4+me$HhC+7&una(K$#;}Rl=2K=fcf}GXhJGPeE8N&x^B(AW zo;_aFpY?lP&wDbaDxwlkSGI(z78QX^RSE9w2%r}Fu(;{=g=|a%)^1ew&x-rv)P$Z|yNGau-3Yn#bOGA)s z`umh~MNuWNU~!Aj3A0u+ZWBtUq!E`MQv`8japDPCQIRptr*V6#Z`n++Ia_2d-A(P_ z|48c4*HIlGWKJWQDnVA%hy7LaW`sHEirHST`qmWr;9!9|ez@jZ;5y*j9!^{wgf&}Z z8YFItE|o0V_RxxJk93zDS+Ux1%_8!+ zZcF?5VJLspUofc|(MA}LU2X=pDr1vPwA0)Mj#yVg^m3sX5E|As&F_ZFVUdzd zL-<{iu%+fQ?odH!+aYPH!HNr_xGG(CoQ8r;dL}EGru?|i0=kO6MhtB^sG*nZ?b!I> z_nlxx?z_WuQ=3)NM^!7RgWMrPbJAC9RVwF2&!5yj1azXQoXK4hD42D_i|(W5p!wvC zT1$4@G?37uwAEEu}1ivXw_Ew0$k5g}UvlZr_9Q=nAimZoZ#0BiV8i1AV{W_pk4B za_-#y&T{6Q&pC5u#5iNj!O~1+?Q>SFn(?sl$R8Qwy*N8#$%;vx(*pCJ#PP*AUcF`4 z<~_akAK%NE1=l?jw(q=P+r(ea7-p>UON@Q=;`-)2XP$k|f1GWuX6%Ot7;`xouBhpwX?C)SUdphg(iHviN^u5fPaC+oZByyg zzcGir_f7q&&(e)DJ$j1?Z^B^-Q|K)I@C=^5hPlNNoweg1V@JiY{F0s3u~x9n;1XD%&bKDoboEpUN2MrF6-oYR$*opXHW3A zbla@0Ov?`GugLNv?`hnYFFk$g|LFhf;Qx5w|9Ig4Egpb~F@s1xwMucL{zJ+i<*ztP zlBg9aBqq+Al$UYbz(Np9N_Hsw_3XE^&t%`v{v~@<_vw{-NS~-r*JtUQ^_TQljzYrX zp2OLDvyW$=&3=&myRPVdy;^V3+w?(wj=n|z0p0Tne;nUyU=!FNTh1O}-(t_REPJ1Q z#O=J3ck>-eJD%qdu`2RphD^3XHrtS22XitPq<$$YV;<&ZK32~BEWm=Sf>p9AR?TWy zE#!VZN)yHxBCL@$u_%kNX4Zo5O+>ldSe#8_?W}`!vM$!mdRT%bSudN+rm#LXl}%&) zY=CKOI-9{}B8RisY&M6@W%Jm4wty{Ui`Zhege_&ukoOgAC0oT-vo&ljJBh7h>)FX{ z1KY?pu@u|PPGMWvR(2}e#@;>dJA>_HyV!1aCfmc#Vtd)y>>PG3+sDph=d%mg zh3q1BF}s9a%J#D~yNq4Vu3%TP&#=$3tJnedId+g;4V`x_yN+GY4zbU(FR(AN8`zEP zCU!IQ@-6IE_GR`J_EmNpyPXZOJJ_A&hBCNvisQmsO@jC2iZgHVfIbb z`y=d8_89v%`wn}YeV0AKz6UJu6nmOI!!qny_8j{@TIL1zB72Fw%znULVgJTnWj|#9 z&VI&z&R%10vR|+tvDeuf?8odU>@D_F_Dl9F_BMNm{TdkKH|)3UckDmd@6on8`vdz= z_FwE>_8$8qTKd1)2kcMm&+ISkuk3H^@9abN5&IwZ5B5)XgyopQj&jC1SGdYe+{`W9 z%1gKn+~MF(?&5A<%FDQid%2I7b3YI8AYl?ty8Hj@e@?0Z7xf?fQLSW$BvG%=9+pHn zD*H7_Bqg$UNg`m9y;~AVknGnb5h}_8SrVZyvh0152t#G>mxTVwvJXfi$&&qsB=lL9 zeNYm5FUvk83H_L5AC^QoF8fVM=-Vv&ElKF*Ec=Kg^mmqhR1$hV%RVLvGJs{jEeX`aFvQJ2YtYF#iNrKd1S)gAc$Pbo%N)jXq%RVg$GKFQIkp$_&vd>C_ zoMGALBthb^?Dr)>_OR^pk|2dx_613hM=blIBuFNfeMu5z6w5*a6G2+B><=VCZn5ku zk|4oY_TMByma*)sk|5Ps_J@)n-&poFNsx3b`y)w^c`W<7B+>@iHzYw0vh0r~K_as3 zPb5J$vMekBB1lP={dY-_mn{1;Nsyc@`*TTjRRhE5A5+p3k{!$WT zEzAB&5~ME6zAXvzmu26P1WC-Yzm^1<%(BChAe~wEHdy=3PSoV*S zpdVQFeM!(1Ec<~Z=nR(qlO$*lmi@CN=n5qG}CJ&L0>byRuVKf)9WNbhcmri60|wfLz1A^ncg4?8lLG9NznC7 zZCMG|lV(GFug+(&<4{xB>{IZy-N}h2-DHGiGW3z-XjU9gy{)Mz$Z*kN&-@0 zdaop47N$>@1oXmm^lc*G7^e400-|C1R7t=#OrItRD2M6&l7M%ZJ|GFmhv}LmU?8TW zZxaCxF?~=Ha1qmINdiJ*`W#8XN=%$C$oc5|A0wS4aXzWBN)-Kx<52B?-8V>8m9H z!7+V}Bw#tFuayK;$MlmV0pBrwog^SVrmvR-%*XVTB?0|0eS;+6K&Ee$1VqU6O_G2O znVymal*shWl7JVPPJI;w0l1Rp;VrBXsNx-g5KT8tJAl)koc$VpB zO9HZG`Z5F4NSjT z5-bR&e@PN-38vp7304KuZ!t~oE!6IS$ zkR;e9Ous`CtQ4l-DGBxp(+^96<-+u@NrDZ-^t&X%nqm6gl3>>`{p*ro;V}IkNw9U8 zey=20Jxsq(66_zQ-!BQ45Yr!!1e=KI-;f0Bi0KbXf}O7noJc#raNn{_1zuoK!9_Q~Uvy}(bI(4`Dchfr4`{o_y+bmNpS6be; zwpw>u?Tet0?&9EP|zvGzU_>$A)+~@qrrMW)qdfDxCuXBG?y0rB1GH2P= zvLl|go)^7#?`rRJzE0nry}<+Uf*K3%u7?)Cbm^$*t{ z39So#JFJ9vgzsqxHQX7gi0qBL)mYwmQ{&&84o0KVp{Nnt82fhYugzPVZ*6h6oZNC} z%kYHwgs)Bb^TgE?Gp&nTFKr!eo6vT7+i-ko{6IWAsd3WN?G^3kwEwE3vEvV&3p>Bm z`Cix7t`EBBc7LVE+w)-0k;Kx(P%@CbueY`L!rqT2CnkS(@{gy~O}TK&xBFOMYv1{O zKbtyr>Vc`hnx;+LJMG8)HT}E$Ul~XY+%Pb#^=hYUKc4QM-aq})=}*rnoAI?7AIw}h z^WmBQHMnu`hQaq{bPf13b|ki#C*UOL@?0i7Nv<7VXB#&S0P%CmSXyR!e!HGs(qa zoR40T`@H*i_DcJ!y}eU!>3h}o`2)2JC-a)C+N!HxUGnOZ1q)uSSyH>M?SRc!Y3G;O zY>&AcZLY`cRa@=$$6OJ+>oHq3zxj7I+pB%IOzrJ`)n4`9RW*F_!rB9EwM%MVU9bS} zc(tZxecJ(hrO&36;7gCWY>jxsR(qBGQL$?yf56d<%2W;3cQaXlJlvV+@pMNc;RcJ} zQy%Ct``x@D8taL~dCb$#li@lZ^ticoBKM5p7FK4(cZZb5tR~u?cBwB{(ri{GVpofO&CFrG)O-KK!zO2rL#Xk`i-)!V8+Ry8_ z#ahSvc~2K|5a*L{A{a;{6VX`IVx`ML%4XE!lg$yur9iNbTirMrvs&tSQsJhWo(ayH zDo@`)OjFhk4z5!!ExmH%#zPh5OIEG}Abdry9?Zoy<;{aT`X^OoPQ zS?QfU|JR2r{V%xe5f{%?PjFQCOtjVny`5pa18=I^c!5>jx&GukTAJDywb*8!KX1_) zR`WXJiPx(6xp6NFCqsob;0r+S=x$mvmi$`H5!Z1b>ltJ5i(eaIV%`Hd$VCUQQpfe-p)A@5LAk1g8h zax{t5X0D!4F_aEgRt6Po$t1t)w%c6(NhMZgnBMffbB}zD(|C28qqNkqEzd{KsF$m0 zcwXZ0G-y<_;Nq^%K)D6Agt`dVDVEVHjf1o-=gEHb*d|nq><#4s?sF>v@Oz>q zO&`RDYq5lBQnXoVtTN88YE+t|lT3+NcQZd=UV5_0x@);P_g6)un{yd#`9A~6IVDq7 z76PlIO1$n6?_50Docmr?nDcOzGRr)9aVO8@GIIj^SFG6Um`;s=|3(S#aV*)hmV9$Z zpHYWU9u>Ufgr960`8v42D;bUiyL|qxIJLjED~Z04FXRZjL>i*qi9Raem@4r5!oIM= zJ}5IXnX-qqk1DRZWpK0aaqXN3D(6tvwaKPPg|Vk1Vwx<9GN=5rn~Lh-4@P^4AL5yG zI?eY#vwDZsyLs@aa`j%yc5g*J=k*o*WgKk!j6YT=c5WEJ1$Y8wNuw+^Xq^~*MSbW2 zGs)-TLmp9pI$jI^Z*k**YZFQ0eK+dM7ba;njm!3_<>i53mp{_S{S!G-ALzx32lnlI zpdu9I(Qt<;Qfch1jF>vYI6Q@aP;u2sCtbyVZg|`Ibw*`TGd-wj8BI%T^ru{W_VtQ# z{n@t8uomvJ8RzCpbhWJuCpulLcPPpZ<31zJGpH$1U2bm%4|3u)A;&W6#gMO5!d4++ z(Jb{m0PaJ>K+HyCDjH@0&4NzZoj^YfltRn~t>IYM3QqK?Nw?FZ1QcIsM~r)2##EP= z$2v-VIOTD=tv;91=l1bAX2WhuDyP_U57-wp@dHgtrqr2s2XpVZJRXKH75lKO5j%Y)4znB>z4HF2}wASG^4qaC<+o!G)A|`CUkSP9}Uz1MW}?P?v8(_)XUAWxY@{=ZQNsy$G&4T zUmV{()myq*UN!!St6VkPjQ<|J>M5K4bk1zfJuSD@jg5)MMm~Cd**Z7h|}v5jc6}a33xJv`luoQBh-zXqirwP%)!q|(AWrk8ljTjS~-7himb8gDK4+GekJx+AU53b(~sS7V>P*69Qj zn_j%>rWZ|oTEba+u5yXf<*`c;=43%#0n!70I@2av`f|XWZ zbE$XpjK$5nvfsBuUCoP^?m#g_Ii6SVRA<5)dos$A2zDWVfnY!ZFhQ9j7U+gJ zie(47QT;yglkkt(GMklTbe7U$NeMOhmPslmqb$;r9C zwe{|@U{6CZ7O<9w>kYC zRXyu!x+hJp(ps7lZEZcV=B~!2j%0FCdHodS(GrzgZNV8EjaSca_IfHSxy`Ox&E^ut zX6K4FXE%49(LYDwPNzeyD{r3Wa+CyJlh3OT*|@jL?y`A!Z~L}Ct!SCfO|^~I;F`d2kq$@qHbt_lj6pl<;IepFfYdix7V!GI|VbcMF1vMTqtPU}hD z7QemsMbF`DHaky0lQ*2Ve$~4dU;I#g?Sd3`#3d9DYrn26Jr9IoX zH+Va0h1|{v;SJ3U0Gs%^Oz!=dM0v_mU(s4KVZ-hP*2uz{E#~eWvu5q+Hn+@N7_lzc zyTpClW55i97n2T zS`xobWm2-QWYj_A$BVp>4Mch@3H;rGZ<12$3Fjq56zmfLB!}3DHAJBelF-}Kp#VKC zR)AXcEK+?0M-Ylt;_B%S#Oh*G8e3+C6ay@I$wm7vc9fS_bkqi#>v_}UNXwkey%(9h zZc@{xi|$QPPLDF$rj)bHW*cyZFIZQ_>#CJ6|8o1q3g5fQRmiFGH#0a#xn71>fw@HIXOS8)%rlrQ&7>O3Hg$utVb>lC*VQ~hJuqK8L; z>=MbY80A!l5BTNqdv@C6skJS&tpj&ED$5l6YsMM;MzkkvRy68!P$>b77q`$@ zDer`YQ%Erg^SRIm$c~N!z>anUp9gi^h0`9D^_P0ZtbUTy;I z!j_p%K8>S(xhQ_>DC6@IiFvtaWl5B@A#UBdoNJQrhJpD) zkSh@y8E*1~>GP;zAE5-Wm^DHhAx=i}+|`*#_MlrU!?_G^tcC^LI9+Q_a-M9~@HIn2 z9%W`V)ER0jrKEG|>PF5Rl|BfPVaSuTC`UpWqGDu>Vf05gw6N3@cdF;B8^IkOVnS_3m814EY48(VKeO`&q+tB?Ep6D)j-%o%Wn?dd?-A4P{#9K%9kNnVA zTV7rZx2BZ$x4<5n0r^_VLa2qfw1oP}5~BZIa4N-MsY4dHxjCQMI3PzbPMWliUuHdH zi95Y^?Rh21K{Ge*vNza_L(_Skb!l(!Qofegmn@mwyTo_{AvN6id;QiauC@DCInaQa zC8t|gpTW&%uMKYO%l*OaRw{bua6YG3Y|l5&=GWfd(WOqFqs*UTpOm*l(~uq2&;^rV zFZ9zmxDPGTuRwYwk=q10Bakb91Z>mP1vEi`lW=4wa2vv6N<^&$tOvN-V2VbKKl$R_aj)5D3N}Ps*E?;F zYVR(Sx4hiTOGmCm8eG@8N*q<*+;0BNG%q(+t+SX+mILKoz8g>5hwVP&m)BP)J{K%p zY(J+&%&~3F#-Hdlrd{4@hs}AtE7A}&`OIE?&BsggSE?K(uIpV5k)ZmPGR<4H&N9bp zIpFi%sPFUPod>S}oXe*un`v7?*aU)PNL|RRkadmHvL)zC%F9Z+N~n91A_Ym}i;%fg z$|FrkELQFh_b9Jui%N1cN)~B>^;;o4R0fyI*7cAs2BZuB;X1Dk78|Zs{C&`eVkM~U%BBokl2KhAK_=?2}%P99NO`|MInVeDk5oy#0j6VP# zC8rNGdBJr6RwV%<3?XzWGK+-bAs-2tQuH+|CuBotYk*vou&1A+uZLh&sFnVx8Yg5;V3)9?r_-8pmIQ|l@zf(@TN8QaOT$rTmhU)^u6@GrtHJRkh` zypIZKynuW{L_Zg<4?^#i9;De7xI&4BmbeU1&XquOKf?TPZ0%q(f;uTdBAgU zvxF#{4||Ujx+1n{1H$8vsL#SzTY_FbE7!c-5 zl047w)Vje=-vH(pj6EJ-U$XhxkYI%h>+i4tl_I-?7g z)O~?3oxS|tE1gSbKei;%`o`+XC7aLdTQ>L$UfvX|v6eNI_c}**CqHtTwZeUwEu=*1 zmM(}olPw{|Hf6<}sH^t#iyxb_*m>o>%V#a)%OW$EP2IQIHhIk(zb|j_SZiZV<=iy4 zJdE8ac2$z=V7Bj}U)RFg=wKS8`f~J{f_Isuw=&YDd!i}|O0b2LljtdwG+4}#>`J5o z&LY%;8pcS0uvD4=F-StB`KGUZUF$sUq?oOy!PI&`(7{m#cyNEKDYQQCl-HE~n>Ovg zRM<`Y+q10B#-6&M-)r|ZRw$bdINM0f8~5_v3sdDeZ+S|o=O?Nue!^=4On)L0Ut22WL7cj1NCbjz(;Px z28My;q|X>-^as4waMY_7X{v%Z5;_jb&Ck=y+(croa_58oBL@QyU8-vI<|7$w;|Os6 z#o@!h;7^jji7UIh2o23mc6J;8eeb>8V_3kv_@6%f3zO*=yfy?kS9M7AeQbUJ5kRP* zm2xx2LE*1ck*R)#OF&SZIX;{coXkY=HhyhihwI1zSI54u8Ad)cjYSz$_D`2Nm~LJD z#cyrc@U1VdHs*@V7;no9jH3@2>b0s%)QSM?1Z@j4s9(SousV2wpd^|bdr=DyZ=f99 zh)s=m_1kBhei0W{VbVxaK5F8-H*9=LS>vr1z>#iqcP?sbYk%?_@%h72Af9@AG(slu zm^=tcCowB2-#+w0^fgFp`nVh>BB7E9sGj22Z&>`3EvKxms=ap)KCj8l@C#2r<89^E zPLWlCVXM8%Bi)JTckjGHK}Ka>&UtcDyotIAbPHs126E1UIMWazX=wWqCt$JYN)l8c zk*t!;mQuPqp|E17rhL2D{)AUISL6RAQD0tFEAmzzc|m4YY#%76+p77K5Y@w!Z6H;F zrzvlbi@epttF@M5?Vy*DyDm=z3ep<0kjn>c6Y+ESaEfVsDgu$l$W87n+U7r_q zS1Edb2jm|bmYli-4j{Av+a~cSYKf3r(24;gtJ;GqAR{lIE>XDEXUmmYoVS#e+h!Xd zM9e1Zte+7|8ST^iO$i1hXms3Cu>; z1?=c14$Me^n;M{>2b-kpNZ8M2+9%%{~mPW&|g(dfsF&e4xa z|Ja|^%Tzb8P#<{EEu7+{)&S{*22SSPB>>$RnMYj+HxCR4szID#N^nG0Mgqu7P&EFn{BziyKJ?o;uXj*gC&hdnrxDN1a8tfiX!x{!o2T z?GhuY`ybn6JTp$qAsZgkJ1IAFs zWCvx|*G(e`;5%yvl|ZUnSYI_>hu3E{er~g&mH(2V1KuJJa7_&n^Bwu4y|lzc=c{dY z`(Kn>#37y$hdE(O#|MR0M$PD%n;RB@98ASGQiFO4nnaJZ9{=+SG+>GF_fA6THe=}7OqI1t=)R| z8t=MY3hJ8AngXbzxxLDsLyB@}k0RwUUv$~I4L7}{sxLh$pCNZ4xiSR?2G+U~?LHA! zJUmU*-|BfJ7V(o}o5o>dh%^Fg0|N_5pszj=>48F6fz7F$ejdx;Ron--lDWd=QG8n2 zHe~H6S;yPD_({eUZl5w)@wl##wk7#EsYE}Rha2V*E2qJzX|S@ADsz2*NLGy88cg$J zq{3AeSiM(K_O1>D`WAD(xG!MT%+FH2W#uFf$Q-q<;amE zq-BpBaY0Ov?l&s;9yvn6h`4|c7475Q3VlEw#EfI|-ZP4UBmpcGO40_=96Rm|f5BE^ z;|pvy<1t%>*T#E|mu(*&e@c0`q{O)2R%J8pFY)35jcc|F`w7k!<)I9?o$`Pj*aSoo z%Hg;ZiibXIyv%!Tcr&tLQx+U|=3V-#kufs1N>2%2Wv{gHRmYu@b*tQf@*|4bMggI4 z^CCJFje|jII4tmTly&rT%DX63rMnCo}+Y&_bAjv^robEjjD-!RCtjOREWrj zGBKb365~LWGE`~#G?&(URF5OXub)QckTIt7JXpkUC2`> zbgnF$A2~wBb|!oBulrBq0h`T+s-f1Y#4e6&lxE}0_6j@4rN|cj^-Jk3;ogS9vTwc9oN}Rmu%Z{TflSL*JvzEcmb82 z{Bgd+2xZRO= zgvAciHx!Mw1VZG8a~YBHc{mMOmZ{!1Yu0McQz;CRowecQuQpMbn~|o6D56E90;c7o z9O><&NSw!}Yfks}Ia;(Tz42gq+3Gb^-%<}yeamu4OEn*A{HaPpV~|3b`>6Vy#?`oO(}J9>bsA~L5MoHwf~27i z&14w1cukF0yk7~?SH^$8)GeFweyWo&h5L13xJyL8OBn$fr2HlK4a&H(;+W!d(tQ6( zU*Px-)yrs}(|D(Y>I7PsOngx@q+DnyR8~2}{BY68cr~}v^Tselj>xunJ-!e!K0Njt z$oJ9T!w2&b<+}-?HN=WSGmeT~s}edv_7FBsWyxLsk={U_lK3j`$y`9P(3(CEwCaf z;Bnh>%okdUKLCHy(F|5$S}0=DrDp@@QjA^eF#keG)<0TBn%_bK(u zqiQ!IT8VGmh%ZSbF+U?|@gca)VuA}Zh9X$JAI$ISyZJ{i%sJ=R_x9J=zOjc#&zoo* zx#ynWmN~w6c&kl0wCJTDUOP!!QqzC$ug@tluG?wbdiZ;evftiw4>wIb&v;AfkE81A zLY{?brhE&RL4y5c{X^t7g$wf&D1sE{RB~WJbXnjdry5jN8-G6i2D>SJdjGrWOD`|4 zdI8}iWxMb2d(YT@TBfTkvLvOJoOwoX-L(C;Us_)ssn~qphKW@Z`Daf*{Y&nBo15F- zy7G!Urt>Ry?tG*%ykv8|$$s{drCa%e$v1v+C0{jPElc*RGxnU>QsA4{)c|B~7~CHI zgq(i5oN1qslfrj1stJ8;0{Do0cru`t93)|cb&yEME)*2$E(|FN4W;}h>d{e0{ zHgB25e)OzaXeqTo6+-hgK%PL7l| zo6-!S*@iA`i`#PBN5jxn7&IF7BW!Y4*lcYi{o=MN#c!j;M<+7lKoRAsqGyZVqg;ab zkoAifY`;HG!+djADrh*XREW|URkfDV*yO!HluUxs>`0&~b-&?$J z;o|o$)I#`6(+1f z3ml<#c)yUfl<<&X@ayn}2;8PI8xr^YF1vk@oMwae$|Jvmk7|&d1cUYrU4)RMY-bQ7 zj)!Hqx1s?g(%Z4Qcl3Vy=xavmn?Z+?&$p9C28zoky**eh(0+VL^5Qym^&_hK$kltUQ>My9D z-)ZdWSToqjcdrdxvU=6Q(8*`#8f4L5J5i!+ur&0|ELk$pY;|p#v0#g$q!unb`x^kG zje~33*In*ee!9hc(vtFn#wnwf@$q}86Vh`}iFkx&NHEsq2U`{u8NJ9#ReV08?EHCn@0uQ4Fm*v0BVK6R zICwOHxDoJak*4^B)s{6wMErJM>3dfp@odEI^TC1f8%A|s#LEj5j_-5n0k5Wtrkpra2>+H0y%tS zy=suPQqMI((@iG7+o#fSRyc(L;4nuH@XZHLT%;%Lhk@SHMS)waV6swBuN<8h+j}JY zdr8QqLqi$ZO-ESC7E-bu~ynyt|#*vSb_Qpr^GBsVqA93n+Bt)fx6T)J|145w- zR;s92vOD36)NwK)8!SFBM&6Gr(7(cp*dZS>AwwGoqKg0zH%2_fgsV+jike>fZHt&< zW>JWPaPG74eymP5K}b*r!A>Ye%vs=!Gy&SP9CbpihO<&z;2c7UeTcI5hkY#o z;A%*slIuVJ`Rk2gV@N_3V@TF~wH(wDTi&=0H)M?AZOWOspDk3Lyvul~I; znQOxmtqf=K?L9p|hC(AL&mLu(##yG2|IOe->hBehn_?_ITnze7To{VT9I-z62=Y@- zTm)Qaq0mtf{>IHKXLK1^$;TJ70*!KC0;7d`$V9oPm}u-GRP-pdk7JAnBUY=6sYsD*-q!DJ54X1n1*~) z+)_rRd>456U*Y5Nc=!0sja#4NWK8C3R8|r?8AndWMx1tV$B0l#^f7sFkLYbM{2^37 z$HXDI@@(+?6&*Y=R z(=yGamHgb3oJ{#mBmHY+Cxd|Pp&}=gk}izQ7e?zxCb~e7@l0Z#K@)67o)C}EeE|Mv!4L!f5=Gn=MQG5d07 zZ?uPlI7(?#%$VM?OVfrGMrzBT?R8Qiiy0IuJDMNe;0(nwh9&SLn>DjH9B}^4$Y@jU za+Pbv2Sz%R*UtqtE&I3F|_v zO1`!*7YXi@=tOP?_P_!ch|TB2OV06!L!I_EOtJ`hPmmDNSOx70-!ZF4+F z8W}@4#4GtZRZhn(7JDXRx7^|YcNb)@CS+I;`Z$7>Rk}Y0S7C~DS7$Kk4+LoqheVPB zc&%{AgAgJ*4$z*P4q^6z*3=R+u0A)`()48|fp~=}_uqH_6va0V)>fyzTvGD#uUvk^ z@Vj_Tpw#$GD#b4<#ezv=Z3S8bAdZ%T*LPer*agcaf^|tEJ-+`{0qzmD*3kc=82oL5 z4glM!af`!fTyIpy)qPAkutrZbiFzJKyw&w-y%#p;1B8Wq8zb3XH~z7E@$9v`solvQ z&xo~jG?oJT>_WGe&=}k;AaYR(-VcxPchSIS9*klDv_3x?Dn~r%QIZUJXJMR=4+E6R z0fdxfQ@Mq(BA|TYD?@_&Or&w0jc=k4KVMd~I7`n7u&TdkX3S~xFc+_Nz=Z%(A8 zA=F$sb=u)YmYE~Z9lYXUJXLsB>9txH-=p;hCe}sTLh}~BWc;)xGG|_9qs6l5@U*Fw z&0*3_dA>0tl7YrPPC`p^OC6R+P?OxPTARou;Bo{c0Om1~!AQ`cPMfdPXfbe&E% zC2+4bhBL8*S)3U+YW~iOU{!N?lCrCzGd!U>Xx!
%#5t+7yTm^Z{)9pPFdh-)p? z70Lyb71b@_PUHS~9CyvfrBIBY6sik5TZ@D3`-%{avZo>tk4%nDNlxf(>hQldU@{F@ ze6B#R$59h-4LCf;$#i8BOsn$trrrtrEf(C;i3_~}x@iDw;0ZY^`-c@CBEkZ3AfPz~ zTh$sM^$+)VKRN)dG~vd;h{`d9Bu=A_&^a)ugxH7x?g_?KA39Z`gQTcBOc6MAkyTMw0?i2G4Ox3=#$`p!h`_Y`L;Hvi4>H9YH@*6wq=g0d!E$hD* zUDJ1Iucc2L{Nl{|NW@e>b~R3zw?V zp;DWxuKb-Xwua^g+m?6A>z%gJp{QCKj`?1^;e2i~8IP(~-lUsMdJ`5DdektPc&}Zp zXexjEEACjVQVspUS6=S>K}fBP#oS+cyS%AFwVhUsm4om-L7Iu>ZqOJch{=Ihz^nvT z3i~I*uPVYArIbV}Fk0ivdqsc}JHBX_$tk!(g~3eNa22_Nzzg zj|?;fP%gsZ2_7jxhWXu$I6;@y5P5sVA!i6!WprnT96%~uf+GjGQn>9X@+)YjR4jZ!)5kD34BKK9qOKpkC6^i9 zA3`mUdLi@pgvux441?MC3 zkhgk((=V(k4Qqpqj;_XOv>MZ8t{|pPgT|>!{ypivq(VvLjlFGwnFCe9$#dG2Cp{(A zUgIs3ctut4*mBbEk6^aY$8bzOoCiHlEp{Z0Tc&qJ&3nBe&V=h~oNO!KD>nY6i!0xk z3jEwWe!fP6i)hT6#xBRr&O{nPrjRB35Do5rZoKR)r>hizGei#@EcEL_ULxq%BisjP zauGTRf&nBuV4;%~C(e`MxDOUMpZLGX|G)*$!PS}?Co_4U(&)Eoo=(x%gF^hth9NN{ zIS~9fUQY7v{Lm+4C{vXAACH$eS_5y?P9eW%H#`IV@L!M1Ma5XEIFCNeLW@F|#uAvs zmkdC~1})<@5>I^T=Cv5@qhsS|G#+GAG9rOvT+M1GGp? z(q9fIQo1w61lh#!rnW zwG$Osi?3YK6h*e{s_rOmP~ML99U?sMNo&=1%8ES7;`5x=#@^6m?Sk&L-Ib@t8&H$S zR)JPMvt>&{o}IX$?(4-3PCkdX)qB)tv^?B6K65n}b9gY>3sx%W&zSlTKG6JLuGLYh zI_#?5=5+%Nzhd$s0-%HcdZO`)vc&iuFAaKO$(l@VukFZ3c86N(;Azx7{6b)=j4~|Z zb?JAt=ohqR;7gwrvs;*PIwp346){B9v7{lZ<8vgj+zml+L16R`^i02?uqd;hog*MU@HBR4^4R?frnN{O_yUX8L~fs{*oUk#mR=4 z58|M^Um8YTMf>5R{fDlqSe_bz0*#Tt$-Zjql;&2`N6$b1kqO&fr~JqrbmKn?ao@{_Fw+DR7lgv6sk(OJ;S6o^ zbv2szPs0V#*h7~Gmv6iO$Ey0q0}s5RHiiT1(89gV6O=!`@x~t&<^9*sKe@Tp*=&0G zh8tfpnO?fFcSmdOvuMI=doG?a(u6!N*4iBwwm6M@(U?FFqH$=Ivo&nXCy#&uB_BU> zKc)&#c*mFs?P1y96|EpE3IZaR5qQtB3u^4kk_4Y@+HwfLGbzi?3*M&A^o2dQ{H zDb4&_g%~oP&5P#ZAb{JcSuju~h4yh*7~wL=ZbNxl;2ANFLWl-3J8xtO`HeFqzJX{u zQAu*OTHGQ|5kP<`F@GnmKe&_cl&Nt8-+A?SO{VW&ZQLN!x{f;hj{|h}#}{o^lnyu?Re;4%`?`u`(Ngne^}R9Tif~nmrTpP zL3$E8DNObU_eW5#1aYaVv0A)X+JbyuRM#XX)gA#EaYWh*i~IyB1d*>BNoLk`*Mi6L>AKM?ZN{J4cxl`EzH2(;uHNT;WscR^-J! zV(ZENPbKk?dSU?OU(*nD45x6*4;T(XaCsv39L;zQl^@K{5>yXeiI)&9V z@^4g5t9Dx)_(_gZg;n}rt8e0sk5+`I&6*Z=I$mq(ph^1%tMBnXhUKX%e66Qq_C5*B ze;zDXyw1kb4_q!j-QQs8w|9i^sctk@`gl4rwXtz(2bu37@jO(}x;$@j3%k2G zhI5(-s^Sc{;!lim{9Qe$+C?;1C2~b^=ZV4?2jMLm-7LzQuQ=AUk9Tw;k^>R5h~rRW z__^0ZoA#^f{!J;dbQeGWc2&LoJh45!<~KF?k4;U@-eu~z@ZGZ>KWn`FtIwSq~R|ot5{2Cw2YRP2gZgubCgK#HDx(=O%l4JsUjWBS!M4v~&$lWkr?@|ya zlLuFn3hBk9s2taMqUOy+`5ea^iXNbKFND{Dw&XV{cwL0A>Ztl%brQx8L+D-P&-6nF zjQ&nW6zd@&vlw&sla|BKvnL!3C(W>FsYv*l7shWY^_dp>w$3o_oUzrn(Bv!St9f0S zTm1umY&rY+&l@*-m2Y`-i))=TTlvP;na*0Cn^sk7{B>Xf=L-h7v$TrO#~c7FS1+~4 zN+L6s7!PP#ddq}P%(a-XCC_iD+^3X`u)65iJqGD_Pz&pipl?8JLE8j<^kWzSa3P#8 zk$ft64oj244;b#kDj#(y1XhD6U|@4$=d!TqBAVNK7k(roq4?YxsjL)lFR>GicaSV5J980Y)Hjcndt)VXQTQrK zguW$(WARP!Mo58!YNBOsRI$btNg&KQqhE0dl8DT6j^v*Lr_g-(g76-f361N71c91K zsqV^vXvDi7nP^s33EA&v@2k7y7-O^ z4xKceslgg46#jw%s$^55bENf)>t|Te zKJ>NvF662c5;X1hI=R}kw)J>pMVXO%TAA@mX=&$A?WH*^1P_mS2Kv@(yhAh? zPtw@~Kmkcdza>JokI+uH{Oup4?)TU1ZVZ-BbyV3d6c{jxR6gFqla3ZN%ZL#QfQ zZd8D*iJnhWOIU4N{0m~MrcD-Wsja3y_i}xWtrYQE`D3Lwf2`R`JoTj$Cgfh8Frl>G zQ)0^>E4>pYxI;KTl2+4_(xju6sbgPc92k4d&o>U_pUl6BpFif!Q4NYxE65k>w`TO) zTGRw-aw~~H^ioLoqJ9b#Nef$HHD^yO66>N`AZ&`?{+RZZ%APWI@;giIua(G^W=meP z4^x&g4%S)InTMJxdo%Z@()_08c+cj{Js|q{N~i5T2MlQ}y~BH7){e6L>O-k~%rfQ8 z3eUfc#h|`BC?a<~fVjwJ3&#ez0{7+x%9ufIAdM3^tWI>24;#Zg1WJi5_KXxwUZ$u5 zEu?C4R4;YBOh0)1DGpG@Xh9Ql5TtV{QP3f1sn7|e{J;s$5gvq2N~7#5W+^wpGj{^H zX{P99h%GU4Nd}fbgP%J{6^1kLRsOzIi}`SDT8m22NJyqdmaxraq)N?Xq{hw^^dWuQ z18ZawMj|0Sgf$)}n|&IOP+lN6@kI!fA`XF3LVg+i-WFO!$zVVYVE~BIP|^_20zD4V zcV(c)Fqi1^S^9|vMN8qnG|-R8q0CEhK1D7KyT%H#{QJlsjp4S?_$_3!)F2}}Bao$@ z#@Pv$lD3Jd^gDC>;rv>ntuoD>Ou51@0xAv4rc$4pQanyW!{J4b@@tmo{ymgm1dr!a zwH_eC?Yz69)X*Gmw^P}MU!zFpb<7iJx*$+|Bjw9C@@)dg#GoEAfQzAJ--y;5$#Y6g z;_G`PdLg6A4xLL;kWY@XX5e4d$kH`MqaV>{JCGE zJ!8j5>D%IlJ6=|l7j(!BdgA$WWtvXEPIsscMR}s}6_N)@a9Kb~18&9`KURn->VN3| zmAT3RtdC`l|(ME*K=)AQd^8g{8jwM=2Zp3fkd^)W% z8W<*-$>=cxn>mIvsob!Z7o8AoX*~B_iic9E6pgW*fN$xSvnGi(vrZt%2_+Q%HRbb4 z2m-%{*N42%oM1U!@ps$$eMsRL*OOcf}YkFbsMfPRJXM^q?Jw>=_5 zD~4$0t6iK8P2Zp>8>Ua+aGTVgD(MG^{?On#JLKF?1I&zo8Dn@@xnwg|22d_}wg|gP zzgZf5Yt7rbBV&Nv6T!dZtqgOqgU>(i0Z(bEV}(bY#_q=cM{P1mU=3lIxK$0EIE25^ z4Q#ezJua>CLQcgxA1Bo7)SJf5;P_cbjg1j{iW`ec4#_@s{PqO7*K$l5&HU(|;Dcj$ z`h>kO37#cFuNh;sEmkr)R4W4vIG)Xj1Ho!c`Ua^@Em)VO2H2yG;t^o&635Z>GT9BR z;5JOv11u*+P#6rtIe#)p>)wjF4~SZz>d25EEU!x;pXNoOMaz|?xrdcQ2pW7D0x4j9aWF2CaVJ=4;^;+wKv0 zg6vz_{~SmIl%0E z)c;7Cgj4!oFN=&~(*74^_>_4^=PTlO%J&I0K@bBgVN4y&D_W6~#=y{um`q3$3Xf-Z z7$As>b;i2`hfoh7?TJd=Tm`+3i;dM$O^a@dyob=7T~PfTeoiAx^>*;i8t{fyDqwP^<~yx;u5n3F*Ahyd=a+nw1>A>nNQP)R$Z|g@2Gw? z)D-tP=~DQs1Dj@BD_xAQ!h5g~{ueh0gVK7qV!TV3ly9xPVCAx$f+fL`V!7H`Z!bzT_`vrhzwbCv2AYB4IbqM~noxM^)FXl?D zc;eY7&+pk2GfA1dM~LBKA)1Z$SthTGs1Ky~raz1C^O(PL^F07+0q((doTRBNIU+*_A|qT7EOVZ?i0%cwEKc4vVn|AF-w3a^T|K9+hA`lPC~KsdIV0CL0j-KOJypSD~BStv$e$S zk;(@mv{ME(y^Qgd#yJ_a;~C5(ZjT&ae2(HR_!dR^>=8ovizBqs&Rq$XC{0axu5q@N zIa)w17F1@zY@d0)SP7|s6+@(5av5Cfwioad9G})0VAQ&pYDg7|xYl~?t=91yf?ipd zc?mod%>e&SS7Ab?v{aa|FOX`^fiqOXtkVbvTrGhuvKjREBkqun?xY1N{YllfMCR@7?6 zbt^CPt@^yF)ruFT#4EDY1(Cx~u)yWAwqWrbEdKO?$Bam&Obw$s7l&pr8)BU}?CIH2 zVo07xF+kI2FqG#dr%^8vj3va|P42rX>Fx7*KY44ho|}NZVB)Jh!lv?{yzX|tz1RO$ zCSswd?A|14GNRcTS0=24&Cg!L@hYwROt|t~V-Q25s;eIp?F^ zRh=a7KM+RzTs<@at>Jnz^J8-sOcD90GG4DA?UO%vvj=sTTRl2=@905UC|53&%W%(* z-JPs1g>Zulx3U^e2c-RLAke$5ms=((D%b5r^$~{!S8oyX&6V=97(^2=-dXM7^UV}& zn8WBSDi>f;2bJe}1!@ni9jjc0A1zV3Y3wqn*5_IIQ z$2Bl>6vuPxceLa15!(&@lCWsULFDK^kRQktb`I1pP7&E<`EkXv#Ha?z92+}elfuXM zAtiRBVcB+2<<*={Qk7ZSyK`r(B`~yQYo`0K`IgHbYn$~x7|NDvMy+ETCr~o z24~jVpjrmDSbUpL`-L>jM`17$GpAwdTdjrytp31MqpTKrBwkWfW4wZfP6hE$Y1~xC z1%O%PXm0$@<2r3PM+Zm+Ov^%V&h~A5PKUIu;toVVF1IT-B;*UO26ll}6&IvP37YNZ zrQuX{@!GPe|4NN!vT9TRdl>cmyy8QP+K3ZALqGIxgM*1=qm zG`J+{TL1;siK$6Z!h)%$&Yn-zd62YH2`fDASLTmD*FLZ9#<|4oU5s~dV<1{jjy3E? z8J?hn&9&AGEj690t-6V~tK9T4^Xa*)W9~-Uee@$O=0WKfOk9ICoq6v~>|EfcWXng6 z((W7Q9N9VZ>7PgkWa3IU%8H*}r)}?ECu^G%MqHL>f%}4eGu~}{_c|UyvEvNj@oM1R zYg(V4Uu0N<*VVxC-5~kyHG8*uaG6p!!s7(Xa4bP>1!ZD%)dsqqy&J9dMv?fScDW46T!rUC?PqSXoTJBY3^Z7XW;-E6#XPdd6cWy zO-m{ZWv)A4z~XdODPtit%(rL(Uxh=baJ8t0`w$3N1X=KTd(e@|)g>;8^`A~0`oS6- zevM0Nrn~hM5Nc`Xpf1r@y};Z>-{pJevskG5Bl-1>;^2XW3V)Y67E~-YrvA4Cq()O_bQC_EDKk)FD&(88gd=`j2PlRo3;MfELP6+IT4}MY) z?Ra4OmM!M9SNziz`}WbN2hEu+TX2hZ_Vt}JHDJEN6J6?$n6ESsZ(IX!>*_t?x%uqA zeRzfLA2j3JAK0;F3++U59B2IsI};Hvv^4tGY#M4-mTVANUvr_g_AeyCdbyXG9y7su zlL=5R>?FDac77PxG^k){S&fpbINUJ?ITk9n)PK*7B-zL!QQC`h=QeExC6@(}8_J*N$Um zm=<{UE0O4Oy@*i+lRGHCRsGm8p{Xn}l4(FP_Ls^D(ES#Si=Y=-u3SeuTiHBWrBm)fn0cJp}_18orE@ON6fF=ZSW)%uSy#i7lW@!A$& zdVKKp&qlbd$QwKdfRU49ZgA!Ajz?a92-H)ZBbEh!Xi=>7!sT>NeE>PzwWF!RejbDi zQ6IH}()_f=DGeSN#&w_xrVw134qY!g8!8_iJPdSKBOR5vgLE*qar8#zOALrJV8DHU z78qcv3@`u?&VjQ*;zDdMz+MFGDL6EEHhBCTdlRb3&g_GZvzE{Of0lB;FB`lp`~eyT zAF2N+TCley%;jKTi)Ll+=^6$p@C#%F{L;9i8R|>RI?x?2q86UvBjhAI?K!)kE?PTO#zLkxl`<5+iTxT%W!Sau_uZBIH zrL4OpcUrzMi#4IVQ>Qex(aFl#yv9b(7NhYzzK=tGBCKT_wExyHJlisErKseDa1 z@_6MeE+DFVD46$#;2nv*E+58Trkrw%#Mm=VXT(A~@(Sd92$=C9RAZfxVk zJey@JHu$K9|9|eIFIi$U`GPQ;2_aNs+>y+sglJgjc>U%3^-=M3xqA>66)f3u24Q(E zf>X&5Sc<|Ac+pPWF~?CF{>$(F!>CFEUv*Vy%x$1h7NRkB{2TH&^VvVxy~n?`54d*w}yQ10(*+u2XxT z?pPT=CpdWU+Vet}4##^|w(WS|o?g$Yr#Bo}yYi}Q&WD_!0MBtL(*k5^_O_?A2;5~= z)h?<%m%27ASB|j~jP+nD)|@|GAE`ZsTCNKcY3=u6-RVC7mx406UTRtk^fd4-~DkfMBXKPDl|~EbG`J4 zw2U4GKK5Z*UL|4xVzd>yFl@_V4V`_{F5ZpC>y>!GIx@Df)RcO44WoLwW{#r0!G}0>TFC!MjhvM;2&1O?|~K%|5CjmH7^!k zX*a9C!ODw*8Ow6+-DuSt%R6veb;I)B*#I-f4>`|beUh}_S<+Vt)?pn6%K9r22cxL! zvzC2cVwxmDndPOR5U|g@P33CZQ{oNz9*0f+Y)`n#pgi#IlE$_az-aau2XyYk@WxCG zD;1+4B=n*asNS}bcUtwTQh`ZSu3Xd<3^r}U!6@VpuL=7JuAjH@EnNa#4}yc9IPz$F zbGWrN+}!bK;RFx{W@(~az$*-rQWeN$;2JPuQWXlb#A+@;NGKOU>K4tFv@r0Ucjlep zd%1T&+F<+7zMr~eX_U(HH$Uj=YBqn*dVsgOM!N7nG)6QwRO7r>EwOG%vEJifsRl4F z>m1zyR2~}|8oOJ%^byx89Ls>C2kZNMk}+F63C_@h$txdTDrT~S*k^1hdc|n=r!j9= z$a9M)>>;P$bFN>j_2^jnb<7j$^xop(hv$0O4o~)%ET@0@a>Pk??BHM*3^GQU=<197 z`V5Nn&dhj2UAQ)_^Y~@Bu4wZk)^nNG?^)M`RCo_{K&N5td>nnko{>-sR;b}0two#B z@=n4yf2KLLs|ARt7`tBxQ5jOWBb2)=$^+^^|5;nKe>PG z0R1i0pnZLt*W9h;WSWBqbFv<&Oc~YjL%Lq8D5p~x&YZ>SGiD69LO848P2*y`)A?FC zxd$%79??9%b9cHw)3EB;A_J0w8B!qK8#u%L5$f@JpYjm(E%KPU{@`8Pwf&C$h^;|v zTjoOxvBR19A7*q6m$o__xc@$;nfrp_;9{V@FJ@~Wi8P`Q*f%HRTdUAs*OY9r+SXvp zrp*IT_Yc4jQ~2U^wmCxRsSxa(F>G`C}2?*@}~z}y}Lf=P>&;oaT=>f z0Kwv>thyq;-qE9m)Rt8(xb}2N_bqiLJ=Nay22`U+p?;z+*Z~#*S2Vp z0)z$HMvw=30OnDEI?E;X6_8~HxtSN>!1=NB&(DX)0%PwP@IW6}vjMcS$10n=%t-0V zv9Uz3b^W%rJ)Lbk_CXgf>a+lTUl?I8&p8Q)pP)=hoCLnUlXa!txXEiOsJ33}p$yROXZ-qgZI?5ARZC#SzZr!H4Arnb1_qs$MP&d_vJ&KFcYv zqQLkhR&O>!{t%;FsQzOr2kbWUiE{8FiGhFNCe**}}%v65wR{D-_M-)TgBFr-!g;A2^;qSQz_lZf?7G=8C_(c~515rmrsCp+c*thTnVF@QShi=ElAYg6BUOoB4}SV9nIs zA2Q}uU3=(eZl)@Dc?tO9;u#@hFt2}wfVFb;!f2-!Zu`7?vaEjow!(|*k*lvhqKYe} z*S&n#T`#Zu8@i`@3lFS3Ul#NzxH6=1^gA%$IpBca2)pRe{hLRjhu92d5^utmqXyW~ z$zAQqWc#ksW1|NS;8GXM)mSyCNA>;X{rU&TKNt++QX4V9SYs%`Jy;#9oS4VM(2+zp zLfCM^@PjnQk8-J^m!QzOVemNg(&lf@$F6{KC9E#!=D)~WzolP}k8@tgu!tW%`GrS$ zS#d1BLoMgT`Z~)@EF)>5Zq*X}U*z6?Jj~{#e3>lrL`Il~Qb`S$O2S~2FKSl_*+Y)R z*ve%{zk|%ps%wqt5T0}bDXIYt%21fSstYT+x;AumyKOhTDul&Pak1;Zt*5MeAsVRgJzs+7jZ`B(+$Jds4e(}IB}R}>hWuz5ho0-!AR z^Js_qn`??sZ1@De>Wb=a7$%sDr~YBxXYi$h+@^x!7iH(LB56lhC1L*!%?|n_?(wFq{hzwGg0TC=wH>+{eT z1PzzLJ6H~CL3y$m;ex*#ZQ(U^bzI~*4u}Zx9c-vrE^$sJ$pg!*&_uPD>h5B{=@j4v z9b~{8H&lImya>j{dmYS$@o@<23UfjJ$oIg~Ag5#0>0=`&9&<;%*f=&0x?=q~diGfL~z{2sUA6zGi5PjclPgA|O@*@FY{qI-k~ zEx|0UIAn;L=e;BJG0)JhArI{_pArG{5A>V}d`vztw_6FGGq=n8#nrvNt95Z99Ko?% zc#-~U$1c`@SO4H}sL0(6fS?JyptCe|EtHDYzDF9+7xppq2@P!b2>dt%Ft(Mk+ygB+ ze~OD^rPY^JE4?MI3~7NkY(mqz#Fxi;nC0*IB4Y-!Ko6iQq61OzBE7NIA8d<&bwD;$ zpj)iGg0#vKSGhl71dk?^%gobMy(oBY*^(ba7=6!_e_rB+Or>*TBZwGtS>!=gtPCi$orTn+sZ@=i6f7pM_MZRDoUD_D*36yjQ zJS&4QSMA-Uc2%-1!K{EGi*>6zy^$T$K&v2+ay)Ald&BsY`EvH!sjI@+oEav3tzQ9d z)a@7AXHhqnxJMY~s0uStUI(q&{Q?x}s5o#i z%vLqvdlntVES>bJjp~;+PC*lSO2I`P4<5*>YW6^|$%loIwl)ZhZ-l?yf zSEE}yRcNGetTk4sRi|{6Dvy81Obm}PnsYNSP_mC8p2%+MN3x}e7U}5eZLb__@9pVO z4^@t>IIpLrrRTgA>LDw1k1r7D2n5VKyv_Xk1rcrb${+O~dpgX{_TJuhdaVOal$!CT z*@-usIYh5<=!s^p`4W=*DB=q&g}u!?DB$b#1_ItrU*J;+a+*%BfF<+j-)lE%?9Y8C z+P>L_BWhqXXJ;=Y>_v^8s|^gYBQ2;aU_=M~3@qxL!c536qind&iAU+YJE;F~vu1ag zC0CQZ+1t?aOP6LRZO^0ou8Zu@e-Le5=WDiU4qww9<|~Jf5{C01{Rl7cl!hQnvZEt9( zDTH?~MqU_cc+4qlW5Q~?7am)_5u`Zf%6drD9O3 z3gt2b&&C!o1%x)yWD>$M09>W<4>mF~u30Ms`bnfvOFUgffOLMurlPfB3>LD^I`D7@ ze8<7o9JIzJVU~#)e13;;$US?FU>{{m292<%i)sobv zSH{Kf^ZC*D;N;`EMvp_a`8|Ds{ZDQg8MyL-PwiC6ZgV^rfTgg#(Mg-UcK>@#llJd& zYW8#NjgGF?24AZkmI;u`t-LmH-hX|CY2J_<-Rp8AQ7GW@Y#O+7|C8I+x`s$|G}@1% zh!sxF_8oU4t;~+XQ5TYNo~^!fTf3m=#-~~Nx#U0yx8WJ2P|iB#s1-)%Dvw%W72&U0VGZHut*{N@ zA6sENY(HMN!VcVj#|pcZ1LU;A9;KhIbzhh@qIqL7JTV`R$I_{(bSm#Q5=PQU<*ziR z3yEmfidjDgjBGBRPKAdCH&}NrHd02mnn&))^l&~u6`snbli`bynUP4O!a0Y0i?`gfiNy|3ZoMSL3s6PE*80Ry3^~CQ;wjVVU(ChUBdWg zkxvq#i>#V)P6>p=aHz=7u18)mq#lG(KEIWLi?{XotG1+?eo(Y9iH>GjRD9gl?`c2O zPAX|+!|JXB8Uq(KkefWv9{E6Berm$1TQknoYo#^{V$fQF^c}R4R)N{G+q*DKV0x&R z)=(eyW4e3}t)+F?m2nNsejnHNoXKkUav<*8_cff*-U3cj;Mi1RELl(muMBE~Cro3VJWSkFKQm(^a$|Ho^z#YWe^jqQi6zT}#)|2Qht( z(gek5k_?)nX_}!pT~D)=pd_UzO*mhRvXrAd73c`f(G4_DAEuAcjdT;;Ot)a7eU$!$ zZl#aX$LLS#HcW=^ppVm?^a;9)?xsJZd+1*JbNVFRM}I+|qEFNP^Z@-O{TKQSJxHIW zhp0rKqtDY{(Zlp#=@|Vt`T{*d|D7JCFVbJrWAr!lI8@VLqA$}Ebez6IPtsTEYxH;Y z6g^FUPhY2RU=r|6dWN2*Z_#t~ZF-)*L*J!;pns%)qVLi7=>>X`en3B@m*_|IWBLjG zlwPKPrdQ}^^grlT`Z@iA7U-AQk^efqLI0C}MgKx?(*L4=rTQfuBk*i4! zsLg7N+N!pxL1;f$sO@Tp;*ZCSNDSnijAYY=)MV3AJoljj=-QP?Clc{YI^)Zv^U-`d zlFMh~nVc&bPs~R0Mzn!nn9RmgvrZ1-jw6+6moX-LTuI^OQds# zZ!!|iX47-Brrv6d8{w7@YJ!vLxs<0Sxl4u%8Ew{>w-r#lqmW9ZW3x8CX!&%e0biN5 zi$k23UBJXP5sl3{CerzQI_Z@^GM&eYh+>m~cqGLzv~jQrRW3}IU_RUv_kF~BYI>$l8wew4GGSgyT&a-;--5pj_fn( zIU{Qa#>8fv;u;yU=i^Bu>xp8lOLB>^S#L6mHl<_HJcc^Ig!5wD8=ah7jI>r$MdBDc zvq|wr)8b7FG3=Q{G-kMfPOTG(H)bjptqYY&tVD9~pAUfIVqUMiWkP zjSMy90AEp2Eg6rwCZaiGA`0@zrDHK8>jJjsIqt@TSwjR}xqLJm0j>CA>CAj&G94@M zXzpREisV2cM#`6)ivs|Wi2}MQrA6aOTMU(Or6Nf;~S|NKQDWjAS%n*!W_fF2pAd+l-OO*iyz^ z&X${rXYBcGAvWurh{xsuwuVerFwN++?Dj$`@0deJ8F^bQ9Z%Vl0K!QHUp)GkNoAu%Ub;17@DZ`*~v`ot}*hF9nC}Q%I3x zMxBs=YseZgBYp&L`!n$vz`KYxZKuWMz~s&qfQ>-x$dIcVv?0@^*O-jwtLW9ZR6ryj zo%T&e^HDI2XktDW&oyM?jHm#JTil;WGyY)g<2HDb(dl>$qZ=4Js+rE>CdMgr0YK0o z(ldhCC$fdyj1ydB5}4samqYYTL|wU9JO`GX^BzH;r_ozr7Ey=f&(3H*pN+=yPIPA+ zL!9fw>2#87>=c1`3P={s#%3JyEpI+LYeeUw^AYauLWbG@u#34bhZ+QsV;GWw32}(X zS#OniBj7nmCn>q98jz%EO!}5?fa3j&G0C`=;*y4)3(6xbubjFM!pB0rw6ftdIuaC78`*;f*LIGsWmZ$cJhE}M%K(BQ + + + + + + + + 用户注册 + + + + + + + + + +
+ + + + + \ No newline at end of file diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/js/app.6d7e7596.js b/src/main/resources/com/fr/plugin/sxka/sso/registe/js/app.6d7e7596.js new file mode 100644 index 0000000..b7f1733 --- /dev/null +++ b/src/main/resources/com/fr/plugin/sxka/sso/registe/js/app.6d7e7596.js @@ -0,0 +1,2 @@ +(function(e){function t(t){for(var n,r,i=t[0],c=t[1],s=t[2],d=0,f=[];d\n
\n
\n
\n
\n 国际贸易”单一窗口“大数据分析平台-功能注册\n
\n
\n\n \n
\n \n
\n
\n \n \n
\n \n \n
\n \n {{ item.roleDescn }}\n
\n
\n \n
\n \n \n
\n
\n \n 下一步\n
\n \n\n \n \n \n \n \n \n
\n
\n \n 保存\n
\n \n
\n\n\n\n\n\n\n","import mod from \"-!../node_modules/cache-loader/dist/cjs.js??ref--13-0!../node_modules/thread-loader/dist/cjs.js!../node_modules/babel-loader/lib/index.js!../node_modules/cache-loader/dist/cjs.js??ref--1-0!../node_modules/vue-loader/lib/index.js??vue-loader-options!./App.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../node_modules/cache-loader/dist/cjs.js??ref--13-0!../node_modules/thread-loader/dist/cjs.js!../node_modules/babel-loader/lib/index.js!../node_modules/cache-loader/dist/cjs.js??ref--1-0!../node_modules/vue-loader/lib/index.js??vue-loader-options!./App.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./App.vue?vue&type=template&id=6987be1c&\"\nimport script from \"./App.vue?vue&type=script&lang=js&\"\nexport * from \"./App.vue?vue&type=script&lang=js&\"\nimport style0 from \"./App.vue?vue&type=style&index=0&lang=css&\"\n\n\n/* normalize component */\nimport normalizer from \"!../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n script,\n render,\n staticRenderFns,\n false,\n null,\n null,\n null\n \n)\n\nexport default component.exports","import Vue from 'vue'\nimport App from './App.vue'\nimport ElementUI from 'element-ui';\nimport 'element-ui/lib/theme-chalk/index.css';\n\nVue.use(ElementUI);\n\nVue.config.productionTip = false\n\nnew Vue({\n render: h => h(App),\n}).$mount('#app')\n"],"sourceRoot":""} \ No newline at end of file diff --git a/src/main/resources/com/fr/plugin/sxka/sso/registe/js/chunk-vendors.98ebceb7.js b/src/main/resources/com/fr/plugin/sxka/sso/registe/js/chunk-vendors.98ebceb7.js new file mode 100644 index 0000000..cfeacf3 --- /dev/null +++ b/src/main/resources/com/fr/plugin/sxka/sso/registe/js/chunk-vendors.98ebceb7.js @@ -0,0 +1,47 @@ +(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-vendors"],{"00ee":function(e,t,n){var i=n("b622"),r=i("toStringTag"),o={};o[r]="z",e.exports="[object z]"===String(o)},"01b4":function(e,t){var n=function(){this.head=null,this.tail=null};n.prototype={add:function(e){var t={item:e,next:null};this.head?this.tail.next=t:this.head=t,this.tail=t},get:function(){var e=this.head;if(e)return this.head=e.next,this.tail===e&&(this.tail=null),e.item}},e.exports=n},"0366":function(e,t,n){var i=n("e330"),r=n("59ed"),o=i(i.bind);e.exports=function(e,t){return r(e),void 0===t?e:o?o(e,t):function(){return e.apply(t,arguments)}}},"03d6":function(e,t,n){var i=n("9c0e"),r=n("6ca1"),o=n("39ad")(!1),a=n("5a94")("IE_PROTO");e.exports=function(e,t){var n,s=r(e),l=0,c=[];for(n in s)n!=a&&i(s,n)&&c.push(n);while(t.length>l)i(s,n=t[l++])&&(~o(c,n)||c.push(n));return c}},"051b":function(e,t,n){var i=n("1a14"),r=n("10db");e.exports=n("0bad")?function(e,t,n){return i.f(e,t,r(1,n))}:function(e,t,n){return e[t]=n,e}},"05f5":function(e,t,n){var i=n("7a41"),r=n("ef08").document,o=i(r)&&i(r.createElement);e.exports=function(e){return o?r.createElement(e):{}}},"06cf":function(e,t,n){var i=n("83ab"),r=n("c65b"),o=n("d1e7"),a=n("5c6c"),s=n("fc6a"),l=n("a04b"),c=n("1a2d"),u=n("0cfb"),d=Object.getOwnPropertyDescriptor;t.f=i?d:function(e,t){if(e=s(e),t=l(t),u)try{return d(e,t)}catch(n){}if(c(e,t))return a(!r(o.f,e,t),e[t])}},"072d":function(e,t,n){"use strict";var i=n("0bad"),r=n("9876"),o=n("fed5"),a=n("1917"),s=n("0983"),l=n("9fbb"),c=Object.assign;e.exports=!c||n("4b8b")((function(){var e={},t={},n=Symbol(),i="abcdefghijklmnopqrst";return e[n]=7,i.split("").forEach((function(e){t[e]=e})),7!=c({},e)[n]||Object.keys(c({},t)).join("")!=i}))?function(e,t){var n=s(e),c=arguments.length,u=1,d=o.f,h=a.f;while(c>u){var f,p=l(arguments[u++]),m=d?r(p).concat(d(p)):r(p),v=m.length,g=0;while(v>g)f=m[g++],i&&!h.call(p,f)||(n[f]=p[f])}return n}:c},"07fa":function(e,t,n){var i=n("50c4");e.exports=function(e){return i(e.length)}},"0983":function(e,t,n){var i=n("c901");e.exports=function(e){return Object(i(e))}},"0ae2":function(e,t,n){var i=n("9876"),r=n("fed5"),o=n("1917");e.exports=function(e){var t=i(e),n=r.f;if(n){var a,s=n(e),l=o.f,c=0;while(s.length>c)l.call(e,a=s[c++])&&t.push(a)}return t}},"0b42":function(e,t,n){var i=n("da84"),r=n("e8b5"),o=n("68ee"),a=n("861d"),s=n("b622"),l=s("species"),c=i.Array;e.exports=function(e){var t;return r(e)&&(t=e.constructor,o(t)&&(t===c||r(t.prototype))?t=void 0:a(t)&&(t=t[l],null===t&&(t=void 0))),void 0===t?c:t}},"0b99":function(e,t,n){"use strict";var i=n("19fa")(!0);n("393a")(String,"String",(function(e){this._t=String(e),this._i=0}),(function(){var e,t=this._t,n=this._i;return n>=t.length?{value:void 0,done:!0}:(e=i(t,n),this._i+=e.length,{value:e,done:!1})}))},"0bad":function(e,t,n){e.exports=!n("4b8b")((function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a}))},"0cfb":function(e,t,n){var i=n("83ab"),r=n("d039"),o=n("cc12");e.exports=!i&&!r((function(){return 7!=Object.defineProperty(o("div"),"a",{get:function(){return 7}}).a}))},"0d51":function(e,t,n){var i=n("da84"),r=i.String;e.exports=function(e){try{return r(e)}catch(t){return"Object"}}},"0e15":function(e,t,n){var i=n("597f");e.exports=function(e,t,n){return void 0===n?i(e,t,!1):i(e,n,!1!==t)}},"0fae":function(e,t,n){},"107c":function(e,t,n){var i=n("d039"),r=n("da84"),o=r.RegExp;e.exports=i((function(){var e=o("(?b)","g");return"b"!==e.exec("b").groups.a||"bc"!=="b".replace(e,"$c")}))},1098:function(e,t,n){"use strict";t.__esModule=!0;var i=n("17ed"),r=l(i),o=n("f893"),a=l(o),s="function"===typeof a.default&&"symbol"===typeof r.default?function(e){return typeof e}:function(e){return e&&"function"===typeof a.default&&e.constructor===a.default&&e!==a.default.prototype?"symbol":typeof e};function l(e){return e&&e.__esModule?e:{default:e}}t.default="function"===typeof a.default&&"symbol"===s(r.default)?function(e){return"undefined"===typeof e?"undefined":s(e)}:function(e){return e&&"function"===typeof a.default&&e.constructor===a.default&&e!==a.default.prototype?"symbol":"undefined"===typeof e?"undefined":s(e)}},"10db":function(e,t){e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},1157:function(e,t,n){var i,r; +/*! + * jQuery JavaScript Library v3.6.0 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright OpenJS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2021-03-02T17:08Z + */(function(t,n){"use strict";"object"===typeof e.exports?e.exports=t.document?n(t,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return n(e)}:n(t)})("undefined"!==typeof window?window:this,(function(n,o){"use strict";var a=[],s=Object.getPrototypeOf,l=a.slice,c=a.flat?function(e){return a.flat.call(e)}:function(e){return a.concat.apply([],e)},u=a.push,d=a.indexOf,h={},f=h.toString,p=h.hasOwnProperty,m=p.toString,v=m.call(Object),g={},b=function(e){return"function"===typeof e&&"number"!==typeof e.nodeType&&"function"!==typeof e.item},y=function(e){return null!=e&&e===e.window},x=n.document,_={type:!0,src:!0,nonce:!0,noModule:!0};function w(e,t,n){n=n||x;var i,r,o=n.createElement("script");if(o.text=e,t)for(i in _)r=t[i]||t.getAttribute&&t.getAttribute(i),r&&o.setAttribute(i,r);n.head.appendChild(o).parentNode.removeChild(o)}function C(e){return null==e?e+"":"object"===typeof e||"function"===typeof e?h[f.call(e)]||"object":typeof e}var k="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function O(e){var t=!!e&&"length"in e&&e.length,n=C(e);return!b(e)&&!y(e)&&("array"===n||0===t||"number"===typeof t&&t>0&&t-1 in e)}S.fn=S.prototype={jquery:k,constructor:S,length:0,toArray:function(){return l.call(this)},get:function(e){return null==e?l.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(e){return this.pushStack(S.map(this,(function(t,n){return e.call(t,n,t)})))},slice:function(){return this.pushStack(l.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,(function(e,t){return(t+1)%2})))},odd:function(){return this.pushStack(S.grep(this,(function(e,t){return t%2})))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n+~]|"+L+")"+L+"*"),q=new RegExp(L+"|>"),Y=new RegExp(B),U=new RegExp("^"+F+"$"),K={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),TAG:new RegExp("^("+F+"|[*])"),ATTR:new RegExp("^"+V),PSEUDO:new RegExp("^"+B),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+A+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},G=/HTML$/i,X=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,Q=/^[^{]+\{\s*\[native \w/,J=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+L+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},ie=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,re=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){h()},ae=xe((function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()}),{dir:"parentNode",next:"legend"});try{M.apply(T=j.call(_.childNodes),_.childNodes),T[_.childNodes.length].nodeType}catch(Ee){M={apply:T.length?function(e,t){N.apply(e,j.call(t))}:function(e,t){var n=e.length,i=0;while(e[n++]=t[i++]);e.length=n-1}}}function se(e,t,i,r){var o,s,c,u,d,p,g,b=t&&t.ownerDocument,_=t?t.nodeType:9;if(i=i||[],"string"!==typeof e||!e||1!==_&&9!==_&&11!==_)return i;if(!r&&(h(t),t=t||f,m)){if(11!==_&&(d=J.exec(e)))if(o=d[1]){if(9===_){if(!(c=t.getElementById(o)))return i;if(c.id===o)return i.push(c),i}else if(b&&(c=b.getElementById(o))&&y(t,c)&&c.id===o)return i.push(c),i}else{if(d[2])return M.apply(i,t.getElementsByTagName(e)),i;if((o=d[3])&&n.getElementsByClassName&&t.getElementsByClassName)return M.apply(i,t.getElementsByClassName(o)),i}if(n.qsa&&!E[e+" "]&&(!v||!v.test(e))&&(1!==_||"object"!==t.nodeName.toLowerCase())){if(g=e,b=t,1===_&&(q.test(e)||W.test(e))){b=ee.test(e)&&ge(t.parentNode)||t,b===t&&n.scope||((u=t.getAttribute("id"))?u=u.replace(ie,re):t.setAttribute("id",u=x)),p=a(e),s=p.length;while(s--)p[s]=(u?"#"+u:":scope")+" "+ye(p[s]);g=p.join(",")}try{return M.apply(i,b.querySelectorAll(g)),i}catch(w){E(e,!0)}finally{u===x&&t.removeAttribute("id")}}}return l(e.replace(R,"$1"),t,i,r)}function le(){var e=[];function t(n,r){return e.push(n+" ")>i.cacheLength&&delete t[e.shift()],t[n+" "]=r}return t}function ce(e){return e[x]=!0,e}function ue(e){var t=f.createElement("fieldset");try{return!!e(t)}catch(Ee){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function de(e,t){var n=e.split("|"),r=n.length;while(r--)i.attrHandle[n[r]]=t}function he(e,t){var n=t&&e,i=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(i)return i;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function fe(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function pe(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function me(e){return function(t){return"form"in t?t.parentNode&&!1===t.disabled?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&ae(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function ve(e){return ce((function(t){return t=+t,ce((function(n,i){var r,o=e([],n.length,t),a=o.length;while(a--)n[r=o[a]]&&(n[r]=!(i[r]=n[r]))}))}))}function ge(e){return e&&"undefined"!==typeof e.getElementsByTagName&&e}for(t in n=se.support={},o=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!G.test(t||n&&n.nodeName||"HTML")},h=se.setDocument=function(e){var t,r,a=e?e.ownerDocument||e:_;return a!=f&&9===a.nodeType&&a.documentElement?(f=a,p=f.documentElement,m=!o(f),_!=f&&(r=f.defaultView)&&r.top!==r&&(r.addEventListener?r.addEventListener("unload",oe,!1):r.attachEvent&&r.attachEvent("onunload",oe)),n.scope=ue((function(e){return p.appendChild(e).appendChild(f.createElement("div")),"undefined"!==typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length})),n.attributes=ue((function(e){return e.className="i",!e.getAttribute("className")})),n.getElementsByTagName=ue((function(e){return e.appendChild(f.createComment("")),!e.getElementsByTagName("*").length})),n.getElementsByClassName=Q.test(f.getElementsByClassName),n.getById=ue((function(e){return p.appendChild(e).id=x,!f.getElementsByName||!f.getElementsByName(x).length})),n.getById?(i.filter["ID"]=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},i.find["ID"]=function(e,t){if("undefined"!==typeof t.getElementById&&m){var n=t.getElementById(e);return n?[n]:[]}}):(i.filter["ID"]=function(e){var t=e.replace(te,ne);return function(e){var n="undefined"!==typeof e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},i.find["ID"]=function(e,t){if("undefined"!==typeof t.getElementById&&m){var n,i,r,o=t.getElementById(e);if(o){if(n=o.getAttributeNode("id"),n&&n.value===e)return[o];r=t.getElementsByName(e),i=0;while(o=r[i++])if(n=o.getAttributeNode("id"),n&&n.value===e)return[o]}return[]}}),i.find["TAG"]=n.getElementsByTagName?function(e,t){return"undefined"!==typeof t.getElementsByTagName?t.getElementsByTagName(e):n.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,i=[],r=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[r++])1===n.nodeType&&i.push(n);return i}return o},i.find["CLASS"]=n.getElementsByClassName&&function(e,t){if("undefined"!==typeof t.getElementsByClassName&&m)return t.getElementsByClassName(e)},g=[],v=[],(n.qsa=Q.test(f.querySelectorAll))&&(ue((function(e){var t;p.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+L+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+L+"*(?:value|"+A+")"),e.querySelectorAll("[id~="+x+"-]").length||v.push("~="),t=f.createElement("input"),t.setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+L+"*name"+L+"*="+L+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+x+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")})),ue((function(e){e.innerHTML="";var t=f.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+L+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),p.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")}))),(n.matchesSelector=Q.test(b=p.matches||p.webkitMatchesSelector||p.mozMatchesSelector||p.oMatchesSelector||p.msMatchesSelector))&&ue((function(e){n.disconnectedMatch=b.call(e,"*"),b.call(e,"[s!='']:x"),g.push("!=",B)})),v=v.length&&new RegExp(v.join("|")),g=g.length&&new RegExp(g.join("|")),t=Q.test(p.compareDocumentPosition),y=t||Q.test(p.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,i=t&&t.parentNode;return e===i||!(!i||1!==i.nodeType||!(n.contains?n.contains(i):e.compareDocumentPosition&&16&e.compareDocumentPosition(i)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return d=!0,0;var i=!e.compareDocumentPosition-!t.compareDocumentPosition;return i||(i=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1,1&i||!n.sortDetached&&t.compareDocumentPosition(e)===i?e==f||e.ownerDocument==_&&y(_,e)?-1:t==f||t.ownerDocument==_&&y(_,t)?1:u?I(u,e)-I(u,t):0:4&i?-1:1)}:function(e,t){if(e===t)return d=!0,0;var n,i=0,r=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!r||!o)return e==f?-1:t==f?1:r?-1:o?1:u?I(u,e)-I(u,t):0;if(r===o)return he(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[i]===s[i])i++;return i?he(a[i],s[i]):a[i]==_?-1:s[i]==_?1:0},f):f},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(h(e),n.matchesSelector&&m&&!E[t+" "]&&(!g||!g.test(t))&&(!v||!v.test(t)))try{var i=b.call(e,t);if(i||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return i}catch(Ee){E(t,!0)}return se(t,f,null,[e]).length>0},se.contains=function(e,t){return(e.ownerDocument||e)!=f&&h(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=f&&h(e);var r=i.attrHandle[t.toLowerCase()],o=r&&$.call(i.attrHandle,t.toLowerCase())?r(e,t,!m):void 0;return void 0!==o?o:n.attributes||!m?e.getAttribute(t):(o=e.getAttributeNode(t))&&o.specified?o.value:null},se.escape=function(e){return(e+"").replace(ie,re)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,i=[],r=0,o=0;if(d=!n.detectDuplicates,u=!n.sortStable&&e.slice(0),e.sort(D),d){while(t=e[o++])t===e[o]&&(r=i.push(o));while(r--)e.splice(i[r],1)}return u=null,e},r=se.getText=function(e){var t,n="",i=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"===typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=r(e)}else if(3===o||4===o)return e.nodeValue}else while(t=e[i++])n+=r(t);return n},i=se.selectors={cacheLength:50,createPseudo:ce,match:K,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return K["CHILD"].test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&Y.test(n)&&(t=a(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=k[e+" "];return t||(t=new RegExp("(^|"+L+")"+e+"("+L+"|$)"))&&k(e,(function(e){return t.test("string"===typeof e.className&&e.className||"undefined"!==typeof e.getAttribute&&e.getAttribute("class")||"")}))},ATTR:function(e,t,n){return function(i){var r=se.attr(i,e);return null==r?"!="===t:!t||(r+="","="===t?r===n:"!="===t?r!==n:"^="===t?n&&0===r.indexOf(n):"*="===t?n&&r.indexOf(n)>-1:"$="===t?n&&r.slice(-n.length)===n:"~="===t?(" "+r.replace(z," ")+" ").indexOf(n)>-1:"|="===t&&(r===n||r.slice(0,n.length+1)===n+"-"))}},CHILD:function(e,t,n,i,r){var o="nth"!==e.slice(0,3),a="last"!==e.slice(-4),s="of-type"===t;return 1===i&&0===r?function(e){return!!e.parentNode}:function(t,n,l){var c,u,d,h,f,p,m=o!==a?"nextSibling":"previousSibling",v=t.parentNode,g=s&&t.nodeName.toLowerCase(),b=!l&&!s,y=!1;if(v){if(o){while(m){h=t;while(h=h[m])if(s?h.nodeName.toLowerCase()===g:1===h.nodeType)return!1;p=m="only"===e&&!p&&"nextSibling"}return!0}if(p=[a?v.firstChild:v.lastChild],a&&b){h=v,d=h[x]||(h[x]={}),u=d[h.uniqueID]||(d[h.uniqueID]={}),c=u[e]||[],f=c[0]===w&&c[1],y=f&&c[2],h=f&&v.childNodes[f];while(h=++f&&h&&h[m]||(y=f=0)||p.pop())if(1===h.nodeType&&++y&&h===t){u[e]=[w,f,y];break}}else if(b&&(h=t,d=h[x]||(h[x]={}),u=d[h.uniqueID]||(d[h.uniqueID]={}),c=u[e]||[],f=c[0]===w&&c[1],y=f),!1===y)while(h=++f&&h&&h[m]||(y=f=0)||p.pop())if((s?h.nodeName.toLowerCase()===g:1===h.nodeType)&&++y&&(b&&(d=h[x]||(h[x]={}),u=d[h.uniqueID]||(d[h.uniqueID]={}),u[e]=[w,y]),h===t))break;return y-=r,y===i||y%i===0&&y/i>=0}}},PSEUDO:function(e,t){var n,r=i.pseudos[e]||i.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return r[x]?r(t):r.length>1?(n=[e,e,"",t],i.setFilters.hasOwnProperty(e.toLowerCase())?ce((function(e,n){var i,o=r(e,t),a=o.length;while(a--)i=I(e,o[a]),e[i]=!(n[i]=o[a])})):function(e){return r(e,0,n)}):r}},pseudos:{not:ce((function(e){var t=[],n=[],i=s(e.replace(R,"$1"));return i[x]?ce((function(e,t,n,r){var o,a=i(e,null,r,[]),s=e.length;while(s--)(o=a[s])&&(e[s]=!(t[s]=o))})):function(e,r,o){return t[0]=e,i(t,null,o,n),t[0]=null,!n.pop()}})),has:ce((function(e){return function(t){return se(e,t).length>0}})),contains:ce((function(e){return e=e.replace(te,ne),function(t){return(t.textContent||r(t)).indexOf(e)>-1}})),lang:ce((function(e){return U.test(e||"")||se.error("unsupported lang: "+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=m?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-")}while((t=t.parentNode)&&1===t.nodeType);return!1}})),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===p},focus:function(e){return e===f.activeElement&&(!f.hasFocus||f.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:me(!1),disabled:me(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!i.pseudos["empty"](e)},header:function(e){return Z.test(e.nodeName)},input:function(e){return X.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve((function(){return[0]})),last:ve((function(e,t){return[t-1]})),eq:ve((function(e,t,n){return[n<0?n+t:n]})),even:ve((function(e,t){for(var n=0;nt?t:n;--i>=0;)e.push(i);return e})),gt:ve((function(e,t,n){for(var i=n<0?n+t:n;++i1?function(t,n,i){var r=e.length;while(r--)if(!e[r](t,n,i))return!1;return!0}:e[0]}function we(e,t,n){for(var i=0,r=t.length;i-1&&(o[c]=!(a[c]=d))}}else g=Ce(g===a?g.splice(p,g.length):g),r?r(null,a,g,l):M.apply(a,g)}))}function Se(e){for(var t,n,r,o=e.length,a=i.relative[e[0].type],s=a||i.relative[" "],l=a?1:0,u=xe((function(e){return e===t}),s,!0),d=xe((function(e){return I(t,e)>-1}),s,!0),h=[function(e,n,i){var r=!a&&(i||n!==c)||((t=n).nodeType?u(e,n,i):d(e,n,i));return t=null,r}];l1&&_e(h),l>1&&ye(e.slice(0,l-1).concat({value:" "===e[l-2].type?"*":""})).replace(R,"$1"),n,l0,r=e.length>0,o=function(o,a,s,l,u){var d,p,v,g=0,b="0",y=o&&[],x=[],_=c,C=o||r&&i.find["TAG"]("*",u),k=w+=null==_?1:Math.random()||.1,S=C.length;for(u&&(c=a==f||a||u);b!==S&&null!=(d=C[b]);b++){if(r&&d){p=0,a||d.ownerDocument==f||(h(d),s=!m);while(v=e[p++])if(v(d,a||f,s)){l.push(d);break}u&&(w=k)}n&&((d=!v&&d)&&g--,o&&y.push(d))}if(g+=b,n&&b!==g){p=0;while(v=t[p++])v(y,x,a,s);if(o){if(g>0)while(b--)y[b]||x[b]||(x[b]=P.call(l));x=Ce(x)}M.apply(l,x),u&&!o&&x.length>0&&g+t.length>1&&se.uniqueSort(l)}return u&&(w=k,c=_),y};return n?ce(o):o}return be.prototype=i.filters=i.pseudos,i.setFilters=new be,a=se.tokenize=function(e,t){var n,r,o,a,s,l,c,u=S[e+" "];if(u)return t?0:u.slice(0);s=e,l=[],c=i.preFilter;while(s){for(a in n&&!(r=H.exec(s))||(r&&(s=s.slice(r[0].length)||s),l.push(o=[])),n=!1,(r=W.exec(s))&&(n=r.shift(),o.push({value:n,type:r[0].replace(R," ")}),s=s.slice(n.length)),i.filter)!(r=K[a].exec(s))||c[a]&&!(r=c[a](r))||(n=r.shift(),o.push({value:n,type:a,matches:r}),s=s.slice(n.length));if(!n)break}return t?s.length:s?se.error(e):S(e,l).slice(0)},s=se.compile=function(e,t){var n,i=[],r=[],o=O[e+" "];if(!o){t||(t=a(e)),n=t.length;while(n--)o=Se(t[n]),o[x]?i.push(o):r.push(o);o=O(e,Oe(r,i)),o.selector=e}return o},l=se.select=function(e,t,n,r){var o,l,c,u,d,h="function"===typeof e&&e,f=!r&&a(e=h.selector||e);if(n=n||[],1===f.length){if(l=f[0]=f[0].slice(0),l.length>2&&"ID"===(c=l[0]).type&&9===t.nodeType&&m&&i.relative[l[1].type]){if(t=(i.find["ID"](c.matches[0].replace(te,ne),t)||[])[0],!t)return n;h&&(t=t.parentNode),e=e.slice(l.shift().value.length)}o=K["needsContext"].test(e)?0:l.length;while(o--){if(c=l[o],i.relative[u=c.type])break;if((d=i.find[u])&&(r=d(c.matches[0].replace(te,ne),ee.test(l[0].type)&&ge(t.parentNode)||t))){if(l.splice(o,1),e=r.length&&ye(l),!e)return M.apply(n,r),n;break}}}return(h||s(e,f))(r,t,!m,n,!t||ee.test(e)&&ge(t.parentNode)||t),n},n.sortStable=x.split("").sort(D).join("")===x,n.detectDuplicates=!!d,h(),n.sortDetached=ue((function(e){return 1&e.compareDocumentPosition(f.createElement("fieldset"))})),ue((function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")}))||de("type|href|height|width",(function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)})),n.attributes&&ue((function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")}))||de("value",(function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue})),ue((function(e){return null==e.getAttribute("disabled")}))||de(A,(function(e,t,n){var i;if(!n)return!0===e[t]?t.toLowerCase():(i=e.getAttributeNode(t))&&i.specified?i.value:null})),se}(n);S.find=E,S.expr=E.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=E.uniqueSort,S.text=E.getText,S.isXMLDoc=E.isXML,S.contains=E.contains,S.escapeSelector=E.escape;var D=function(e,t,n){var i=[],r=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(r&&S(e).is(n))break;i.push(e)}return i},$=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},T=S.expr.match.needsContext;function P(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function M(e,t,n){return b(t)?S.grep(e,(function(e,i){return!!t.call(e,i,e)!==n})):t.nodeType?S.grep(e,(function(e){return e===t!==n})):"string"!==typeof t?S.grep(e,(function(e){return d.call(t,e)>-1!==n})):S.filter(t,e,n)}S.filter=function(e,t,n){var i=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===i.nodeType?S.find.matchesSelector(i,e)?[i]:[]:S.find.matches(e,S.grep(t,(function(e){return 1===e.nodeType})))},S.fn.extend({find:function(e){var t,n,i=this.length,r=this;if("string"!==typeof e)return this.pushStack(S(e).filter((function(){for(t=0;t1?S.uniqueSort(n):n},filter:function(e){return this.pushStack(M(this,e||[],!1))},not:function(e){return this.pushStack(M(this,e||[],!0))},is:function(e){return!!M(this,"string"===typeof e&&T.test(e)?S(e):e||[],!1).length}});var j,I=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,A=S.fn.init=function(e,t,n){var i,r;if(!e)return this;if(n=n||j,"string"===typeof e){if(i="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:I.exec(e),!i||!i[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(i[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(i[1],t&&t.nodeType?t.ownerDocument||t:x,!0)),N.test(i[1])&&S.isPlainObject(t))for(i in t)b(this[i])?this[i](t[i]):this.attr(i,t[i]);return this}return r=x.getElementById(i[2]),r&&(this[0]=r,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):b(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)};A.prototype=S.fn,j=S(x);var L=/^(?:parents|prev(?:Until|All))/,F={children:!0,contents:!0,next:!0,prev:!0};function V(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter((function(){for(var e=0;e-1:1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(o.length>1?S.uniqueSort(o):o)},index:function(e){return e?"string"===typeof e?d.call(S(e),this[0]):d.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return D(e,"parentNode")},parentsUntil:function(e,t,n){return D(e,"parentNode",n)},next:function(e){return V(e,"nextSibling")},prev:function(e){return V(e,"previousSibling")},nextAll:function(e){return D(e,"nextSibling")},prevAll:function(e){return D(e,"previousSibling")},nextUntil:function(e,t,n){return D(e,"nextSibling",n)},prevUntil:function(e,t,n){return D(e,"previousSibling",n)},siblings:function(e){return $((e.parentNode||{}).firstChild,e)},children:function(e){return $(e.firstChild)},contents:function(e){return null!=e.contentDocument&&s(e.contentDocument)?e.contentDocument:(P(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},(function(e,t){S.fn[e]=function(n,i){var r=S.map(this,t,n);return"Until"!==e.slice(-5)&&(i=n),i&&"string"===typeof i&&(r=S.filter(i,r)),this.length>1&&(F[e]||S.uniqueSort(r),L.test(e)&&r.reverse()),this.pushStack(r)}}));var B=/[^\x20\t\r\n\f]+/g;function z(e){var t={};return S.each(e.match(B)||[],(function(e,n){t[n]=!0})),t}function R(e){return e}function H(e){throw e}function W(e,t,n,i){var r;try{e&&b(r=e.promise)?r.call(e).done(t).fail(n):e&&b(r=e.then)?r.call(e,t,n):t.apply(void 0,[e].slice(i))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(e){e="string"===typeof e?z(e):S.extend({},e);var t,n,i,r,o=[],a=[],s=-1,l=function(){for(r=r||e.once,i=t=!0;a.length;s=-1){n=a.shift();while(++s-1)o.splice(n,1),n<=s&&s--})),this},has:function(e){return e?S.inArray(e,o)>-1:o.length>0},empty:function(){return o&&(o=[]),this},disable:function(){return r=a=[],o=n="",this},disabled:function(){return!o},lock:function(){return r=a=[],n||t||(o=n=""),this},locked:function(){return!!r},fireWith:function(e,n){return r||(n=n||[],n=[e,n.slice?n.slice():n],a.push(n),t||l()),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!i}};return c},S.extend({Deferred:function(e){var t=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",r={state:function(){return i},always:function(){return o.done(arguments).fail(arguments),this},catch:function(e){return r.then(null,e)},pipe:function(){var e=arguments;return S.Deferred((function(n){S.each(t,(function(t,i){var r=b(e[i[4]])&&e[i[4]];o[i[1]]((function(){var e=r&&r.apply(this,arguments);e&&b(e.promise)?e.promise().progress(n.notify).done(n.resolve).fail(n.reject):n[i[0]+"With"](this,r?[e]:arguments)}))})),e=null})).promise()},then:function(e,i,r){var o=0;function a(e,t,i,r){return function(){var s=this,l=arguments,c=function(){var n,c;if(!(e=o&&(i!==H&&(s=void 0,l=[n]),t.rejectWith(s,l))}};e?u():(S.Deferred.getStackHook&&(u.stackTrace=S.Deferred.getStackHook()),n.setTimeout(u))}}return S.Deferred((function(n){t[0][3].add(a(0,n,b(r)?r:R,n.notifyWith)),t[1][3].add(a(0,n,b(e)?e:R)),t[2][3].add(a(0,n,b(i)?i:H))})).promise()},promise:function(e){return null!=e?S.extend(e,r):r}},o={};return S.each(t,(function(e,n){var a=n[2],s=n[5];r[n[1]]=a.add,s&&a.add((function(){i=s}),t[3-e][2].disable,t[3-e][3].disable,t[0][2].lock,t[0][3].lock),a.add(n[3].fire),o[n[0]]=function(){return o[n[0]+"With"](this===o?void 0:this,arguments),this},o[n[0]+"With"]=a.fireWith})),r.promise(o),e&&e.call(o,o),o},when:function(e){var t=arguments.length,n=t,i=Array(n),r=l.call(arguments),o=S.Deferred(),a=function(e){return function(n){i[e]=this,r[e]=arguments.length>1?l.call(arguments):n,--t||o.resolveWith(i,r)}};if(t<=1&&(W(e,o.done(a(n)).resolve,o.reject,!t),"pending"===o.state()||b(r[n]&&r[n].then)))return o.then();while(n--)W(r[n],a(n),o.reject);return o.promise()}});var q=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){n.console&&n.console.warn&&e&&q.test(e.name)&&n.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){n.setTimeout((function(){throw e}))};var Y=S.Deferred();function U(){x.removeEventListener("DOMContentLoaded",U),n.removeEventListener("load",U),S.ready()}S.fn.ready=function(e){return Y.then(e).catch((function(e){S.readyException(e)})),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0,!0!==e&&--S.readyWait>0||Y.resolveWith(x,[S]))}}),S.ready.then=Y.then,"complete"===x.readyState||"loading"!==x.readyState&&!x.documentElement.doScroll?n.setTimeout(S.ready):(x.addEventListener("DOMContentLoaded",U),n.addEventListener("load",U));var K=function(e,t,n,i,r,o,a){var s=0,l=e.length,c=null==n;if("object"===C(n))for(s in r=!0,n)K(e,t,s,n[s],!0,o,a);else if(void 0!==i&&(r=!0,b(i)||(a=!0),c&&(a?(t.call(e,i),t=null):(c=t,t=function(e,t,n){return c.call(S(e),n)})),t))for(;s1,null,!0)},removeData:function(e){return this.each((function(){ne.remove(this,e)}))}}),S.extend({queue:function(e,t,n){var i;if(e)return t=(t||"fx")+"queue",i=te.get(e,t),n&&(!i||Array.isArray(n)?i=te.access(e,t,S.makeArray(n)):i.push(n)),i||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),i=n.length,r=n.shift(),o=S._queueHooks(e,t),a=function(){S.dequeue(e,t)};"inprogress"===r&&(r=n.shift(),i--),r&&("fx"===t&&n.unshift("inprogress"),delete o.stop,r.call(e,a,o)),!i&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return te.get(e,n)||te.access(e,n,{empty:S.Callbacks("once memory").add((function(){te.remove(e,[t+"queue",n])}))})}}),S.fn.extend({queue:function(e,t){var n=2;return"string"!==typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]*)/i,xe=/^$|^module$|\/(?:java|ecma)script/i;(function(){var e=x.createDocumentFragment(),t=e.appendChild(x.createElement("div")),n=x.createElement("input");n.setAttribute("type","radio"),n.setAttribute("checked","checked"),n.setAttribute("name","t"),t.appendChild(n),g.checkClone=t.cloneNode(!0).cloneNode(!0).lastChild.checked,t.innerHTML="",g.noCloneChecked=!!t.cloneNode(!0).lastChild.defaultValue,t.innerHTML="",g.option=!!t.lastChild})();var _e={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function we(e,t){var n;return n="undefined"!==typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!==typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&P(e,t)?S.merge([e],n):n}function Ce(e,t){for(var n=0,i=e.length;n",""]);var ke=/<|&#?\w+;/;function Se(e,t,n,i,r){for(var o,a,s,l,c,u,d=t.createDocumentFragment(),h=[],f=0,p=e.length;f-1)r&&r.push(o);else if(c=de(o),a=we(d.appendChild(o),"script"),c&&Ce(a),n){u=0;while(o=a[u++])xe.test(o.type||"")&&n.push(o)}return d}var Oe=/^([^.]*)(?:\.(.+)|)/;function Ee(){return!0}function De(){return!1}function $e(e,t){return e===Te()===("focus"===t)}function Te(){try{return x.activeElement}catch(e){}}function Pe(e,t,n,i,r,o){var a,s;if("object"===typeof t){for(s in"string"!==typeof n&&(i=i||n,n=void 0),t)Pe(e,s,n,i,t[s],o);return e}if(null==i&&null==r?(r=n,i=n=void 0):null==r&&("string"===typeof n?(r=i,i=void 0):(r=i,i=n,n=void 0)),!1===r)r=De;else if(!r)return e;return 1===o&&(a=r,r=function(e){return S().off(e),a.apply(this,arguments)},r.guid=a.guid||(a.guid=S.guid++)),e.each((function(){S.event.add(this,t,r,i,n)}))}function Ne(e,t,n){n?(te.set(e,t,!1),S.event.add(e,t,{namespace:!1,handler:function(e){var i,r,o=te.get(this,t);if(1&e.isTrigger&&this[t]){if(o.length)(S.event.special[t]||{}).delegateType&&e.stopPropagation();else if(o=l.call(arguments),te.set(this,t,o),i=n(this,t),this[t](),r=te.get(this,t),o!==r||i?te.set(this,t,!1):r={},o!==r)return e.stopImmediatePropagation(),e.preventDefault(),r&&r.value}else o.length&&(te.set(this,t,{value:S.event.trigger(S.extend(o[0],S.Event.prototype),o.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===te.get(e,t)&&S.event.add(e,t,Ee)}S.event={global:{},add:function(e,t,n,i,r){var o,a,s,l,c,u,d,h,f,p,m,v=te.get(e);if(J(e)){n.handler&&(o=n,n=o.handler,r=o.selector),r&&S.find.matchesSelector(ue,r),n.guid||(n.guid=S.guid++),(l=v.events)||(l=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(t){return"undefined"!==typeof S&&S.event.triggered!==t.type?S.event.dispatch.apply(e,arguments):void 0}),t=(t||"").match(B)||[""],c=t.length;while(c--)s=Oe.exec(t[c])||[],f=m=s[1],p=(s[2]||"").split(".").sort(),f&&(d=S.event.special[f]||{},f=(r?d.delegateType:d.bindType)||f,d=S.event.special[f]||{},u=S.extend({type:f,origType:m,data:i,handler:n,guid:n.guid,selector:r,needsContext:r&&S.expr.match.needsContext.test(r),namespace:p.join(".")},o),(h=l[f])||(h=l[f]=[],h.delegateCount=0,d.setup&&!1!==d.setup.call(e,i,p,a)||e.addEventListener&&e.addEventListener(f,a)),d.add&&(d.add.call(e,u),u.handler.guid||(u.handler.guid=n.guid)),r?h.splice(h.delegateCount++,0,u):h.push(u),S.event.global[f]=!0)}},remove:function(e,t,n,i,r){var o,a,s,l,c,u,d,h,f,p,m,v=te.hasData(e)&&te.get(e);if(v&&(l=v.events)){t=(t||"").match(B)||[""],c=t.length;while(c--)if(s=Oe.exec(t[c])||[],f=m=s[1],p=(s[2]||"").split(".").sort(),f){d=S.event.special[f]||{},f=(i?d.delegateType:d.bindType)||f,h=l[f]||[],s=s[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=h.length;while(o--)u=h[o],!r&&m!==u.origType||n&&n.guid!==u.guid||s&&!s.test(u.namespace)||i&&i!==u.selector&&("**"!==i||!u.selector)||(h.splice(o,1),u.selector&&h.delegateCount--,d.remove&&d.remove.call(e,u));a&&!h.length&&(d.teardown&&!1!==d.teardown.call(e,p,v.handle)||S.removeEvent(e,f,v.handle),delete l[f])}else for(f in l)S.event.remove(e,f+t[c],n,i,!0);S.isEmptyObject(l)&&te.remove(e,"handle events")}},dispatch:function(e){var t,n,i,r,o,a,s=new Array(arguments.length),l=S.event.fix(e),c=(te.get(this,"events")||Object.create(null))[l.type]||[],u=S.event.special[l.type]||{};for(s[0]=l,t=1;t=1))for(;c!==this;c=c.parentNode||this)if(1===c.nodeType&&("click"!==e.type||!0!==c.disabled)){for(o=[],a={},n=0;n-1:S.find(r,this,null,[c]).length),a[r]&&o.push(i);o.length&&s.push({elem:c,handlers:o})}return c=this,l\s*$/g;function Ae(e,t){return P(e,"table")&&P(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function Le(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Fe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Ve(e,t){var n,i,r,o,a,s,l;if(1===t.nodeType){if(te.hasData(e)&&(o=te.get(e),l=o.events,l))for(r in te.remove(t,"handle events"),l)for(n=0,i=l[r].length;n1&&"string"===typeof p&&!g.checkClone&&je.test(p))return e.each((function(r){var o=e.eq(r);m&&(t[0]=p.call(this,r,o.html())),ze(o,t,n,i)}));if(h&&(r=Se(t,e[0].ownerDocument,!1,e,i),o=r.firstChild,1===r.childNodes.length&&(r=o),o||i)){for(a=S.map(we(r,"script"),Le),s=a.length;d0&&Ce(a,!l&&we(e,"script")),s},cleanData:function(e){for(var t,n,i,r=S.event.special,o=0;void 0!==(n=e[o]);o++)if(J(n)){if(t=n[te.expando]){if(t.events)for(i in t.events)r[i]?S.event.remove(n,i):S.removeEvent(n,i,t.handle);n[te.expando]=void 0}n[ne.expando]&&(n[ne.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Re(this,e,!0)},remove:function(e){return Re(this,e)},text:function(e){return K(this,(function(e){return void 0===e?S.text(this):this.empty().each((function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)}))}),null,e,arguments.length)},append:function(){return ze(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Ae(this,e);t.appendChild(e)}}))},prepend:function(){return ze(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Ae(this,e);t.insertBefore(e,t.firstChild)}}))},before:function(){return ze(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this)}))},after:function(){return ze(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)}))},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(we(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map((function(){return S.clone(this,e,t)}))},html:function(e){return K(this,(function(e){var t=this[0]||{},n=0,i=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"===typeof e&&!Me.test(e)&&!_e[(ye.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n=0&&(l+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-l-s-.5))||0),l}function at(e,t,n){var i=We(e),r=!g.boxSizingReliable()||n,o=r&&"border-box"===S.css(e,"boxSizing",!1,i),a=o,s=Ue(e,t,i),l="offset"+t[0].toUpperCase()+t.slice(1);if(He.test(s)){if(!n)return s;s="auto"}return(!g.boxSizingReliable()&&o||!g.reliableTrDimensions()&&P(e,"tr")||"auto"===s||!parseFloat(s)&&"inline"===S.css(e,"display",!1,i))&&e.getClientRects().length&&(o="border-box"===S.css(e,"boxSizing",!1,i),a=l in e,a&&(s=e[l])),s=parseFloat(s)||0,s+ot(e,t,n||(o?"border":"content"),a,i,s)+"px"}function st(e,t,n,i,r){return new st.prototype.init(e,t,n,i,r)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Ue(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,i){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var r,o,a,s=Q(t),l=tt.test(t),c=e.style;if(l||(t=Je(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(r=a.get(e,!1,i))?r:c[t];o=typeof n,"string"===o&&(r=le.exec(n))&&r[1]&&(n=pe(e,t,r),o="number"),null!=n&&n===n&&("number"!==o||l||(n+=r&&r[3]||(S.cssNumber[s]?"":"px")),g.clearCloneStyle||""!==n||0!==t.indexOf("background")||(c[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,i))||(l?c.setProperty(t,n):c[t]=n))}},css:function(e,t,n,i){var r,o,a,s=Q(t),l=tt.test(t);return l||(t=Je(s)),a=S.cssHooks[t]||S.cssHooks[s],a&&"get"in a&&(r=a.get(e,!0,n)),void 0===r&&(r=Ue(e,t,i)),"normal"===r&&t in it&&(r=it[t]),""===n||n?(o=parseFloat(r),!0===n||isFinite(o)?o||0:r):r}}),S.each(["height","width"],(function(e,t){S.cssHooks[t]={get:function(e,n,i){if(n)return!et.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?at(e,t,i):qe(e,nt,(function(){return at(e,t,i)}))},set:function(e,n,i){var r,o=We(e),a=!g.scrollboxSize()&&"absolute"===o.position,s=a||i,l=s&&"border-box"===S.css(e,"boxSizing",!1,o),c=i?ot(e,t,i,l,o):0;return l&&a&&(c-=Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-parseFloat(o[t])-ot(e,t,"border",!1,o)-.5)),c&&(r=le.exec(n))&&"px"!==(r[3]||"px")&&(e.style[t]=n,n=S.css(e,t)),rt(e,n,c)}}})),S.cssHooks.marginLeft=Ke(g.reliableMarginLeft,(function(e,t){if(t)return(parseFloat(Ue(e,"marginLeft"))||e.getBoundingClientRect().left-qe(e,{marginLeft:0},(function(){return e.getBoundingClientRect().left})))+"px"})),S.each({margin:"",padding:"",border:"Width"},(function(e,t){S.cssHooks[e+t]={expand:function(n){for(var i=0,r={},o="string"===typeof n?n.split(" "):[n];i<4;i++)r[e+ce[i]+t]=o[i]||o[i-2]||o[0];return r}},"margin"!==e&&(S.cssHooks[e+t].set=rt)})),S.fn.extend({css:function(e,t){return K(this,(function(e,t,n){var i,r,o={},a=0;if(Array.isArray(t)){for(i=We(e),r=t.length;a1)}}),S.Tween=st,st.prototype={constructor:st,init:function(e,t,n,i,r,o){this.elem=e,this.prop=n,this.easing=r||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=i,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=st.propHooks[this.prop];return e&&e.get?e.get(this):st.propHooks._default.get(this)},run:function(e){var t,n=st.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):st.propHooks._default.set(this),this}},st.prototype.init.prototype=st.prototype,st.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""),t&&"auto"!==t?t:0)},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[Je(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}},st.propHooks.scrollTop=st.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=st.prototype.init,S.fx.step={};var lt,ct,ut=/^(?:toggle|show|hide)$/,dt=/queueHooks$/;function ht(){ct&&(!1===x.hidden&&n.requestAnimationFrame?n.requestAnimationFrame(ht):n.setTimeout(ht,S.fx.interval),S.fx.tick())}function ft(){return n.setTimeout((function(){lt=void 0})),lt=Date.now()}function pt(e,t){var n,i=0,r={height:e};for(t=t?1:0;i<4;i+=2-t)n=ce[i],r["margin"+n]=r["padding"+n]=e;return t&&(r.opacity=r.width=e),r}function mt(e,t,n){for(var i,r=(bt.tweeners[t]||[]).concat(bt.tweeners["*"]),o=0,a=r.length;o1)},removeAttr:function(e){return this.each((function(){S.removeAttr(this,e)}))}}),S.extend({attr:function(e,t,n){var i,r,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"===typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(r=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?yt:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):r&&"set"in r&&void 0!==(i=r.set(e,n,t))?i:(e.setAttribute(t,n+""),n):r&&"get"in r&&null!==(i=r.get(e,t))?i:(i=S.find.attr(e,t),null==i?void 0:i))},attrHooks:{type:{set:function(e,t){if(!g.radioValue&&"radio"===t&&P(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,i=0,r=t&&t.match(B);if(r&&1===e.nodeType)while(n=r[i++])e.removeAttribute(n)}}),yt={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),(function(e,t){var n=xt[t]||S.find.attr;xt[t]=function(e,t,i){var r,o,a=t.toLowerCase();return i||(o=xt[a],xt[a]=r,r=null!=n(e,t,i)?a:null,xt[a]=o),r}}));var _t=/^(?:input|select|textarea|button)$/i,wt=/^(?:a|area)$/i;function Ct(e){var t=e.match(B)||[];return t.join(" ")}function kt(e){return e.getAttribute&&e.getAttribute("class")||""}function St(e){return Array.isArray(e)?e:"string"===typeof e&&e.match(B)||[]}S.fn.extend({prop:function(e,t){return K(this,S.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each((function(){delete this[S.propFix[e]||e]}))}}),S.extend({prop:function(e,t,n){var i,r,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,r=S.propHooks[t]),void 0!==n?r&&"set"in r&&void 0!==(i=r.set(e,n,t))?i:e[t]=n:r&&"get"in r&&null!==(i=r.get(e,t))?i:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):_t.test(e.nodeName)||wt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),g.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],(function(){S.propFix[this.toLowerCase()]=this})),S.fn.extend({addClass:function(e){var t,n,i,r,o,a,s,l=0;if(b(e))return this.each((function(t){S(this).addClass(e.call(this,t,kt(this)))}));if(t=St(e),t.length)while(n=this[l++])if(r=kt(n),i=1===n.nodeType&&" "+Ct(r)+" ",i){a=0;while(o=t[a++])i.indexOf(" "+o+" ")<0&&(i+=o+" ");s=Ct(i),r!==s&&n.setAttribute("class",s)}return this},removeClass:function(e){var t,n,i,r,o,a,s,l=0;if(b(e))return this.each((function(t){S(this).removeClass(e.call(this,t,kt(this)))}));if(!arguments.length)return this.attr("class","");if(t=St(e),t.length)while(n=this[l++])if(r=kt(n),i=1===n.nodeType&&" "+Ct(r)+" ",i){a=0;while(o=t[a++])while(i.indexOf(" "+o+" ")>-1)i=i.replace(" "+o+" "," ");s=Ct(i),r!==s&&n.setAttribute("class",s)}return this},toggleClass:function(e,t){var n=typeof e,i="string"===n||Array.isArray(e);return"boolean"===typeof t&&i?t?this.addClass(e):this.removeClass(e):b(e)?this.each((function(n){S(this).toggleClass(e.call(this,n,kt(this),t),t)})):this.each((function(){var t,r,o,a;if(i){r=0,o=S(this),a=St(e);while(t=a[r++])o.hasClass(t)?o.removeClass(t):o.addClass(t)}else void 0!==e&&"boolean"!==n||(t=kt(this),t&&te.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||!1===e?"":te.get(this,"__className__")||""))}))},hasClass:function(e){var t,n,i=0;t=" "+e+" ";while(n=this[i++])if(1===n.nodeType&&(" "+Ct(kt(n))+" ").indexOf(t)>-1)return!0;return!1}});var Ot=/\r/g;S.fn.extend({val:function(e){var t,n,i,r=this[0];return arguments.length?(i=b(e),this.each((function(n){var r;1===this.nodeType&&(r=i?e.call(this,n,S(this).val()):e,null==r?r="":"number"===typeof r?r+="":Array.isArray(r)&&(r=S.map(r,(function(e){return null==e?"":e+""}))),t=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&void 0!==t.set(this,r,"value")||(this.value=r))}))):r?(t=S.valHooks[r.type]||S.valHooks[r.nodeName.toLowerCase()],t&&"get"in t&&void 0!==(n=t.get(r,"value"))?n:(n=r.value,"string"===typeof n?n.replace(Ot,""):null==n?"":n)):void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:Ct(S.text(e))}},select:{get:function(e){var t,n,i,r=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],l=a?o+1:r.length;for(i=o<0?l:a?o:0;i-1)&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],(function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=S.inArray(S(e).val(),t)>-1}},g.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})})),g.focusin="onfocusin"in n;var Et=/^(?:focusinfocus|focusoutblur)$/,Dt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,i,r){var o,a,s,l,c,u,d,h,f=[i||x],m=p.call(e,"type")?e.type:e,v=p.call(e,"namespace")?e.namespace.split("."):[];if(a=h=s=i=i||x,3!==i.nodeType&&8!==i.nodeType&&!Et.test(m+S.event.triggered)&&(m.indexOf(".")>-1&&(v=m.split("."),m=v.shift(),v.sort()),c=m.indexOf(":")<0&&"on"+m,e=e[S.expando]?e:new S.Event(m,"object"===typeof e&&e),e.isTrigger=r?2:3,e.namespace=v.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+v.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=i),t=null==t?[e]:S.makeArray(t,[e]),d=S.event.special[m]||{},r||!d.trigger||!1!==d.trigger.apply(i,t))){if(!r&&!d.noBubble&&!y(i)){for(l=d.delegateType||m,Et.test(l+m)||(a=a.parentNode);a;a=a.parentNode)f.push(a),s=a;s===(i.ownerDocument||x)&&f.push(s.defaultView||s.parentWindow||n)}o=0;while((a=f[o++])&&!e.isPropagationStopped())h=a,e.type=o>1?l:d.bindType||m,u=(te.get(a,"events")||Object.create(null))[e.type]&&te.get(a,"handle"),u&&u.apply(a,t),u=c&&a[c],u&&u.apply&&J(a)&&(e.result=u.apply(a,t),!1===e.result&&e.preventDefault());return e.type=m,r||e.isDefaultPrevented()||d._default&&!1!==d._default.apply(f.pop(),t)||!J(i)||c&&b(i[m])&&!y(i)&&(s=i[c],s&&(i[c]=null),S.event.triggered=m,e.isPropagationStopped()&&h.addEventListener(m,Dt),i[m](),e.isPropagationStopped()&&h.removeEventListener(m,Dt),S.event.triggered=void 0,s&&(i[c]=s)),e.result}},simulate:function(e,t,n){var i=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(i,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each((function(){S.event.trigger(e,t,this)}))},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),g.focusin||S.each({focus:"focusin",blur:"focusout"},(function(e,t){var n=function(e){S.event.simulate(t,e.target,S.event.fix(e))};S.event.special[t]={setup:function(){var i=this.ownerDocument||this.document||this,r=te.access(i,t);r||i.addEventListener(e,n,!0),te.access(i,t,(r||0)+1)},teardown:function(){var i=this.ownerDocument||this.document||this,r=te.access(i,t)-1;r?te.access(i,t,r):(i.removeEventListener(e,n,!0),te.remove(i,t))}}}));var $t=n.location,Tt={guid:Date.now()},Pt=/\?/;S.parseXML=function(e){var t,i;if(!e||"string"!==typeof e)return null;try{t=(new n.DOMParser).parseFromString(e,"text/xml")}catch(r){}return i=t&&t.getElementsByTagName("parsererror")[0],t&&!i||S.error("Invalid XML: "+(i?S.map(i.childNodes,(function(e){return e.textContent})).join("\n"):e)),t};var Nt=/\[\]$/,Mt=/\r?\n/g,jt=/^(?:submit|button|image|reset|file)$/i,It=/^(?:input|select|textarea|keygen)/i;function At(e,t,n,i){var r;if(Array.isArray(t))S.each(t,(function(t,r){n||Nt.test(e)?i(e,r):At(e+"["+("object"===typeof r&&null!=r?t:"")+"]",r,n,i)}));else if(n||"object"!==C(t))i(e,t);else for(r in t)At(e+"["+r+"]",t[r],n,i)}S.param=function(e,t){var n,i=[],r=function(e,t){var n=b(t)?t():t;i[i.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,(function(){r(this.name,this.value)}));else for(n in e)At(n,e[n],t,r);return i.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map((function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this})).filter((function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&It.test(this.nodeName)&&!jt.test(e)&&(this.checked||!be.test(e))})).map((function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,(function(e){return{name:t.name,value:e.replace(Mt,"\r\n")}})):{name:t.name,value:n.replace(Mt,"\r\n")}})).get()}});var Lt=/%20/g,Ft=/#.*$/,Vt=/([?&])_=[^&]*/,Bt=/^(.*?):[ \t]*([^\r\n]*)$/gm,zt=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Rt=/^(?:GET|HEAD)$/,Ht=/^\/\//,Wt={},qt={},Yt="*/".concat("*"),Ut=x.createElement("a");function Kt(e){return function(t,n){"string"!==typeof t&&(n=t,t="*");var i,r=0,o=t.toLowerCase().match(B)||[];if(b(n))while(i=o[r++])"+"===i[0]?(i=i.slice(1)||"*",(e[i]=e[i]||[]).unshift(n)):(e[i]=e[i]||[]).push(n)}}function Gt(e,t,n,i){var r={},o=e===qt;function a(s){var l;return r[s]=!0,S.each(e[s]||[],(function(e,s){var c=s(t,n,i);return"string"!==typeof c||o||r[c]?o?!(l=c):void 0:(t.dataTypes.unshift(c),a(c),!1)})),l}return a(t.dataTypes[0])||!r["*"]&&a("*")}function Xt(e,t){var n,i,r=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((r[n]?e:i||(i={}))[n]=t[n]);return i&&S.extend(!0,e,i),e}function Zt(e,t,n){var i,r,o,a,s=e.contents,l=e.dataTypes;while("*"===l[0])l.shift(),void 0===i&&(i=e.mimeType||t.getResponseHeader("Content-Type"));if(i)for(r in s)if(s[r]&&s[r].test(i)){l.unshift(r);break}if(l[0]in n)o=l[0];else{for(r in n){if(!l[0]||e.converters[r+" "+l[0]]){o=r;break}a||(a=r)}o=o||a}if(o)return o!==l[0]&&l.unshift(o),n[o]}function Qt(e,t,n,i){var r,o,a,s,l,c={},u=e.dataTypes.slice();if(u[1])for(a in e.converters)c[a.toLowerCase()]=e.converters[a];o=u.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!l&&i&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),l=o,o=u.shift(),o)if("*"===o)o=l;else if("*"!==l&&l!==o){if(a=c[l+" "+o]||c["* "+o],!a)for(r in c)if(s=r.split(" "),s[1]===o&&(a=c[l+" "+s[0]]||c["* "+s[0]],a)){!0===a?a=c[r]:!0!==c[r]&&(o=s[0],u.unshift(s[1]));break}if(!0!==a)if(a&&e.throws)t=a(t);else try{t=a(t)}catch(d){return{state:"parsererror",error:a?d:"No conversion from "+l+" to "+o}}}return{state:"success",data:t}}Ut.href=$t.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:$t.href,type:"GET",isLocal:zt.test($t.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Yt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Xt(Xt(e,S.ajaxSettings),t):Xt(S.ajaxSettings,e)},ajaxPrefilter:Kt(Wt),ajaxTransport:Kt(qt),ajax:function(e,t){"object"===typeof e&&(t=e,e=void 0),t=t||{};var i,r,o,a,s,l,c,u,d,h,f=S.ajaxSetup({},t),p=f.context||f,m=f.context&&(p.nodeType||p.jquery)?S(p):S.event,v=S.Deferred(),g=S.Callbacks("once memory"),b=f.statusCode||{},y={},_={},w="canceled",C={readyState:0,getResponseHeader:function(e){var t;if(c){if(!a){a={};while(t=Bt.exec(o))a[t[1].toLowerCase()+" "]=(a[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=a[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return c?o:null},setRequestHeader:function(e,t){return null==c&&(e=_[e.toLowerCase()]=_[e.toLowerCase()]||e,y[e]=t),this},overrideMimeType:function(e){return null==c&&(f.mimeType=e),this},statusCode:function(e){var t;if(e)if(c)C.always(e[C.status]);else for(t in e)b[t]=[b[t],e[t]];return this},abort:function(e){var t=e||w;return i&&i.abort(t),k(0,t),this}};if(v.promise(C),f.url=((e||f.url||$t.href)+"").replace(Ht,$t.protocol+"//"),f.type=t.method||t.type||f.method||f.type,f.dataTypes=(f.dataType||"*").toLowerCase().match(B)||[""],null==f.crossDomain){l=x.createElement("a");try{l.href=f.url,l.href=l.href,f.crossDomain=Ut.protocol+"//"+Ut.host!==l.protocol+"//"+l.host}catch(O){f.crossDomain=!0}}if(f.data&&f.processData&&"string"!==typeof f.data&&(f.data=S.param(f.data,f.traditional)),Gt(Wt,f,t,C),c)return C;for(d in u=S.event&&f.global,u&&0===S.active++&&S.event.trigger("ajaxStart"),f.type=f.type.toUpperCase(),f.hasContent=!Rt.test(f.type),r=f.url.replace(Ft,""),f.hasContent?f.data&&f.processData&&0===(f.contentType||"").indexOf("application/x-www-form-urlencoded")&&(f.data=f.data.replace(Lt,"+")):(h=f.url.slice(r.length),f.data&&(f.processData||"string"===typeof f.data)&&(r+=(Pt.test(r)?"&":"?")+f.data,delete f.data),!1===f.cache&&(r=r.replace(Vt,"$1"),h=(Pt.test(r)?"&":"?")+"_="+Tt.guid+++h),f.url=r+h),f.ifModified&&(S.lastModified[r]&&C.setRequestHeader("If-Modified-Since",S.lastModified[r]),S.etag[r]&&C.setRequestHeader("If-None-Match",S.etag[r])),(f.data&&f.hasContent&&!1!==f.contentType||t.contentType)&&C.setRequestHeader("Content-Type",f.contentType),C.setRequestHeader("Accept",f.dataTypes[0]&&f.accepts[f.dataTypes[0]]?f.accepts[f.dataTypes[0]]+("*"!==f.dataTypes[0]?", "+Yt+"; q=0.01":""):f.accepts["*"]),f.headers)C.setRequestHeader(d,f.headers[d]);if(f.beforeSend&&(!1===f.beforeSend.call(p,C,f)||c))return C.abort();if(w="abort",g.add(f.complete),C.done(f.success),C.fail(f.error),i=Gt(qt,f,t,C),i){if(C.readyState=1,u&&m.trigger("ajaxSend",[C,f]),c)return C;f.async&&f.timeout>0&&(s=n.setTimeout((function(){C.abort("timeout")}),f.timeout));try{c=!1,i.send(y,k)}catch(O){if(c)throw O;k(-1,O)}}else k(-1,"No Transport");function k(e,t,a,l){var d,h,y,x,_,w=t;c||(c=!0,s&&n.clearTimeout(s),i=void 0,o=l||"",C.readyState=e>0?4:0,d=e>=200&&e<300||304===e,a&&(x=Zt(f,C,a)),!d&&S.inArray("script",f.dataTypes)>-1&&S.inArray("json",f.dataTypes)<0&&(f.converters["text script"]=function(){}),x=Qt(f,x,C,d),d?(f.ifModified&&(_=C.getResponseHeader("Last-Modified"),_&&(S.lastModified[r]=_),_=C.getResponseHeader("etag"),_&&(S.etag[r]=_)),204===e||"HEAD"===f.type?w="nocontent":304===e?w="notmodified":(w=x.state,h=x.data,y=x.error,d=!y)):(y=w,!e&&w||(w="error",e<0&&(e=0))),C.status=e,C.statusText=(t||w)+"",d?v.resolveWith(p,[h,w,C]):v.rejectWith(p,[C,w,y]),C.statusCode(b),b=void 0,u&&m.trigger(d?"ajaxSuccess":"ajaxError",[C,f,d?h:y]),g.fireWith(p,[C,w]),u&&(m.trigger("ajaxComplete",[C,f]),--S.active||S.event.trigger("ajaxStop")))}return C},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],(function(e,t){S[t]=function(e,n,i,r){return b(n)&&(r=r||i,i=n,n=void 0),S.ajax(S.extend({url:e,type:t,dataType:r,data:n,success:i},S.isPlainObject(e)&&e))}})),S.ajaxPrefilter((function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")})),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(b(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map((function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e})).append(this)),this},wrapInner:function(e){return b(e)?this.each((function(t){S(this).wrapInner(e.call(this,t))})):this.each((function(){var t=S(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)}))},wrap:function(e){var t=b(e);return this.each((function(n){S(this).wrapAll(t?e.call(this,n):e)}))},unwrap:function(e){return this.parent(e).not("body").each((function(){S(this).replaceWith(this.childNodes)})),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new n.XMLHttpRequest}catch(e){}};var Jt={0:200,1223:204},en=S.ajaxSettings.xhr();g.cors=!!en&&"withCredentials"in en,g.ajax=en=!!en,S.ajaxTransport((function(e){var t,i;if(g.cors||en&&!e.crossDomain)return{send:function(r,o){var a,s=e.xhr();if(s.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(a in e.xhrFields)s[a]=e.xhrFields[a];for(a in e.mimeType&&s.overrideMimeType&&s.overrideMimeType(e.mimeType),e.crossDomain||r["X-Requested-With"]||(r["X-Requested-With"]="XMLHttpRequest"),r)s.setRequestHeader(a,r[a]);t=function(e){return function(){t&&(t=i=s.onload=s.onerror=s.onabort=s.ontimeout=s.onreadystatechange=null,"abort"===e?s.abort():"error"===e?"number"!==typeof s.status?o(0,"error"):o(s.status,s.statusText):o(Jt[s.status]||s.status,s.statusText,"text"!==(s.responseType||"text")||"string"!==typeof s.responseText?{binary:s.response}:{text:s.responseText},s.getAllResponseHeaders()))}},s.onload=t(),i=s.onerror=s.ontimeout=t("error"),void 0!==s.onabort?s.onabort=i:s.onreadystatechange=function(){4===s.readyState&&n.setTimeout((function(){t&&i()}))},t=t("abort");try{s.send(e.hasContent&&e.data||null)}catch(l){if(t)throw l}},abort:function(){t&&t()}}})),S.ajaxPrefilter((function(e){e.crossDomain&&(e.contents.script=!1)})),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",(function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")})),S.ajaxTransport("script",(function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(i,r){t=S("