From 50642b6229dd87a857c0f7fc110e672b17877adc Mon Sep 17 00:00:00 2001
From: Hossein <hossein13785ab@gmail.com>
Date: Mon, 23 Oct 2023 18:33:43 +0330
Subject: [PATCH 1/4] #175: Add market-order comp

---
 public/assets/locales/en/translation.json     |   2 +
 public/assets/locales/fa/translation.json     |   4 +-
 public/assets/locales/uzb/translation.json    |   2 +
 .../Layout/LayoutHeader/LayoutHeader.js       |   9 +-
 src/components/TextInput/TextInput.js         |   1 -
 src/main/Browser/Browser.js                   |   2 +
 .../Browser/Pages/EasyTrading/EasyTrading.js  |  16 +
 .../Pages/EasyTrading/EasyTrading.module.css  |   0
 .../components/EasyOrder/EasyOrder.js         |  52 ++
 .../components/EasyOrder/EasyOrder.module.css |  61 +++
 .../components/EasyBuyOrder/EasyBuyOrder.js   | 455 ++++++++++++++++++
 .../EasyBuyOrder/EasyBuyOrder.module.css      |   0
 .../components/EasySellOrder/EasySellOrder.js |  12 +
 .../EasySellOrder/EasySellOrder.module.css    |   0
 src/main/Browser/Routes/routes.js             |   1 +
 15 files changed, 611 insertions(+), 6 deletions(-)
 create mode 100644 src/main/Browser/Pages/EasyTrading/EasyTrading.js
 create mode 100644 src/main/Browser/Pages/EasyTrading/EasyTrading.module.css
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css

diff --git a/public/assets/locales/en/translation.json b/public/assets/locales/en/translation.json
index d765c03b..4457b2fb 100644
--- a/public/assets/locales/en/translation.json
+++ b/public/assets/locales/en/translation.json
@@ -49,6 +49,7 @@
   "noTx": "There is no transaction!",
   "close": "Close",
   "unit": "Unit",
+  "with": "With",
   "from": "from",
   "row": "Row",
   "until": "until",
@@ -583,6 +584,7 @@
     "emptyCaptcha": "Captcha required!",
     "forgetPassServerError": "Error recovering password, try again!",
     "UserAlreadyExists": "User with this email is already registered",
+    "RegisterIsLimited": "It is not possible to register for you at this time.",
     "forgetPassEmailForgetError": "Email format is incorrect!",
     "forDemoLogin": "Click here for a testing login!"
   },
diff --git a/public/assets/locales/fa/translation.json b/public/assets/locales/fa/translation.json
index ff7bd4f8..65f1fe29 100644
--- a/public/assets/locales/fa/translation.json
+++ b/public/assets/locales/fa/translation.json
@@ -52,6 +52,7 @@
   "from": "از",
   "row": "ردیف",
   "until": "تا",
+  "with": "با",
   "withPrice": "با قیمت",
   "description": "توضیحات",
   "first": "ابتدا",
@@ -582,7 +583,8 @@
     "minCaptcha": "Captcha باید ۵ کاراکتر باشد!",
     "emptyCaptcha": "وارد کردن Captcha الزامی است",
     "forgetPassServerError": "خطا در بازیابی رمز، دوباره تلاش کنید",
-    "UserAlreadyExists": "ایمل واردشده تکراری است",
+    "UserAlreadyExists": "ایمیل واردشده تکراری است.",
+    "RegisterIsLimited": "در حال حاضر امکان ثبت نام برای شما وجود ندارد.",
     "forgetPassEmailForgetError": "فرمت ایمیل صحیح نیست.",
     "forDemoLogin": "برای ورود آزمایشی، اینجا کلیک کنید!"
   },
diff --git a/public/assets/locales/uzb/translation.json b/public/assets/locales/uzb/translation.json
index d6923853..e610efc3 100644
--- a/public/assets/locales/uzb/translation.json
+++ b/public/assets/locales/uzb/translation.json
@@ -52,6 +52,7 @@
   "from": "dan",
   "row": "Qator",
   "until": "gacha",
+  "with": "Bilan",
   "withPrice": "narx bilan",
   "description": "Tavsif",
   "first": "Birinchi",
@@ -583,6 +584,7 @@
     "emptyCaptcha": "Captcha talab qilinadi!",
     "forgetPassServerError": "Parolni tiklashda xatolik yuz berdi, qaytadan urinib ko'ring!",
     "UserAlreadyExists": "Ushbu email manziliga ega foydalanuvchi allaqachon ro'yxatdan o'tgan",
+    "RegisterIsLimited": "Ayni paytda siz uchun ro'yxatdan o'tish mumkin emas.",
     "forgetPassEmailForgetError": "Email manzili formati noto'g'ri!",
     "forDemoLogin": "Sinov uchun kirish uchun bu yerni bosing!"
   },
diff --git a/src/components/Layout/LayoutHeader/LayoutHeader.js b/src/components/Layout/LayoutHeader/LayoutHeader.js
index f1824ec2..14367c66 100644
--- a/src/components/Layout/LayoutHeader/LayoutHeader.js
+++ b/src/components/Layout/LayoutHeader/LayoutHeader.js
@@ -41,6 +41,7 @@ const LayoutHeader = () => {
                 <div className={`width-30 `}>
                     <Routes>
                         <Route path={RoutesName.Landing} element={<h2>{t("Landing.title")}</h2>}/>
+                        <Route path={RoutesName.EasyTrading} element={<h2>{t("MarketTitle.easyTrading")}</h2>}/>
                         <Route path={RoutesName.Commission} element={<h2>{t("commissions.title")}</h2>}/>
                         <Route path={RoutesName.AboutUs} element={<h2>{t("aboutUs.title")}</h2>}/>
                         <Route path={RoutesName.TransferFees} element={<h2>{t("transferFees.title")}</h2>}/>
@@ -59,10 +60,10 @@ const LayoutHeader = () => {
                         to={RoutesName.Landing}
                         className={({ isActive }) => isActive ? 'text-orange mx-1 cursor-pointer hover-text' : 'mx-1 cursor-pointer hover-text'}
                     >{t("home")}</NavLink>
-                    {/* <NavLink
-                        to="#"
-                        className={`mx-1 cursor-pointer hover-text`}
-                    >{t("MarketTitle.easyTrading")}</NavLink>*/}
+                     <NavLink
+                        to={RoutesName.EasyTrading}
+                        className={({ isActive }) => isActive ? 'text-orange mx-1 cursor-pointer hover-text' : 'mx-1 cursor-pointer hover-text'}
+                    >{t("MarketTitle.easyTrading")}</NavLink>
                     <NavLink
                         to={RoutesName.Panel}
                         className={({ isActive }) => isActive ? 'text-orange mx-1 cursor-pointer hover-text' : 'mx-1 cursor-pointer hover-text'}
diff --git a/src/components/TextInput/TextInput.js b/src/components/TextInput/TextInput.js
index 70133167..bafe4bab 100644
--- a/src/components/TextInput/TextInput.js
+++ b/src/components/TextInput/TextInput.js
@@ -38,7 +38,6 @@ const TextInput = (props) => {
             if (state.isSelected) {
                 className = className + " " + classes.isSelected
             }
-        console.log("className", className)
         return className;
     }
 
diff --git a/src/main/Browser/Browser.js b/src/main/Browser/Browser.js
index 6d352777..5242bd7a 100644
--- a/src/main/Browser/Browser.js
+++ b/src/main/Browser/Browser.js
@@ -22,6 +22,7 @@ import TransferFees from "./Pages/Info/TransferFees/TransferFees";
 import Guide from "./Pages/Info/Guide/Guide";
 import Rules from "./Pages/Info/Rules/Rules";
 import ContactUs from "./Pages/Info/ContactUs/ContactUs";
+import EasyTrading from "./Pages/EasyTrading/EasyTrading";
 
 const Browser = () => {
     const query = useQuery();
@@ -94,6 +95,7 @@ const Browser = () => {
                 <Route element={<Layout/>}>
                     <Route path={RoutesName.Landing} element={<Landing/>}/>
                     <Route path={RoutesName.AllMarket} element={<AllMarket/>}/>
+                    <Route path={RoutesName.EasyTrading} element={<EasyTrading/>}/>
                     <Route path={RoutesName.AboutUs} element={<AboutUs/>}/>
                     <Route path={RoutesName.Commission} element={<Commission/>}/>
                     <Route path={RoutesName.TransferFees} element={<TransferFees/>}/>
diff --git a/src/main/Browser/Pages/EasyTrading/EasyTrading.js b/src/main/Browser/Pages/EasyTrading/EasyTrading.js
new file mode 100644
index 00000000..97a66223
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/EasyTrading.js
@@ -0,0 +1,16 @@
+import React from 'react';
+import classes from './EasyTrading.module.css'
+import {images} from "../../../../assets/images";
+import PriceInfo from "../AllMarket/components/PriceInfo/PriceInfo";
+import Swing from "../AllMarket/components/Swing/Swing";
+import VolumeInfo from "../AllMarket/components/VolumeInfo/VolumeInfo";
+import AllMarketInfo from "../AllMarket/components/AllMarketInfo/AllMarketInfo";
+import EasyOrder from "./components/EasyOrder/EasyOrder";
+
+const EasyTrading = () => {
+    return (
+        <EasyOrder/>
+    );
+};
+
+export default EasyTrading;
diff --git a/src/main/Browser/Pages/EasyTrading/EasyTrading.module.css b/src/main/Browser/Pages/EasyTrading/EasyTrading.module.css
new file mode 100644
index 00000000..e69de29b
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
new file mode 100644
index 00000000..f358efce
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
@@ -0,0 +1,52 @@
+import React, {useState} from 'react';
+import classes from './EasyOrder.module.css'
+import {useTranslation} from "react-i18next";
+import {useDispatch} from "react-redux";
+import AccordionBox from "../../../../../../components/AccordionBox/AccordionBox";
+import EasyBuyOrder from "./components/EasyBuyOrder/EasyBuyOrder";
+import EasySellOrder from "./components/EasySellOrder/EasySellOrder";
+import {images} from "../../../../../../assets/images";
+
+const EasyOrder = () => {
+
+    const {t} = useTranslation();
+    const dispatch = useDispatch();
+
+    const [activeTab, setActiveTab] = useState(0);
+
+    const [selected, setSelected] = useState({
+        "base": null,
+        "quote": null,
+    })
+
+
+    const data = [
+        {id: 1, title: t("buy"), body: <EasyBuyOrder setOutPutSelected={setSelected}/>},
+        {id: 2, title: t("sell"), body: <EasySellOrder/>},
+    ];
+
+    return (
+        <div className={`container card-bg card-border my-2 ${classes.container} width-30`}>
+
+
+
+            <AccordionBox
+                title={<div className={`width-100 row jc-between ai-center`}>
+                    <span>{t("orders.title")}</span>
+                    {/*<div className={`${classes.avatar}  position-relative`}
+                         style={{backgroundImage: `url("${images[selected?.quote] }")`}}>
+                        <div className={`${classes.avatar} ${classes.backImg} position-absolute`}
+                             style={{backgroundImage: `url("${images[selected?.base] }")`}}
+                        />
+                    </div>*/}
+                </div>}
+                safari={classes.safariFlexSize}
+                content={data}
+                activeTab={activeTab}
+                setActiveTab={setActiveTab}
+            />
+        </div>
+    );
+};
+
+export default EasyOrder;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
new file mode 100644
index 00000000..c8f1414e
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
@@ -0,0 +1,61 @@
+.container {
+    min-height: 78vh;
+    margin: 5vh auto;
+}
+
+
+.thisInput :global(.lead) {
+    width: 30%;
+}
+.thisInput :global(.selectExternalClass) {
+    width: 70% !important;
+}
+
+
+
+.thisButton {
+    width: 90%;
+}
+.alertSubmit{
+    background-color: var(--orange);
+}
+.thisButton.buyOrder {
+    background-color: var(--darkGreen);
+}
+.thisButton.sellOrder {
+    background-color: var(--darkRed);
+}
+.thisButton:disabled,.button[disabled] {
+    border: 0.3vh solid var(--cardHeader);
+    background: var(--cardHeader);
+    color: var(--textColor);
+    cursor: not-allowed;
+}
+.thisLoading{
+    width: 5vw;
+}
+
+.hide {
+    visibility: hidden;
+}
+
+
+.avatar {
+    width: 2.7vw;
+    height: 2.7vw;
+    /*background-color: #dfdfdf;*/
+    border-radius: 100%;
+    background-size: cover;
+    background-position: center;
+    background-repeat: no-repeat;
+}
+
+.backImg {
+    left: 75%;
+
+}
+:global(.ltr) .backImg {
+    left: initial;
+    right: 75%;
+
+}
\ No newline at end of file
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
new file mode 100644
index 00000000..c0cd0df0
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
@@ -0,0 +1,455 @@
+import React, {useEffect, useState} from 'react';
+import classes from '../../EasyOrder.module.css';
+import {Trans, useTranslation} from "react-i18next";
+import {useDispatch, useSelector} from "react-redux";
+import {useGetUserAccount} from "../../../../../../../../queries/hooks/useGetUserAccount";
+import {BN, parsePriceString} from "../../../../../../../../utils/utils";
+import {toast} from "react-hot-toast";
+import {useOrderBook} from "../../../../../../../../queries";
+import TextInput from "../../../../../../../../components/TextInput/TextInput";
+import NumberInput from "../../../../../../../../components/NumberInput/NumberInput";
+import {createOrder} from "js-api-client";
+import {setLastTransaction} from "../../../../../../../../store/actions/auth";
+import {images} from "../../../../../../../../assets/images";
+import Button from "../../../../../../../../components/Button/Button";
+
+const EasyBuyOrder = ({setOutPutSelected}) => {
+
+    const {t} = useTranslation();
+    const dispatch = useDispatch();
+    const symbols = useSelector((state) => state.exchange.symbols)
+
+    const {data: userAccount} = useGetUserAccount()
+    const [isLoading, setIsLoading] = useState(false)
+
+    const tradeFee = useSelector((state) => state.auth.tradeFee)
+    const isLogin = useSelector((state) => state.auth.isLogin)
+
+    const [pairConfig, setPairConfig] = useState({
+        "baseAssetPrecision": 0,
+        "quoteAssetPrecision": 0,
+    })
+
+    const [bestBuyPrice, setBestBuyPrice] = useState(new BN(0))
+
+    const [selected, setSelected] = useState({
+        "base": null,
+        "quote": null,
+    })
+    const [options, setOptions] = useState({
+        "base": [],
+        "quote": [],
+    })
+
+    useEffect(() => {
+        setOutPutSelected({
+            "base": selected?.base,
+            "quote": selected?.quote,
+        })
+    }, [selected]);
+
+    const {data} = useOrderBook(selected?.base + selected?.quote)
+
+    useEffect(() => {
+        if (data?.asks?.length > 0 ) {
+            setBestBuyPrice(new BN (data?.asks[0][0]))
+        }
+
+    }, [data]);
+
+    const quote = userAccount?.wallets[selected?.quote]?.free || 0;
+
+    const [alert, setAlert] = useState({
+        submit: false,
+        reqAmount: null,
+        totalPrice: null,
+    });
+
+    const [order, setOrder] = useState({
+        tradeFee: new BN(0),
+        stopLimit: false,
+        stopMarket: false,
+        stopPrice: new BN(0),
+        reqAmount: new BN(0),
+        pricePerUnit: new BN(0),
+        totalPrice: new BN(0),
+    });
+
+    const currentSymbolHandler = (base , quote) => {
+        const currentSymbol = symbols?.find(s => (s?.baseAsset === base) && (s?.quoteAsset === quote))
+        setPairConfig(currentSymbol)
+    }
+
+    const availableQuote = (baseAsset) => {
+
+        const quoteAssets = [];
+        for (const symbol of symbols) {
+            if(symbol.baseAsset === baseAsset){
+                quoteAssets.push(symbol.quoteAsset)
+            }
+        }
+        return quoteAssets
+    }
+
+    useEffect(() => {
+        const baseAssets = [];
+        for (const symbol of symbols) {
+            if (symbol.symbol.toUpperCase().includes("NLN")) continue
+            if (!baseAssets.includes(symbol.baseAsset)) {
+                baseAssets.push(symbol.baseAsset)
+            }
+        }
+        const quoteOptions = availableQuote(baseAssets[0])
+        setOptions({
+            "base": baseAssets,
+            "quote": quoteOptions,
+        })
+        setSelected({
+            "base": baseAssets[0],
+            "quote": quoteOptions[0],
+        })
+        currentSymbolHandler(baseAssets[0],quoteOptions[0])
+    }, []);
+
+    useEffect(() => {
+        if (alert?.submit) {
+            setAlert({
+                ...alert, submit: false
+            })
+        }
+    }, [order])
+
+    useEffect(() => {
+        setOrder({
+            tradeFee: new BN(0),
+            stopLimit: false,
+            stopMarket: false,
+            stopPrice: new BN(0),
+            reqAmount: new BN(0),
+            pricePerUnit: new BN(0),
+            totalPrice: new BN(0),
+        })
+        setAlert({
+            submit: false,
+            reqAmount: null,
+            totalPrice: null,
+        })
+    }, [selected])
+
+    const currencyValidator = (key, val, rule) => {
+        if (!val.isZero() && val.isLessThan(rule.min)) {
+            return setAlert({
+                ...alert,
+                [key]: (
+                    <Trans
+                        i18nKey="orders.minOrder"
+                        values={{
+                            min: pairConfig?.baseRange?.min?.toString(),
+                            currency: t("currency." + pairConfig?.baseAsset),
+                        }}
+                    />
+                ),
+            });
+        }
+        if (val.isGreaterThan(rule.max)) {
+            return setAlert({
+                ...alert,
+                [key]: (
+                    <Trans
+                        i18nKey="orders.maxOrder"
+                        values={{
+                            max: pairConfig?.baseRange?.max?.toLocaleString(),
+                            currency: t("currency." + pairConfig?.baseAsset),
+                        }}
+                    />
+                ),
+            });
+        }
+        if (!val.mod(rule.step).isZero()) {
+            return setAlert({
+                ...alert,
+                [key]: (<Trans
+                    i18nKey="orders.divisibility"
+                    values={{mod: rule.step.toString()}}
+                />)
+            })
+        }
+        return setAlert({...alert, [key]: null});
+    };
+
+    const buyPriceHandler = (value, key) => {
+        value = parsePriceString(value);
+        switch (key) {
+            case "reqAmount":
+                const reqAmount = new BN(value);
+                currencyValidator("reqAmount", reqAmount, pairConfig?.baseRange);
+                setOrder({
+                    ...order,
+                    reqAmount,
+                    totalPrice: reqAmount.multipliedBy(order?.pricePerUnit).decimalPlaces(pairConfig?.quoteAssetPrecision),
+                    tradeFee: reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
+                });
+                break;
+            case "pricePerUnit":
+                const pricePerUnit = new BN(value);
+                setOrder({
+                    ...order,
+                    pricePerUnit: pricePerUnit,
+                    totalPrice: pricePerUnit.multipliedBy(order.reqAmount).decimalPlaces(pairConfig?.quoteAssetPrecision),
+                    tradeFee: order.reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
+                });
+                break;
+            case "totalPrice":
+                const totalPrice = new BN(value);
+                const req = totalPrice.dividedBy(order.pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision);
+                setOrder({
+                    ...order,
+                    reqAmount: req.isFinite() ? req : new BN(0),
+                    totalPrice,
+                    tradeFee: req.isFinite() ? req.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision) : new BN(0),
+                });
+                currencyValidator("reqAmount", req, pairConfig?.baseRange);
+                break;
+            default:
+        }
+    };
+
+    useEffect(() => {
+        if (order.totalPrice.isGreaterThan(quote)) {
+            return setAlert({
+                ...alert,
+                totalPrice: t('orders.notEnoughBalance')
+            })
+        }
+        return setAlert({
+            ...alert,
+            totalPrice: null
+        })
+    }, [order.totalPrice]);
+
+    useEffect(() => {
+        setOrder((prevState) => ({
+            ...order,
+            tradeFee: prevState.totalPrice.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
+        }));
+    }, [tradeFee]);
+
+    const fillBuyByWallet = () => {
+        if (bestBuyPrice.isEqualTo(0)) return toast.error(t("orders.hasNoOffer"));
+        if (order.pricePerUnit.isEqualTo(0)) {
+            const pricePerUnit = new BN(bestBuyPrice)
+            let totalPrice = new BN(quote);
+            let reqAmount = totalPrice.dividedBy(pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision)
+            if (!reqAmount.mod(pairConfig?.baseRange.step).isZero()) {
+                reqAmount = reqAmount?.minus(reqAmount.mod(pairConfig?.baseRange.step));
+                totalPrice = reqAmount.multipliedBy(pricePerUnit);
+            }
+            setOrder({
+                ...order,
+                reqAmount,
+                pricePerUnit,
+                totalPrice,
+                tradeFee: reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
+            });
+        } else {
+            let totalPrice = new BN(quote);
+            let reqAmount = totalPrice.dividedBy(order.pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision)
+            if (!reqAmount.mod(pairConfig?.baseRange.step).isZero()) {
+                reqAmount = reqAmount?.minus(reqAmount.mod(pairConfig?.baseRange.step));
+            }
+            buyPriceHandler(
+                reqAmount.toFormat(),
+                "reqAmount",
+            );
+        }
+    };
+
+    const fillBuyByBestPrice = () => {
+        buyPriceHandler(
+            bestBuyPrice?.toString(),
+            "pricePerUnit",
+        );
+    };
+
+    useEffect(() => {
+        fillBuyByBestPrice()
+    }, [bestBuyPrice]);
+
+
+    const submit = () => {
+        if (!isLogin) {
+            return false
+        }
+        if (isLoading) {
+            return false
+        }
+        setIsLoading(true)
+        createOrder(pairConfig?.symbol, "BUY", order)
+            .then((res) => {
+                setOrder({
+                    tradeFee: new BN(0),
+                    stopLimit: false,
+                    stopMarket: false,
+                    stopPrice: new BN(0),
+                    reqAmount: new BN(0),
+                    pricePerUnit: new BN(0),
+                    totalPrice: new BN(0),
+                })
+                toast.success(<Trans
+                    i18nKey="orders.success"
+                    values={{
+                        base: t("currency." + pairConfig?.baseAsset),
+                        quote: t("currency." + pairConfig?.quoteAsset),
+                        type: t("buy"),
+                        reqAmount: order.reqAmount,
+                        pricePerUnit: order.pricePerUnit,
+                    }}
+                />);
+                dispatch(setLastTransaction(res.data.transactTime))
+            }).catch(() => {
+            toast.error(t("orders.error"));
+            setAlert({
+                ...alert, submit: true
+            })
+        }).finally(() => {
+            setIsLoading(false)
+        })
+    }
+
+    const submitButtonTextHandler = () => {
+        if (isLoading) return <img className={`${classes.thisLoading}`} src={images.linearLoading} alt="linearLoading"/>
+
+        if (isLogin) return t("buy")
+
+        return t("pleaseLogin")
+    }
+
+    const isAllowed = ({floatValue}) => {
+        return floatValue < 10 ** 12;
+    }
+
+    const baseOnChangeHandler = (e) => {
+        const newBase = e.value;
+        const quoteOptions = availableQuote(newBase)
+
+        currentSymbolHandler(newBase, quoteOptions.includes(selected.quote) ? selected.quote : quoteOptions[0])
+
+        setOptions({
+            ...options,
+            "quote": quoteOptions,
+        })
+        setSelected({
+            base: newBase,
+            "quote": quoteOptions.includes(selected.quote) ? selected.quote : quoteOptions[0],
+        })
+    }
+
+
+    return (
+        <div className={`height-100 column jc-between ai-center py-2`}>
+            <TextInput
+                select={true}
+                placeholder={t('TransactionHistory.coin')}
+                options={options?.base.map((o)=>{return {
+                    value: o,
+                    label: <div className={`row jc-start ai-center`}>
+
+                        <div className={`${classes.avatar}`}
+                             style={{backgroundImage: `url("${images[o] }")`}}
+                        />
+                        <span className={`mr-1`}>{t('currency.'+ o)}</span>
+                    </div>
+                    }}
+                )}
+                lead={t("buy")}
+                type="select"
+                value={{
+                    value: selected?.base,
+                    label:  t('currency.'+ selected?.base),
+                }}
+                onchange={baseOnChangeHandler}
+                customClass={`width-90 ${classes.thisInput} mb-1`}
+            />
+
+            <div className={`row width-80 jc-between fs-0-9`}>
+                <p>{t("MarketInfo.lastPrice")}:{" "}</p>
+                <span>{new BN(bestBuyPrice).toFormat()}{" "}{t("currency." + pairConfig?.quoteAsset)}</span>
+            </div>
+
+            <TextInput
+                select={true}
+                placeholder={t('TransactionHistory.coin')}
+                options={options?.quote.map((o)=>{return { value: o,
+                    label: <div className={`row jc-start ai-center`}>
+
+                        <div className={`${classes.avatar}`}
+                             style={{backgroundImage: `url("${images[o] }")`}}
+                        />
+                        <span className={`mr-1`}>{t('currency.'+ o)}</span>
+                    </div>
+                    }}
+                )}
+                lead={t("with")}
+                type="select"
+                value={{
+                    value: selected?.quote,
+                    label:  selected?.quote ? t('currency.'+ selected?.quote) : t("PersonalizationForm.placeholder"),
+                }}
+                onchange={(e) => setSelected({...selected, quote: e.value})}
+                customClass={`width-90 ${classes.thisInput} my-1`}
+            />
+
+            <div className={`row width-80 jc-between fs-0-9 cursor-pointer`} onClick={() => {fillBuyByWallet()}}>
+                <p>{t("orders.availableAmount")}:{" "}</p>
+                <span>{new BN(quote).toFormat()}{" "}{t("currency." + pairConfig?.quoteAsset)}</span>
+            </div>
+
+            <span className={`my-2`}/>
+
+            <NumberInput
+                lead={t("orders.amount")}
+                after={t("currency." + selected.base)}
+                value={order.reqAmount.toFormat()}
+                maxDecimal={pairConfig?.baseAssetPrecision}
+                onchange={(e) => buyPriceHandler(e.target.value, "reqAmount")}
+                alert={alert.reqAmount}
+                customClass={`width-90 my-1`}
+                isAllowed={isAllowed}
+            />
+
+            <NumberInput
+                lead={t("orders.totalPrice")}
+                value={order?.totalPrice?.toFormat()}
+                maxDecimal={pairConfig?.quoteAssetPrecision}
+                after={t("currency." + selected.quote)}
+                onchange={(e) => buyPriceHandler(e.target.value, "totalPrice")}
+                alert={alert.totalPrice}
+                customClass={`width-90 my-1`}
+                isAllowed={isAllowed}
+            />
+
+            <div className="width-80 column jc-start fs-0-9 my-2">
+                <p>
+                    {t("orders.tradeFee")}:{" "}
+                    {order?.tradeFee?.toFormat()}{" "}
+                    {t("currency." + selected.base)}
+                </p>
+                <p>
+                    {t("orders.getAmount")}:{" "}
+                    {order?.reqAmount?.minus(order?.tradeFee).decimalPlaces(pairConfig?.baseAssetPrecision).toFormat()}{" "}
+                    {t("currency." + selected.base)}
+                </p>
+            </div>
+
+            <Button
+                buttonClass={`${classes.thisButton} ${classes.buyOrder} ${isLoading ? "cursor-not-allowed" : "cursor-pointer"} flex jc-center ai-center`}
+                type="submit"
+                onClick={submit}
+                disabled={alert.reqAmount || order.reqAmount.isZero() || order.pricePerUnit.isZero() || !isLogin || alert.totalPrice}
+                buttonTitle={submitButtonTextHandler()}
+            />
+        </div>
+    );
+};
+
+export default EasyBuyOrder;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css
new file mode 100644
index 00000000..e69de29b
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
new file mode 100644
index 00000000..25cc1484
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
@@ -0,0 +1,12 @@
+import React from 'react';
+import classes from './EasySellOrder.module.css';
+
+const EasySellOrder = () => {
+    return (
+        <div>
+
+        </div>
+    );
+};
+
+export default EasySellOrder;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css
new file mode 100644
index 00000000..e69de29b
diff --git a/src/main/Browser/Routes/routes.js b/src/main/Browser/Routes/routes.js
index 513db911..8554edd0 100644
--- a/src/main/Browser/Routes/routes.js
+++ b/src/main/Browser/Routes/routes.js
@@ -2,6 +2,7 @@ export const Landing = "/";
 export const Panel = "/panel";
 export const Login = "/login";
 export const AllMarket = "/all-market";
+export const EasyTrading = "/easy-trading";
 export const AboutUs = "/about-us";
 export const Commission = "/commission";
 export const TransferFees = "/transfer-fees";

From 1a597c6c4e0cb006111da69078be93393f0e5fb7 Mon Sep 17 00:00:00 2001
From: Benyamin <Koorosh.azimi1@gmail.com>
Date: Tue, 31 Oct 2023 16:40:07 +0330
Subject: [PATCH 2/4] Easy Order

---
 .../Browser/Pages/EasyTrading/EasyTrading.js  |  10 +-
 .../components/EasyOrder/EasyOrder.js         |  24 +-
 .../components/EasyBuyOrder/EasyBuyOrder.js   |   9 +-
 .../EasyOrder/EasyBuyOrder.module.css         |   0
 .../components/EasyOrder/EasyOrderNew.js      | 411 ++++++++++++++++++
 5 files changed, 415 insertions(+), 39 deletions(-)
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css
 create mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js

diff --git a/src/main/Browser/Pages/EasyTrading/EasyTrading.js b/src/main/Browser/Pages/EasyTrading/EasyTrading.js
index 97a66223..fd46723c 100644
--- a/src/main/Browser/Pages/EasyTrading/EasyTrading.js
+++ b/src/main/Browser/Pages/EasyTrading/EasyTrading.js
@@ -1,16 +1,8 @@
 import React from 'react';
-import classes from './EasyTrading.module.css'
-import {images} from "../../../../assets/images";
-import PriceInfo from "../AllMarket/components/PriceInfo/PriceInfo";
-import Swing from "../AllMarket/components/Swing/Swing";
-import VolumeInfo from "../AllMarket/components/VolumeInfo/VolumeInfo";
-import AllMarketInfo from "../AllMarket/components/AllMarketInfo/AllMarketInfo";
 import EasyOrder from "./components/EasyOrder/EasyOrder";
 
 const EasyTrading = () => {
-    return (
-        <EasyOrder/>
-    );
+    return <EasyOrder/>;
 };
 
 export default EasyTrading;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
index f358efce..1bcb4068 100644
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
@@ -1,44 +1,24 @@
 import React, {useState} from 'react';
 import classes from './EasyOrder.module.css'
 import {useTranslation} from "react-i18next";
-import {useDispatch} from "react-redux";
 import AccordionBox from "../../../../../../components/AccordionBox/AccordionBox";
-import EasyBuyOrder from "./components/EasyBuyOrder/EasyBuyOrder";
 import EasySellOrder from "./components/EasySellOrder/EasySellOrder";
-import {images} from "../../../../../../assets/images";
+import EasyOrderNew from "./components/EasyOrder/EasyOrderNew";
 
 const EasyOrder = () => {
-
     const {t} = useTranslation();
-    const dispatch = useDispatch();
-
     const [activeTab, setActiveTab] = useState(0);
 
-    const [selected, setSelected] = useState({
-        "base": null,
-        "quote": null,
-    })
-
-
     const data = [
-        {id: 1, title: t("buy"), body: <EasyBuyOrder setOutPutSelected={setSelected}/>},
+        {id: 1, title: t("buy"), body: <EasyOrderNew/>},
         {id: 2, title: t("sell"), body: <EasySellOrder/>},
     ];
 
     return (
         <div className={`container card-bg card-border my-2 ${classes.container} width-30`}>
-
-
-
             <AccordionBox
                 title={<div className={`width-100 row jc-between ai-center`}>
                     <span>{t("orders.title")}</span>
-                    {/*<div className={`${classes.avatar}  position-relative`}
-                         style={{backgroundImage: `url("${images[selected?.quote] }")`}}>
-                        <div className={`${classes.avatar} ${classes.backImg} position-absolute`}
-                             style={{backgroundImage: `url("${images[selected?.base] }")`}}
-                        />
-                    </div>*/}
                 </div>}
                 safari={classes.safariFlexSize}
                 content={data}
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
index c0cd0df0..d102e37d 100644
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
@@ -13,7 +13,7 @@ import {setLastTransaction} from "../../../../../../../../store/actions/auth";
 import {images} from "../../../../../../../../assets/images";
 import Button from "../../../../../../../../components/Button/Button";
 
-const EasyBuyOrder = ({setOutPutSelected}) => {
+const EasyBuyOrder = () => {
 
     const {t} = useTranslation();
     const dispatch = useDispatch();
@@ -41,13 +41,6 @@ const EasyBuyOrder = ({setOutPutSelected}) => {
         "quote": [],
     })
 
-    useEffect(() => {
-        setOutPutSelected({
-            "base": selected?.base,
-            "quote": selected?.quote,
-        })
-    }, [selected]);
-
     const {data} = useOrderBook(selected?.base + selected?.quote)
 
     useEffect(() => {
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css
new file mode 100644
index 00000000..e69de29b
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js
new file mode 100644
index 00000000..26befb6e
--- /dev/null
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js
@@ -0,0 +1,411 @@
+import React, {useEffect, useState} from 'react';
+import classes from '../../EasyOrder.module.css';
+import {Trans, useTranslation} from "react-i18next";
+import {useDispatch, useSelector} from "react-redux";
+import {useGetUserAccount} from "../../../../../../../../queries/hooks/useGetUserAccount";
+import {BN, parsePriceString} from "../../../../../../../../utils/utils";
+import {toast} from "react-hot-toast";
+import {useOrderBook} from "../../../../../../../../queries";
+import TextInput from "../../../../../../../../components/TextInput/TextInput";
+import NumberInput from "../../../../../../../../components/NumberInput/NumberInput";
+import {createOrder} from "js-api-client";
+import {setLastTransaction} from "../../../../../../../../store/actions/auth";
+import {images} from "../../../../../../../../assets/images";
+import Button from "../../../../../../../../components/Button/Button";
+
+const EasyOrderNew = () => {
+
+    const {t} = useTranslation();
+    const dispatch = useDispatch();
+    const {data: userAccount} = useGetUserAccount()
+    const [isLoading, setIsLoading] = useState(false)
+    const isLogin = useSelector((state) => state.auth.isLogin)
+
+    const symbols = useSelector((state) => state.exchange.symbols)
+
+    const [alert, setAlert] = useState({
+        submit: false,
+        reqAmount: null,
+        totalPrice: null,
+    });
+
+    const [order, setOrder] = useState({
+        tradeFee: new BN(0),
+        stopLimit: false,
+        stopMarket: false,
+        stopPrice: new BN(0),
+        reqAmount: new BN(0),
+        pricePerUnit: new BN(0),
+        totalPrice: new BN(0),
+    });
+
+    const handleAvailableAssets = () => {
+        const availableAssets = [];
+        for (const symbol of symbols) {
+            if (!availableAssets.includes(symbol.baseAsset)) availableAssets.push(symbol.baseAsset)
+            if (!availableAssets.includes(symbol.quoteAsset)) availableAssets.push(symbol.quoteAsset)
+        }
+        return availableAssets;
+    }
+
+    const handleAvailableDest = (buy) => {
+        const dest = []
+        for (const symbol of symbols) {
+            if (symbol.baseAsset === buy) dest.push(symbol.quoteAsset)
+            if (symbol.quoteAsset === buy) dest.push(symbol.baseAsset)
+        }
+        return dest
+    }
+
+    const findPair = (buy, sell) => symbols?.find(s => ((s?.baseAsset === buy) && (s?.quoteAsset === sell)) || ((s?.baseAsset === sell) && (s?.quoteAsset === buy)))
+
+    const [selected, setSelected] = useState({
+        buy: symbols[0].baseAsset,
+        sell: symbols[0].quoteAsset,
+        pair: findPair(symbols[0].baseAsset, symbols[0].quoteAsset),
+        type: "ask"
+    })
+
+    const [options, setOptions] = useState({
+            buy: handleAvailableAssets(),
+            sell: handleAvailableDest(handleAvailableAssets()[0]),
+        }
+    )
+
+    const {data: orderBook} = useOrderBook(selected.pair.symbol)
+
+    const bestPriceHandler = () => {
+        let bestPrice = 0;
+        if (orderBook && selected.type === "ask" && orderBook["asks"].length) {
+            bestPrice = orderBook["asks"][0][0]
+        }
+        if (orderBook && selected.type === "bid" && orderBook["bids"].length) {
+            bestPrice = orderBook["bids"][0][0];
+        }
+        setOrder({
+            ...order,
+            pricePerUnit: new BN(bestPrice)
+        })
+    }
+    useEffect(() => {
+        bestPriceHandler()
+    }, [orderBook, selected])
+
+
+    const buyPriceHandler = (value) => {
+        let newAlert = null
+        value = parsePriceString(value);
+        const reqAmount = new BN(value);
+        let range = "baseRange"
+        if (selected.type === "bid") range = "quoteRange"
+        if (reqAmount.isZero() && reqAmount.isLessThan(selected.pair[range].min)) {
+            newAlert = <Trans
+                i18nKey="orders.minOrder"
+                values={{
+                    min: selected.pair[range].min?.toString(),
+                    currency: t("currency." + selected.buy),
+                }}
+            />
+
+        }
+
+        if (reqAmount.isGreaterThan(selected.pair[range].max)) {
+            newAlert = <Trans
+                i18nKey="orders.maxOrder"
+                values={{
+                    max: selected.pair[range].max?.toLocaleString(),
+                    currency: t("currency." + selected.buy),
+                }}
+            />
+        }
+
+        if (!reqAmount.mod(selected.pair[range].step).isZero()) {
+            newAlert = <Trans
+                i18nKey="orders.divisibility"
+                values={{mod: selected.pair[range].step.toString()}}
+            />
+        }
+        setAlert({...alert, reqAmount: newAlert});
+
+        const price = selected.type === "ask" ? reqAmount.multipliedBy(order.pricePerUnit) : reqAmount.multipliedBy(order.pricePerUnit.pow(-1));
+        setOrder({
+            ...order,
+            reqAmount,
+            totalPrice: price,
+        });
+
+    };
+    const totalPriceHandler = (value) => {
+        let newAlert = null
+        value = parsePriceString(value);
+        const totalPrice = new BN(value);
+        let range = "quoteRange"
+        if (selected.type === "bid") range = "baseRange"
+
+        if (totalPrice.isZero() && totalPrice.isLessThan(selected.pair[range].min)) {
+            newAlert = <Trans
+                i18nKey="orders.minOrder"
+                values={{
+                    min: selected.pair[range].min?.toString(),
+                    currency: t("currency." + selected.sell),
+                }}
+            />
+
+        }
+
+        if (totalPrice.isGreaterThan(selected.pair[range].max)) {
+            newAlert = <Trans
+                i18nKey="orders.maxOrder"
+                values={{
+                    max: selected.pair[range].max?.toLocaleString(),
+                    currency: t("currency." + selected.sell),
+                }}
+            />
+        }
+
+        if (!totalPrice.mod(selected.pair[range].step).isZero()) {
+            newAlert = <Trans
+                i18nKey="orders.divisibility"
+                values={{mod: selected.pair[range].step.toString()}}
+            />
+        }
+        setAlert({...alert, totalPrice: newAlert});
+
+        const reqAmount = selected.type === "ask" ? totalPrice.dividedBy(order.pricePerUnit) : totalPrice.dividedBy(order.pricePerUnit.pow(-1));
+        setOrder({
+            ...order,
+            totalPrice: totalPrice,
+            reqAmount
+        });
+    };
+
+    const fillBuyByWallet = () => {
+        if (order.pricePerUnit.isEqualTo(0)) return toast.error(t("orders.hasNoOffer"));
+        let totalPrice = new BN(userAccount?.wallets[selected?.sell]?.free);
+        let reqAmount = totalPrice.dividedBy(order.pricePerUnit)
+        if (!reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step).isZero()) {
+            reqAmount = reqAmount.minus(reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step));
+        }
+        console.log(reqAmount.toFormat())
+        buyPriceHandler(
+            reqAmount.toFormat(),
+            "reqAmount",
+        );
+
+    };
+
+    const submit = () => {
+        if (!isLogin) return
+        if (isLoading) return
+
+        setIsLoading(true)
+        const newOrder = {...order}
+        if (selected.type === "bid") {
+            newOrder.reqAmount = order.totalPrice.decimalPlaces(selected.pair?.baseAssetPrecision)
+        }
+        createOrder(selected.pair?.symbol, selected.type === "ask" ? "BUY" : "SELL", newOrder)
+            .then((res) => {
+                setOrder({
+                    tradeFee: new BN(0),
+                    stopLimit: false,
+                    stopMarket: false,
+                    stopPrice: new BN(0),
+                    reqAmount: new BN(0),
+                    pricePerUnit: new BN(0),
+                    totalPrice: new BN(0),
+                })
+                toast.success(<Trans
+                    i18nKey="orders.success"
+                    values={{
+                        base: t("currency." + selected.pair?.baseAsset),
+                        quote: t("currency." + selected.pair?.quoteAsset),
+                        type: t("buy"),
+                        reqAmount: order.reqAmount,
+                        pricePerUnit: order.pricePerUnit,
+                    }}
+                />);
+                dispatch(setLastTransaction(res.data.transactTime))
+            }).catch(() => {
+            toast.error(t("orders.error"));
+            setAlert({
+                ...alert, submit: true
+            })
+        }).finally(() => {
+            setIsLoading(false)
+        })
+    }
+
+    const submitButtonTextHandler = () => {
+        if (isLoading) return <img className={`${classes.thisLoading}`} src={images.linearLoading} alt="linearLoading"/>
+        if (isLogin) return t("buy")
+        return t("pleaseLogin")
+    }
+
+
+    const isAllowed = ({floatValue}) => {
+        return floatValue < 10 ** 12;
+    }
+
+    const buyOnChangeHandler = (e) => {
+        const newBuy = e.value;
+        const sellOptions = handleAvailableDest(newBuy)
+
+        setOptions({
+            ...options,
+            "sell": sellOptions,
+        })
+        const sell = sellOptions.includes(selected.sell) ? selected.sell : sellOptions[0];
+        const pair = findPair(newBuy, sell)
+        setSelected({
+            buy: newBuy,
+            sell,
+            pair,
+            type: newBuy === pair.baseAsset ? "ask" : "bid"
+        })
+        setOrder({
+            tradeFee: new BN(0),
+            stopLimit: false,
+            stopMarket: false,
+            stopPrice: new BN(0),
+            reqAmount: new BN(0),
+            pricePerUnit: new BN(0),
+            totalPrice: new BN(0),
+        })
+    }
+    const sellOnChangeHandler = (e) => {
+        const newSell = e.value;
+        const pair = findPair(selected.buy, newSell)
+        setSelected({
+            ...selected,
+            sell: newSell,
+            pair,
+            type: selected.buy === pair.baseAsset ? "ask" : "bid"
+        })
+        setOrder({
+            tradeFee: new BN(0),
+            stopLimit: false,
+            stopMarket: false,
+            stopPrice: new BN(0),
+            reqAmount: new BN(0),
+            pricePerUnit: new BN(0),
+            totalPrice: new BN(0),
+        })
+    }
+    const showBestPrice = () => {
+        if (order.pricePerUnit.isZero()) return 0
+        if (selected.type === "ask") return order.pricePerUnit.toFormat()
+        return new BN(1).dividedBy(order.pricePerUnit).decimalPlaces(selected.pair?.baseAssetPrecision).toFormat()
+    }
+
+    useEffect(() => {
+        if (order.totalPrice.isGreaterThan(userAccount?.wallets[selected?.sell]?.free)) {
+            return setAlert({
+                ...alert,
+                totalPrice: t('orders.notEnoughBalance')
+            })
+        }
+        return setAlert({
+            ...alert,
+            totalPrice: null
+        })
+    }, [order.totalPrice])
+
+    return (
+        <div className={`height-100 column jc-between ai-center py-2`}>
+            <TextInput
+                select={true}
+                placeholder={t('TransactionHistory.coin')}
+                options={options?.buy.map((o) => {
+                        return {
+                            value: o,
+                            label: <div className={`row jc-start ai-center`}>
+                                <div className={`${classes.avatar}`}
+                                     style={{backgroundImage: `url("${images[o]}")`}}
+                                />
+                                <span className={`mr-1`}>{t('currency.' + o)}</span>
+                            </div>
+                        }
+                    }
+                )}
+                lead={t("buy")}
+                type="select"
+                value={{
+                    value: selected?.buy,
+                    label: t('currency.' + selected?.buy),
+                }}
+                onchange={buyOnChangeHandler}
+                customClass={`width-90 ${classes.thisInput} mb-1`}
+            />
+
+            <div className={`row width-80 jc-between fs-0-9`}>
+                <p>{t("MarketInfo.lastPrice")}:{" "}</p>
+                <span>{showBestPrice()}{" "}{t("currency." + selected?.sell)}</span>
+            </div>
+
+            <TextInput
+                select={true}
+                placeholder={t('TransactionHistory.coin')}
+                options={options?.sell.map((o) => {
+                        return {
+                            value: o,
+                            label: <div className={`row jc-start ai-center`}>
+
+                                <div className={`${classes.avatar}`}
+                                     style={{backgroundImage: `url("${images[o]}")`}}
+                                />
+                                <span className={`mr-1`}>{t('currency.' + o)}</span>
+                            </div>
+                        }
+                    }
+                )}
+                lead={t("with")}
+                type="select"
+                value={{
+                    value: selected?.sell,
+                    label: selected?.sell ? t('currency.' + selected?.sell) : t("PersonalizationForm.placeholder"),
+                }}
+                onchange={sellOnChangeHandler}
+                customClass={`width-90 ${classes.thisInput} my-1`}
+            />
+
+            <div className={`row width-80 jc-between fs-0-9 cursor-pointer`}>
+                <p>{t("orders.availableAmount")}:{" "}</p>
+                <span
+                    onClick={fillBuyByWallet}>{new BN(userAccount?.wallets[selected?.sell]?.free || 0).toFormat()}{" "}{t("currency." + selected?.sell)}</span>
+            </div>
+
+            <span className={`my-2`}/>
+
+            <NumberInput
+                lead={t("orders.amount")}
+                after={t("currency." + selected.buy)}
+                value={order.reqAmount.toFormat()}
+                maxDecimal={selected.type === "ask" ? selected.pair?.baseAssetPrecision : selected.pair?.quoteAssetPrecision}
+                onchange={(e) => buyPriceHandler(e.target.value)}
+                alert={alert.reqAmount}
+                customClass={`width-90 my-1`}
+                isAllowed={isAllowed}
+            />
+            <NumberInput
+                lead={t("orders.totalPrice")}
+                value={order?.totalPrice?.toFormat(selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision)}
+                maxDecimal={selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision}
+                after={t("currency." + selected.sell)}
+                onchange={(e) => totalPriceHandler(e.target.value)}
+                alert={alert.totalPrice}
+                customClass={`width-90 my-1`}
+                isAllowed={isAllowed}
+            />
+
+            <Button
+                buttonClass={`${classes.thisButton} ${classes.buyOrder} ${isLoading ? "cursor-not-allowed" : "cursor-pointer"} flex jc-center ai-center`}
+                type="submit"
+                onClick={submit}
+                disabled={alert.reqAmount || order.reqAmount.isZero() || order.pricePerUnit.isZero() || !isLogin || alert.totalPrice}
+                buttonTitle={submitButtonTextHandler()}
+            />
+        </div>
+    );
+};
+
+export default EasyOrderNew;

From 8ba54c49906b4092ff363de652b66e1ab22bb303 Mon Sep 17 00:00:00 2001
From: Hossein <hossein13785ab@gmail.com>
Date: Wed, 1 Nov 2023 17:22:00 +0330
Subject: [PATCH 3/4] #175: Add reversePair function

---
 src/assets/fontIcon/opex-icon/config.json     |  14 +
 .../opex-icon/css/opex-icon-codes.css         |   1 +
 .../opex-icon/css/opex-icon-embedded.css      |  13 +-
 .../opex-icon/css/opex-icon-ie7-codes.css     |   1 +
 .../fontIcon/opex-icon/css/opex-icon-ie7.css  |   1 +
 .../fontIcon/opex-icon/css/opex-icon.css      |  15 +-
 src/assets/fontIcon/opex-icon/demo.html       |  45 +-
 .../fontIcon/opex-icon/font/opex-icon.eot     | Bin 38936 -> 39172 bytes
 .../fontIcon/opex-icon/font/opex-icon.svg     |   2 +
 .../fontIcon/opex-icon/font/opex-icon.ttf     | Bin 38764 -> 39000 bytes
 .../fontIcon/opex-icon/font/opex-icon.woff    | Bin 24036 -> 24224 bytes
 .../fontIcon/opex-icon/font/opex-icon.woff2   | Bin 20140 -> 20264 bytes
 .../components/EasyOrder/EasyOrder.js         | 445 ++++++++++++++++-
 .../components/EasyOrder/EasyOrder.module.css |   6 +-
 .../components/EasyBuyOrder/EasyBuyOrder.js   | 448 ------------------
 .../EasyBuyOrder/EasyBuyOrder.module.css      |   0
 .../EasyOrder/EasyBuyOrder.module.css         |   0
 .../components/EasyOrder/EasyOrderNew.js      | 411 ----------------
 .../components/EasySellOrder/EasySellOrder.js |  12 -
 .../EasySellOrder/EasySellOrder.module.css    |   0
 20 files changed, 488 insertions(+), 926 deletions(-)
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
 delete mode 100644 src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css

diff --git a/src/assets/fontIcon/opex-icon/config.json b/src/assets/fontIcon/opex-icon/config.json
index c7f9812d..acd47d48 100644
--- a/src/assets/fontIcon/opex-icon/config.json
+++ b/src/assets/fontIcon/opex-icon/config.json
@@ -937,6 +937,20 @@
       "search": [
         "cicle-plus-01"
       ]
+    },
+    {
+      "uid": "f022243a5960b8c63529a647d92d78bf",
+      "css": "exchange-arrow",
+      "code": 528,
+      "src": "custom_icons",
+      "selected": true,
+      "svg": {
+        "path": "M304.5 1000C290.9 1000 281.8 995.5 272.7 986.4L13.6 727.3C-4.5 709.1-4.5 681.8 13.6 663.6S59.1 645.5 77.3 663.6L259.1 845.5V45.5C259.1 18.2 277.3 0 304.5 0S350 18.2 350 45.5V954.5C350 972.7 340.9 990.9 322.7 995.5 318.2 1000 309.1 1000 304.5 1000ZM500 1000C472.7 1000 454.5 981.8 454.5 954.5V45.5C454.5 27.3 463.6 9.1 481.8 4.5 500-4.5 518.2 0 531.8 13.6L790.9 272.7C809.1 290.9 809.1 318.2 790.9 336.4S745.5 354.5 727.3 336.4L545.5 154.5V954.5C545.5 981.8 527.3 1000 500 1000Z",
+        "width": 818
+      },
+      "search": [
+        "exchange-arrow"
+      ]
     }
   ]
 }
\ No newline at end of file
diff --git a/src/assets/fontIcon/opex-icon/css/opex-icon-codes.css b/src/assets/fontIcon/opex-icon/css/opex-icon-codes.css
index 044417c9..657818a2 100644
--- a/src/assets/fontIcon/opex-icon/css/opex-icon-codes.css
+++ b/src/assets/fontIcon/opex-icon/css/opex-icon-codes.css
@@ -75,6 +75,7 @@
 .icon-trash-1:before { content: '\0207'; } /* 'ȇ' */
 .icon-trash-2:before { content: '\0208'; } /* 'Ȉ' */
 .icon-cicle-plus-01:before { content: '\0209'; } /* 'ȉ' */
+.icon-exchange-arrow:before { content: '\0210'; } /* 'Ȑ' */
 .icon-market:before { content: '\e800'; } /* '' */
 .icon-cancel-circled2:before { content: '\e801'; } /* '' */
 .icon-settings:before { content: '\e802'; } /* '' */
diff --git a/src/assets/fontIcon/opex-icon/css/opex-icon-embedded.css b/src/assets/fontIcon/opex-icon/css/opex-icon-embedded.css
index a39a20fe..48d5ff0b 100644
--- a/src/assets/fontIcon/opex-icon/css/opex-icon-embedded.css
+++ b/src/assets/fontIcon/opex-icon/css/opex-icon-embedded.css
@@ -1,15 +1,15 @@
 @font-face {
   font-family: 'opex-icon';
-  src: url('../font/opex-icon.eot?22057364');
-  src: url('../font/opex-icon.eot?22057364#iefix') format('embedded-opentype'),
-       url('../font/opex-icon.svg?22057364#opex-icon') format('svg');
+  src: url('../font/opex-icon.eot?72312620');
+  src: url('../font/opex-icon.eot?72312620#iefix') format('embedded-opentype'),
+       url('../font/opex-icon.svg?72312620#opex-icon') format('svg');
   font-weight: normal;
   font-style: normal;
 }
 @font-face {
   font-family: 'opex-icon';
-  src: url('data:application/octet-stream;base64,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') format('woff'),
-       url('data:application/octet-stream;base64,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') format('truetype');
+  src: url('data:application/octet-stream;base64,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') format('woff'),
+       url('data:application/octet-stream;base64,AAEAAAAPAIAAAwBwR1NVQiCLJXoAAAD8AAAAVE9TLzJXU0oeAAABUAAAAGBjbWFw+HXFfgAAAbAAAAf8Y3Z0IAAAAAAAAImgAAAADmZwZ21iLvl6AACJsAAADgxnYXNwAAAAEAAAiZgAAAAIZ2x5ZpmzqfIAAAmsAAB0uGhlYWQmtKoEAAB+ZAAAADZoaGVhCBkElQAAfpwAAAAkaG10eJAL/6IAAH7AAAABwGxvY2HKb6zkAACAgAAAAOJtYXhwAowQDwAAgWQAAAAgbmFtZewZB3MAAIGEAAAC2XBvc3TB3w/9AACEYAAABTdwcmVwfrY7tgAAl7wAAACcAAEAAAAKADAAPgACREZMVAAObGF0bgAaAAQAAAAAAAAAAQAAAAQAAAAAAAAAAQAAAAFsaWdhAAgAAAABAAAAAQAEAAQAAAABAAgAAQAGAAAAAQAAAAQDkgGQAAUAAAJ6ArwAAACMAnoCvAAAAeAAMQECAAACAAUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBmRWQAwAEA6CEDUv9qAFoDrADGAAAAAQAAAAAAAAAAAAAAAAACAAAABQAAAAMAAAAsAAAABAAAArgAAQAAAAABsgADAAEAAAAsAAMACgAAArgABAGGAAAAJgAgAAQABgEJARMBJAEpATkBSAFUAVkBYwFmAXMBeQGJAZYCAwIJAhDoIf//AAABAAEQASABJwEwAUABVAFWAWEBZQFzAXkBgAGQAgICBgIQ6AD//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABACYAOAA+AEYASgBcAGwAbAByAHYAeAB4AHgAigCWAJgAngCeAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAaABsAHAAdAB4AHwAgACEAIgAjACQAJQAmACcAKAApACoAKwAsAC0ALgAvADAAMQAyADMANAA1ADYANwA4ADkAOgA7ADwAPQA+AD8AQABBAEIAQwBEAEUARgBHAEgASQBKAEsATABNAE4ATwBQAFEAUgBTAFQAVQBWAFcAWABZAFoAWwBcAF0AXgBfAGAAYQBiAGMAZABlAGYAZwBoAGkAagBrAGwAbQBuAG8AAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAABUQAAAAAAAAAbwAAAQAAAAEAAAAAAQAAAQEAAAEBAAAAAgAAAQIAAAECAAAAAwAAAQMAAAEDAAAABAAAAQQAAAEEAAAABQAAAQUAAAEFAAAABgAAAQYAAAEGAAAABwAAAQcAAAEHAAAACAAAAQgAAAEIAAAACQAAAQkAAAEJAAAACgAAARAAAAEQAAAACwAAAREAAAERAAAADAAAARIAAAESAAAADQAAARMAAAETAAAADgAAASAAAAEgAAAADwAAASEAAAEhAAAAEAAAASIAAAEiAAAAEQAAASMAAAEjAAAAEgAAASQAAAEkAAAAEwAAAScAAAEnAAAAFAAAASgAAAEoAAAAFQAAASkAAAEpAAAAFgAAATAAAAEwAAAAFwAAATEAAAExAAAAGAAAATIAAAEyAAAAGQAAATMAAAEzAAAAGgAAATQAAAE0AAAAGwAAATUAAAE1AAAAHAAAATYAAAE2AAAAHQAAATcAAAE3AAAAHgAAATgAAAE4AAAAHwAAATkAAAE5AAAAIAAAAUAAAAFAAAAAIQAAAUEAAAFBAAAAIgAAAUIAAAFCAAAAIwAAAUMAAAFDAAAAJAAAAUQAAAFEAAAAJQAAAUUAAAFFAAAAJgAAAUYAAAFGAAAAJwAAAUcAAAFHAAAAKAAAAUgAAAFIAAAAKQAAAVQAAAFUAAAAKgAAAVYAAAFWAAAAKwAAAVcAAAFXAAAALAAAAVgAAAFYAAAALQAAAVkAAAFZAAAALgAAAWEAAAFhAAAALwAAAWIAAAFiAAAAMAAAAWMAAAFjAAAAMQAAAWUAAAFlAAAAMgAAAWYAAAFmAAAAMwAAAXMAAAFzAAAANAAAAXkAAAF5AAAANQAAAYAAAAGAAAAANgAAAYEAAAGBAAAANwAAAYIAAAGCAAAAOAAAAYMAAAGDAAAAOQAAAYQAAAGEAAAAOgAAAYUAAAGFAAAAOwAAAYYAAAGGAAAAPAAAAYcAAAGHAAAAPQAAAYgAAAGIAAAAPgAAAYkAAAGJAAAAPwAAAZAAAAGQAAAAQAAAAZEAAAGRAAAAQQAAAZIAAAGSAAAAQgAAAZMAAAGTAAAAQwAAAZQAAAGUAAAARAAAAZUAAAGVAAAARQAAAZYAAAGWAAAARgAAAgIAAAICAAAARwAAAgMAAAIDAAAASAAAAgYAAAIGAAAASQAAAgcAAAIHAAAASgAAAggAAAIIAAAASwAAAgkAAAIJAAAATAAAAhAAAAIQAAAATQAA6AAAAOgAAAAATgAA6AEAAOgBAAAATwAA6AIAAOgCAAAAUAAA6AMAAOgDAAAAUQAA6AQAAOgEAAAAUgAA6AUAAOgFAAAAUwAA6AYAAOgGAAAAVAAA6AcAAOgHAAAAVQAA6AgAAOgIAAAAVgAA6AkAAOgJAAAAVwAA6AoAAOgKAAAAWAAA6AsAAOgLAAAAWQAA6AwAAOgMAAAAWgAA6A0AAOgNAAAAWwAA6A4AAOgOAAAAXAAA6A8AAOgPAAAAXQAA6BAAAOgQAAAAXgAA6BEAAOgRAAAAXwAA6BIAAOgSAAAAYAAA6BMAAOgTAAAAYQAA6BQAAOgUAAAAYgAA6BUAAOgVAAAAYwAA6BYAAOgWAAAAZAAA6BcAAOgXAAAAZQAA6BgAAOgYAAAAZgAA6BkAAOgZAAAAZwAA6BoAAOgaAAAAaAAA6BsAAOgbAAAAaQAA6BwAAOgcAAAAagAA6B0AAOgdAAAAawAA6B4AAOgeAAAAbAAA6B8AAOgfAAAAbQAA6CAAAOggAAAAbgAA6CEAAOghAAAAbwABAAD/5wO2AikAFAAZQBYNAQABAUwCAQEAAYUAAAB2FBcSAwYZKwkBBiInASY0PwE2MhcJATYyHwEWFAOr/mIKHgr+YgsLXQoeCgEoASgLHAxcCwGP/mMLCwGdCx4KXAsL/tgBKAsLXAscAAABAAAAAAO2AkYAFAAZQBYFAQACAUwAAgAChQEBAAB2FxQSAwYZKyUHBiInCQEGIi8BJjQ3ATYyFwEWFAOrXAseCv7Y/tgLHAtdCwsBngscCwGeC2tcCgoBKf7XCgpcCx4KAZ4KCv5iCxwAAAAC//n/vgGhAv8AJwAsAClAJgAEBQSFAAUCBYUAAgEChQABAwGFAAMAA4UAAAB2ERQYKScmBgYcKyU2FgcOAiMiJyY/ATYnJiMiDwIGJjc+AjMyFxYPAQYXFjMyNjcDNCAQIAFLEhgQBSJUKm0oIzA0HBkFEQsNFgcTGBAHHlYpbycjLzUbGQMSCxoJpgEE/vwlBiQQBRYeT0pdaDcSBQMFAgckDgcUIE9JXmg4EgMEAwJbgv78AAAAAQAA/70DQwL/ABsANUAyAAUABYUAAgEChgQGAgABAQBXBAYCAAABXwMBAQABTwEAGBcUEg8NCgkGBAAbARsHBhYrATIeAQYvARUUDgEmJzcHIiY0NjczJzQ2MhYHFQLZLDwCQCrQPFo4AgPULDw8LNQDPFZAAgHGPlQ+AQPUKzwCQCnUAzxWPAHRKj4+KtEAAv/1/34D3AMyAB0ANAAlQCIyLiomIhoJAwgAAQFMAAEAAYUCAQAAdgEAExEAHQEdAwYWKwUiLwEHBicmPwEvASY2PwI2MzIfAh4BDwEXFgYBDgEPATc2HwEnJj8BJyYvAQcGDwEXFgLlExTV1ywoKQoyVGMlIDL0ZhYyLxhl9TAiJrcyBy7+MgEMCxS+Gxm+LAYWodkeC1paDR7YoRV2DHl5GBsdMvNLWiNeBxrhLy/hGwRgI6byIzoBVgRANFxrDg5r1R0UlBcEGsfHGgQXlBMAAAAB//z/ugNpAv0AGgARQA4WEAsDAEkAAAB2EwEGFysBNjc2Mh8BBR4BDwETFgYvAQYHBiY3EycmNjcBKUUtBiQFcgESDwwMzDcDGg7wkGAPGgI4zAwMDwHymGQPD/weAx4Mu/7yDxQIiFE3CRYOAQ67Cx4EAAEAAAAAAnQClwAdAB5AGxoTDAQEAAIBTAMBAgAChQEBAAB2FBgUGQQGGisBFhQPARcWFAcGIi8BBwYiJjQ/AScmNDYyHwE3NjICVCAgh4cgIB5WH4eHHlg9H4eHHz1YHoeHHlgCeB9WH4eHH1QgHh6Hhx49Vh6HhyBUPx+Hhx8AA//1//IEIALLABkAIgAsADZAMwABAAMFAQNpAAUABAIFBGkGAQIAAAJZBgECAgBhAAACAFEbGisqJiUfHhoiGyIcFwcGGCsBFgcOAgcGICcuAicmNz4CNzYgFx4CBTI2NCYiBhQWNxQGLgI2NzIWBAoWFgc2fEFw/tVwQH40CBYWBjZ+QHEBKXFAfjb+B0tqapdqarQ8WDwCQCorPAF8HR4LRoIsUFAtgEgKHR4LRoAsUlItfkjfbJdqapdstys+AjpaOAQ+AAAJ//n/bgPbA04ABwAPABcAHwAnAC8ANwA/AEgAMUAuPDcsJxwJBgMCAUwAAAIAhQQBAgMChQADAQOFAAEBdkFARURASEFINTQlJAUGFisBJyY2NzYWBwEXBwYmJyY2ARcWBgcGJjcBFgYvATc2FiUuATc2Fh8BAyY2PwEHDgElHgEHBiYvARMWBg8BNz4BBTIWDgIuATYB6zUHFBUeNAz+K5qaFSoHCiwBxjMHFBUeNAwCGwosJJmZFSr81BUOChBED0eRHwIdkUcKKgKCFQ4KEEQPR5EfAh2RRwoq/stgigKGxIgCjAJmmBYoCAoqJv6VNTQIFhUeNP63mBUqBwosJAGyHjYONDUHFNoKKhUgBByR/eIQRA9HkRUObQosFB8CHZECHhBEDkiRFg6EisKIBJC6kgAAAAAK//n/bgPbA04ABwAPABcAHwAnAC8ANwA/AEgAUQBXQFQBAQMAOSECBAMZCQIFBDEpAgIFEQEBAgVMAAADAIUAAQIBhgADBwEEBQMEaQAFAgIFWQAFBQJhBgECBQJRSklBQE5NSVFKUUVEQEhBSDc2JyYIBhYrAQcnJjY3NhYBFwcGJicmNgE3FxYGBwYmASc3NhYXFgYBFycuATc2FgM3Bw4BJyY2BScXHgEHBiYTBzc+ARcWBgEiJjQ2HgEUBgMiBhQWMjY0JgIeMzUHFBUeNP4fmZkVKgcKLAGRNTMHFBUeNAHhmZkVKgcKLP05R5EVDgoQRDuRRwoqFh8CAmtHkRUOChBEO5FHCioWHwL+mGGKisKIiGE2Tk5sTEwC/piYFigICir+bzU0CBYVHjT+H5iYFSoHCiwBkDQ1BxQWHjYBjZFICioVIAT9mEeRFQ4KEEQ7kUcKLBQfAgJqSJEWDgsQRP4FjL6OBIbGhAFpTGxMTGxMAAAAAwAAAAADkAI/ABIAHAAmAD1AOiMaDgUEBQQBTAEBAAYIAgQFAARpBwEFAgIFWQcBBQUCYQMBAgUCURQTJiUhIBgXExwUHBQTFBIJBhorETQ2Mh8BNzYyHgEGIi8BBwYiJjciBhQeAT8BJyYFNjQmBg8BFxYyhLpCSElBuIQCiLZCSElBuoThJzg4Th1ERB0B6hs2UBtGRRtQAV5dhEJFRkGEuoRCRUZBhLw4TzYCHUNCHaIbUDgCGkRCHAABAAAAAAMxAlIADgASQA8MBQIASQEBAAB2FBICBhgrETQ2MhcJATYyFhQHCQEmJDQQATEBMBIyJBL+ev55EgIVGSQS/tEBLxIkMhL+eQGHEwAAAAABAAAAAAMwAlkADgASQA8KAwIASgEBAAB2FBcCBhgrNTQ3CQEWFAYiJwkBBiImEgGHAYYRIzQR/tH+zxIyJKcaEQGH/nkRNCMRATH+zxEjAAL///9qA+gDUwAkAE8ALUAqCQECAQFMAAECAYUAAgMChQADAAADWQADAwBfAAADAE9LSjY1GBczBAYXKwERFAYjISImNxE0PgM/ATY/AT4DHgMfAR4GATY3PgEvAS4BBwYHBg8BDgEuAycmJyYGDwEGFhcWFx4EMj4DA+g0JfzKJDYBCyIMKBM1Ii5sAjYaLh4wGDYCbC5EKCYMIgv+xZMuBgIFFQQQBYE/AhsnDDAeLho2AmhYBg4FFQUCBi6TBS4aLigsKDAYMgHl/d4lNDQlAiIICSAIIg4oGiJPAigSFgISFiQETyI0HCIIIAn+smoiBQ4GHQYCBV4tAhQdCRYCEhYkBEpBBQIGHQYOBSJqBSISGgwMHBAkAAAAAQAA/8oDoQNAAB8AHUAaEg8KBAMFAAIBTAACAAKFAQEAAHYdFBcDBhkrARQPARMVFA4BLwEHBiImNTQ3EycmNTQ3JTc2Mh8BBRYDoQ/KMAwVDPv6DBYMATDLDh8BGH4LIAx9ARggAekMD8X+6QwLEAEHhIQHEgoECAEXxQ8MFQUo/hcX/igFAAQAAP9pBJsDUQAUAB0AJgAvADBALQwGAgADAUwIAQBJAAECAYUGBAICAwKFBwUCAwADhQAAAHYTFBMUExUcIwgGHisBFAYEJyInFwU+AT8BJjU0NiQgBBYHNCYiBhQWMjYnNCYiBhQWMjYnNCYiBhQWMjYEm57+8KB6cAL+myw2BARqngEQAT4BEpz5KjsqKjsq+io7Kio7KvoqOyoqOyoBgX7WfgEnA2s7hicmeJJ+1nx81n4dKio7KioeHSoqOyoqHh0qKjsqKgAAAAEAAP9pBJsDUQAUABxAGQwGAgABAUwIAQBJAAEAAYUAAAB2HCMCBhgrARQGBCciJxcFPgE/ASY1NDYkIAQWBJue/vCgenAC/pssNgQEap4BEAE+ARKcAYF+1n4BJwNrO4YnJniSftZ8fNYAAAEAAP9pA+gCwwAmABxAGRsBAAEBTA0BAEkAAQABhQAAAHYkIiMCBhcrARQOASMiJwYHBgcGJic1JjYmPwE2PwE+Aj8BLgEnND4CMzIeAQPohuaIJypukxskCg4DAgQCAwwEDRQHFBAHD1hkAVCEvGSI5oYBXmGkYARhJggEAQwKAQIIBAMPBQ4WCBwcEyoyklRJhGA4YKQAB////2oEdwMLAAIABQAJAAwAEAAUACYAUkBPAQEJAAFMAAkACYYACggGAgIDCgJnBwUMAwMAAANXBwUMAwMDAF8EAQsDAAMATwYGAAAmIxwbFBMSERAPDg0MCwYJBgkIBwUEAAIAAg0GFisTAQMBEyEnNyMHCQEjJSEnIwUzJyM3ExYUBwEGIicBLgE3EzYzITJ2AVynARDD/ntNcpKhAjoBXLX+MQF9cpkBXMGhksDXBwr96QoiCf3pCQII1woSAoMSAaX+jQFz/lIBrkjW1v5FAXNI1tbWOf7iChoJ/cQLCwI8CRoKAR4PAAACAAD/tgK8AwgAGwAjADVAMgQCBgMABQEFAAGAAAEBhAADBQUDWQADAwVhAAUDBVEBACIhHh0YFxQSCwgAGwEbBwYWKwEyFhURFA8BBiMhIi8BJjURNDY7ATU0NjIWHQElFTM1NCYiBgKAFCgwPCo2/t44KjwwHhRkZsRm/tTINlw2AdwmFv56MBISEBASEjABhhYmRm54eG5GWlpaNDo6AAAAAAP//v9pA+gDUgARACUALgCTtR8BAQQBTEuwDFBYQDMABgIDAgZyBQEDBwIDB34ABwQCBwR+AAQBAgQBfgABAYQIAQACAgBZCAEAAAJhAAIAAlEbQDQABgIDAgYDgAUBAwcCAwd+AAcEAgcEfgAEAQIEAX4AAQGECAEAAgIAWQgBAAACYQACAAJRWUAXAQAtLCkoJSQjIiEgGRgKCQARAREJBhYrATIeAhcUDgIuBD4CATY1NC4CIg4CBxQXNjMWMjcyJzQmDgIeATYB9Ga4iEwCToi20LaITARUgMABu1REdJ6unnRCAlQkhknMSYZffLR6BIKshANSUIS8ZGW6hFICToa6yrqGTv0Pc4tXnnRERHSeV4tzt0hIsll+Anq2eAaEAAADAAD/owLZAxkAFwAgACgASUBGAggCAAYHBgAHgAADAAYAAwZpCQEHAAUEBwVpAAQBAQRZAAQEAV8AAQQBTyEhAQAhKCEoJSQdHBkYFBMQDgkGABcBFwoGFisBMhYXERQGIyEiJjURNDY3MzU0NjIWBxUDMjY0Jg4CFhM1NCYiBgcVAnErPAE+Kv33LDw8LDR8qnwB0BwoKDgmAiqCPlY8AQHgPir+kyo+PioBbSs8AWlWenpWaf5RKDYqAiY6JAF6nCw8PiqcAAQAAP+jAtkDGQAEAB8AKAAsAJhLsBlQWEA0BQEDBgcHA3IKAQILAQYDAgZpAAcACAAHCGgAAAABCQABaQwBCQQECVcMAQkJBF8ABAkETxtANQUBAwYHBgMHgAoBAgsBBgMCBmkABwAIAAcIaAAAAAEJAAFpDAEJBAQJVwwBCQkEXwAECQRPWUAhKSkhIAYFKSwpLCsqJSQgKCEoGhgTEAsJBR8GHxERDQYYKyU0MhYmEzIWFxUzMhYXERQGIyEiJjURNDY3MzU0Njc2FyIGBxUzNTQmExEhEQEqhgKKRVV6ATQrPAE+Kv33LDw8LDQ8LDA5LDwB0T7a/fd0RIgCAud8VGk+Kv6TKj4+KgFtKzwBaTxeGhxoPiqcnCw8/VoBbf6TAAADAAD/tgLZAwUAGgAoADgAV0BUNC0mJR8eBgcENSwCAQgMAQAGA0wABAUHBQQHgAAHCAUHCH4AAgAChgADAAUEAwVpAAgAAQYIAWkABgAABlkABgYAYQAABgBRJiMdEhIWFBIXCQYfKwE2FhURFAcGIicuAQcVFAYuATURNDc2MhcWMgUuAQcVNhYXHgE3NQYmEx4BNzUGIyInLgEHFTYzMgKAGUAPUOJQL34zHiogD1DiUDKM/vkvfjNDnDgwijhIqBAvfjM2MmRLMIo4NDVwArUZHCH+XhUPUFAuCCjuFSACHBcCphUPUFAyGC8GJ3chGjYxDiN6ICD+5C4IKHcZSDEOJHgVAAABAAD/tgLZAwUAGgApQCYMAQABAUwAAwQDhQAEAQSFAAEAAYUAAAIAhQACAnYSFhQSFwUGGysBNhYVERQHBiInLgEHFRQGLgE1ETQ3NjIXFjICgBlAD1DiUC9+Mx4qIA9Q4lAyjAK1GRwh/l4VD1BQLggo7hUgAhwXAqYVD1BQMgAAAAAGAAD/vgR7Av8ADwAfACsANwA8AEcAb0BsAAENAQIIAQJnAAcPAQYJBwZnAAgACQUICWkABQ4BBAsFBGcQAQoACwMKC2kAAwAAA1cAAwMAXwwBAAMATz49LiwiIBEQAgBDQj1HPkc8Ozo5NDEsNy43KCUgKyIrGRYQHxEeCgcADwIPEQYWKwUhIiYnETQ2MyEyFgcRFAYBIgYXERQWNyEyNjURNCYnASMiJjQ2OwEyFg4BJyMiJjQ2OwEyFg4BNzQyFiIXMhYXFAYiJjU0NgPe/L5BWgFcQANCQVwBWvx8FSABHhYDQhUeHhX999EVHh4V0RUgAhwX0RUeHhXRFSACHLrOAdBoOUgBSnJISEJcQAIIQVxcQf34QVoC2CAV/fgVIAEeFgIIFh4B/isgKh4eKiDRHiogICoeGWnRLCwfDxYWDx4uAAAAAwAA/58CsAMdABAAGgAiAEtASBgBAwQBTAcBAAAFAgAFaQkGAgIABAMCBGkIAQMBAQNZCAEDAwFfAAEDAU8bGxIRAQAbIhsiHx4WFREaEhoNDAkGABABEAoGFisBMhYVERQGIyEiJjURMzU0NhMyNjQmIgYHFBYTNTQuAQYHFQGZc6RiRf6xRmJwpDsXIB4yHAIg9mCMYgEDHaRy/kFFZGRFAYY5c6L9YyAwICAXGCIBUDlFYAJkQzkAAAAEAAD/nwKwAx0AEAAYACIAKwBMQEkJAQAABAIABGkDAQIABggCBmcACAAHBQgHaQoBBQEBBVcKAQUFAV8AAQUBTxoZAQAqKSYlHh0ZIhohFxYTEg0MCQYAEAEQCwYWKwEyFhURFAYjISImJxEzNTQ2AxUhNTQuAQYBMjY1ESERFBYzNxQGIiY0NjIWAZlzpGJF/rBGYAFwpDUBT2CMYgEXFyD+QiAX4CAvICAuIgMdpHL+QUVkZEUBhjlzov7rOTlFYAJk/cYgGAEX/ukYIKgXIiAwICAAAAAFAAD/agLvA1IAFQAlADUAPQBIAFNAUCUBDAUBTAABAAkHAQlpAAcACwAHC2kKCAYCBAAABQwABWcADAANBAwNaQAEAwMEVwAEBANfAAMEA09GRUFAOzo3NjMyExMTJjQ1ExMTDgYfKz0BNDY3NTQ2MhYdATIWBxUUBisBIiY3FBYXMzI2NzU0JichIgYXNzM1NDYyFh0BMzU0JiIGFRczNTQmDgEVEzQ2HgIHBiInJjYopOqkJzgBpHW8daQ/gFq8WoABEg79zg4SAV0/XIBcP4Kygl76SGpIPyQ0JAEWDjYOFYPbJzYBfXWkpHV9OCbbdaSkdVqAAYJZ2w4QARINXn1AXFxAfX1agIBafX00SgJGNv6JGSYCIjc4KSk4AAAD//b/agP1A1IAGwAlADUAOEA1EwQCBAUjIAIDBAJMAAAABQQABWkABAADAgQDaQACAQECVwACAgFfAAECAU8XGRQSOxsGBhwrFyY3NjcmJy4BNjc2IBceAQYHBgcWFxYGIyEiJjchJi8BBiInBwYTBhYfARYyPwE+AScuASIGBA4nd6xUIwoCMCpUARZTKzAECSNUrHcnGjD8lRUiNwNrbZ5PLVwuTqBVDTpDCjiGOAlDOg0OfNR8aSsbTiZpljeGpDhpaTmiiDaWaSZOG1gaJEkjEB4eECMCEWfSUQ5BQQ5S0GhxoKAADP///4kD6AMzABEAIwAsADUAPgBHAFcAWwBkAG0AdgB8AJ5AmyMBDQQBTHwBBAFLAAAABA0ABGcADRUQDVcAFRYBEBcVEGcAFwADExcDZwATABQPExRnAA8RDg9XABESAQ4LEQ5nAAsADAkLDGcACQAKBwkKZwAHAAgFBwhnAAUABgIFBmcAAgEBAlcAAgIBXwABAgFPe3l2c3JvbWppZmRhYF1bWllYVlROTEdEQ0A+Ozo3MTIxNCMjNDczGAYfKxURNDY3ITIfARYVERQGByEiJjcUFjchMjYnESMiJj0BISIGFxM0MyEyFCchIjU0MyEyFCMhIjU0MyEyFAchIjU0MyEyFCchIj0BNDYXMzIWFxUUBicjIiY3MzUjBTQzITIUJyEiNTQ7ATIUKwEiNTQ7ATIUByMiJRQWNzMnNigCkBkUuxI2KPzUJzhAEA8DLA4SAXwoNv2PDhIBPhACzhAQ/TIQEALOEBD9MhAQAs4QEP0yEBACzhAQ/TIQEg3bDhABEg3bDRI/nJwBGQ8BdxAQ/okPD50PD50PD50PD50PARkmGH27GQLuJzYBErsUGf2uJzYBOCYOEgEQDwIzNid9Eg39YBAgAW0QIG4PHgFtECABfbsOEgEQD7sOEgEQLn2sECABbRAgbg8eAR8ZJgG7AAAEAAD/5wP/AtUAEAAhACoAMwA7QDgrAQYEAUwABAMGAwQGgAAAAAMEAANnAAYABQIGBWoAAgEBAlcAAgIBXwABAgFPFBMVNjQ2MwcGHSs1ETQ2MyEyHwEWDwEGIyEiJjcUFjchMj8BNi8BJiMhIgYXBTQ+AR4BBi4BNxQWPgEuAgZINQJSRCWcKyucJUT9rjVIPyQaAlIjEZ0VFZ0RI/2uGSYBAjI2UDQCOEw6ISYyJgIiNiJkAfQzSjv6QkL6O0g1GSYBHfohIfodJBr6JzYCOko6AjYnGSYCIjYiBCoAAAQAAP9qA1kDUgATABoAIwBTANNACxQBAgRSOwIHCwJMS7ASUFhARg8BDAMLAwxyEA4NAwsHAwsHfhMRCggEBwYDBwZ+CQEGBQUGcAABAAQCAQRnAAIAAwwCA2cSAQUAAAVXEgEFBQBgAAAFAFAbQEgPAQwDCwMMC4AQDg0DCwcDCwd+ExEKCAQHBgMHBn4JAQYFAwYFfgABAAQCAQRnAAIAAwwCA2cSAQUAAAVXEgEFBQBgAAAFAFBZQCokJBsbJFMkU1FQT05NTEFAPz49PDo5ODc2NSgnJiUbIxsjEyYUNTYUBhsrAR4BFREUBgchIiYnETQ2NyEyFhcHFTMmLwEmExEjIiYnNSERNxUzNSM3PgIHMxQfAR4BHwEjFTM1Iyc3MzUjFTMHDgEPASM0JyYvATM1IxUzFwcDMxAWHhf9EhceASAWAfQWNg9K0gUHrwbG6BceAf5TqJ0qOgMEBgEBAwIBBAI8K6Mma2wmnCk5AggBAQEDAwY7KqImam0CfhA0GP1+Fx4BIBYDfBceARYQJtIRBq8H/LACPCAV6fymgzs7WgQKBgECBAQCBANaOzuYnjs7WQQKAwECAwYHWTs7mJ4ABQAA/zoDqgOBACgAMQBCAEsAVACEQIEbCgIEAR8BCgYAAQ0KA0wABAEGAQQGgAAGCgEGCn4ACQ0HDQkHgAACAwEBBAIBaQ8BCgANCQoNaQAHAAgMBwhnEAEMAAsFDAtpDgEFAAAFWQ4BBQUAYQAABQBRTUxEQyopUVBMVE1USEdDS0RLQD86NzQyLi0pMSoxGCMzKBQRBhsrARYVFAAEADU0Ejc1JzUjIiY+ATczMh4BBicjFQcVFhc/ATYyFgYPAQYBMjYQJgQGEBYTMzIWFAYnIyImPQE0NjIWBycyFhIGIiYSNhMyNi4BDgIWA1dT/uz+fv7s8LICMxUgAhwX0BUeAiITNAGccgYbDyogAg4aBf50l9bW/tLW1stoFSAgFZwVICAqIAE0gbYCuv68BLSDa5oCltqWApoCGXWUwv7uAgEWwLQBChMBAzMgKh4BICgiATMBAxFsCRoPHiwPGgX9hdYBLtYC0v7O0gGeHiogAR4WnBYeHhaduP7+uLgBArj9wprWmgKW2pYAAgAA/50DjwMhAAgAFABJQEYEAQIDBQMCBYAJBwIFBgMFBn4IAQAAAwIAA2cABgEBBlcABgYBYQABBgFRCQkBAAkUCRQTEhEQDw4NDAsKBQQACAEICgYWKwEyABAABAASAAE1IzUjFSMVMxUzNQHRuAEG/vr+kP74AgEEAZmncKiocAMd/vr+jv78BAEMAWoBDv4GcKencKioAAAACQAA/58DjwMdABMAFwAbAB8AIwAmACoANgBCAIxAiTEBABEBTCQBBwFLBAICABESEQASgBMBERQBEgMREmkFAQMPDAIICQMIZxkQGA0WBQkOCgIGBwkGZxcLFQMHAQEHVxcLFQMHBwFfAAEHAU8nJyAgHBwYGBQUQUA7OjU0Ly4nKicqKSgmJSAjICMiIRwfHB8eHRgbGBsaGRQXFBcUExMTEREQGgYdKwEzESERMxUUFjI2NzUzFRQWMjY3ATUjFTc1IxUFNSMVNzUjFRc3Izc1IxUBNTQ2MhYHFRQGIiYlNTQ2MhYHFRQGIiYC6Kf8g6hCXEABcEJcQAH+QnBwcAFPcHBw33BwcHD+eSIuIgIgLyABTiAvIgEgLiICrfzyAw44LkJCLjg4LkJCLv2bb2/fcHDfb2/fcHDfb3BwcAGHcBcgIBdwGCAgGHAXICAXcBggIAAAAAAJAAD/nwOPAx0ABwALAA8AEwAXABsAHgAqADYAhUCCJQEBDwFMHAELAUsDAQEPEA8BEIARAQ8SARAEDxBpCAYCBBUJFAcTBQUKBAVnDgwCChcNFgMLAgoLZwACAAACVwACAgBfAAACAE8YGBQUEBAMDAgINTQvLikoIyIeHRgbGBsaGRQXFBcWFRATEBMSEQwPDA8ODQgLCAsSEREREBgGGysFIREzESERMwE1MxUzNTMVMzUzFQU1MxUzNTMVMzUzATU0NjIWBxUUBiImJTU0NjIWBxUUBiImA4/8g3ACnXD9K3BvcG9w/dJwb3BvcP4JIi4iAiAvIAFOIC8iASAuImEDDv1jAp3+sm9vb29vb+BwcHBwcAGHcBcgIBdwGCAgGHAXICAXcBggIAAPAAD/agOhA1IAAwAHAAsADwATABcAGwAfACMAMwA3ADsAPwBPAHMAnkCbQSUCHRJJLSQDEx0CTCABHhoBEh0eEmkhHwIdEwkdVxsBExkXDQMJCBMJaBgWDAMIFREHAwUECAVnFBAGAwQPCwMDAQAEAWcOCgIDABwcAFcOCgIDAAAcXwAcABxPcnBtamdmY2BdW1ZTTUxFRD8+PTw7Ojk4NzY1NDEvKScjIiEgHx4dHBsaGRgXFhUUExIRERERERERERAiBh8rFzM1IxczNSMnMzUjFzM1IyczNSMBMzUjJzM1IwEzNSMnMzUjAzU0JicjIgYHFRQWNzMyNgEzNSMnMzUjFzM1Izc1NCYnIyIGFxUUFjczMjY3ERQGIyEiJjURNDY7ATU0NjsBMhYdATM1NDY7ATIWBxUzMhZHoaHFsrLFoaHFsrLFoaEBm7Oz1rKyAayhodazs8QMBiQHCgEMBiQHCgGboaHWs7PWoaESCggjBwwBCggjCArXLBz87h0qKh1INCUkJTTWNiQjJTYBRx0qT6GhoSSysrIkof3Eofqh/cShJLIBMKEHCgEMBqEHDAEK/iayJKGhoWuhBwoBDAahBwwBCiz9NR0qKh0Cyx0qNiU0NCU2NiU0NCU2KgAEAAD/agOhA1IAAwATACMARwCHQAwVBQIHAh0NAgMHAkxLsApQWEAsCwkCBwIDAwdyCgEIBAECBwgCaQUBAwABAAMBaAAABgYAVwAAAAZfAAYABk8bQC0LCQIHAgMCBwOACgEIBAECBwgCaQUBAwABAAMBaAAABgYAVwAAAAZfAAYABk9ZQBJGREE+OzozJTYmJiYkERAMBh8rFyERITc1NCYrASIGHQEUFjsBMjYlNTQmKwEiBh0BFBY7ATI2NxEUBiMhIiY1ETQ2OwE1NDY7ATIWHQEzNTQ2OwEyFgcVMzIWRwMS/O7XCggkCAoKCCQICgGsCggjCAoKCCMICtcsHPzuHSoqHUg0JSQlNNY2JCMlNgFHHSpPAjxroQgKCgihCAoKCKEICgoIoQgKCiz9NR0qKh0Cyx0qNiU0NCU2NiU0NCU2KgAAFAAA/5oDCAMoAC4AMgA2ADoAPgBGAEoATgBSAFYAXgBiAGYAagBuAHYAegB+AIIAhgFUtx8QDQMAEQFMS7ALUFhAaAYEAgMAERAQAHIFAwIBJRsCEQABEWkkGgIQLSMZAw8OEA9oLCIYAw4rIRcDDQwODWcqIBYDDCkfFQMLCgwLZygeFAMKMicxHTATLwcJCAoJZyYcEgMIBwcIVyYcEgMICAdfLgEHCAdPG0BpBgQCAwAREBEAEIAFAwIBJRsCEQABEWkkGgIQLSMZAw8OEA9oLCIYAw4rIRcDDQwODWcqIBYDDCkfFQMLCgwLZygeFAMKMicxHTATLwcJCAoJZyYcEgMIBwcIVyYcEgMICAdfLgEHCAdPWUBsd3dfX0dHLy8AAIaFhIOCgYB/fn18e3d6d3p5eHV0cXBubWxramloZ2ZlZGNfYl9iYWBdXFlYVlVUU1JRUE9OTUxLR0pHSklIRURBQD49PDs6OTg3NjU0My8yLzIxMAAuAC4VGBcWFRYRMwYdKxURMzQ/AT4CMh4CBxUzNTc2FjYXMh4DFBcVMzU3NhY2FjYXMh4CHQEzESUVMzUnMzUjNTM1IzUzNSM3FDI9ATQiFRMVMzUnMzUjNTM1IzUzNSM3FDI9ATQiFRMVMzUnMzUjNTM1IzUzNSM3FDI9ATQiFRMVMzUnMzUjNTM1IzUzNSNcAQQDECIuJAwKATcEBBAgGBIaEgoIATYCAgQMEhgTGCIOCFz9OYuLi4uLi4uLR0pKWZiYmJiYmJiYfktLL5iYmJiYmJiYqEtLBYyMjIyMjIyMZgMHHQogFhAQEBAsCicnICAEJAoICBoMJAccHBkZAigGFgcQECwKJ/z5sXBwFncWghVwWyEhgiEh/XlwcBZ3FoIVcFshIYIhIf15cHAWdxaCFXBbISGCISH9eXBwFncWghVwAAAL////aQPpA1IAJwBPAFMAVwBbAF8AYwBnAGsAbwBzAMZAw08BCgkvAQgRAkwGBAIDAA8NCwMJCgAJZwUDAgEODAIKFAEKaSAaAhQqIScbJAUVEhQVZx4YAhIpHyYZIwUTEBITZxwWAhAoHSUXIgURCBARZwAIBwcIVwAICAdfAAcIB09wcGxsaGhkZGBgXFxYWFRUUFBwc3BzcnFsb2xvbm1oa2hramlkZ2RnZmVgY2BjYmFcX1xfXl1YW1hbWllUV1RXVlVQU1BTUlFNS0hHRENAPzw7ODc0MjQ1IxMTExMTIysGHysVETQ2FzM1NDYyFh0BMzU0NjIWHQEzNTQ2MhYdATMyFgcRFAYnISImNxQWMyEyNicRNCYrARUUBiImPQEjFRQGIiY9ASMVFAYiJj0BIyIGFxM1MxUnNTMVJzUzFRM1MxUnNTMVJzUzFRM1MxUnNTMVJzUzFTAkhxIaErwSGhK8EhoShyMyATAk/MAjMkAKCwNACgwBCguHEhoSvBIaErwSGhKHCgwBnH19fX19Xn19fX19XX19fX19QgLiIzIBPw0SEg0/Pw0SEg0/Pw0SEg0/MCT9HiMyATAkCgwMCgLiCgw/DRISDT8/DRISDT8/DRISDT8MCv2lXl6cXl6cXl7+yF5enF5enF5e/sheXpxeXpxeXgAAA//8/5ADmgMsAAgAEwApAGJAXwwBAwIjIhgXBAUHAkwABwYFBgcFgAAFBAYFBH4IAQAJAQIDAAJpAAMABgcDBmkKAQQBAQRZCgEEBAFhAAEEAVEVFAoJAQAmJCAeGxkUKRUpEA4JEwoTBQQACAEICwYWKwE2ABIABAACABciBhUGFjMyNjU0AzI2NycGIyI/ATYjIgYHFzYzMg8BBgHGvgEQBv72/oT+7gYBDPIqLgIiICYutB5sNBIwGA4KKhowHnY4EDQWDAwkGgMqAv74/oT+7gYBCgF8ARKWMBocICwgOv2uNDQYJCagYDouGiIimGgAAAP//f+xA18DCwAPADcARABIQEUpAQUDCQECAQACTAAEAgMCBAOAAAMFAgMFfgAHAAIEBwJpAAUAAAEFAGcAAQYGAVcAAQEGYQAGAQZRFR4rExYmJiMIBh4rJTU0JisBIgYdARQWOwEyNhM0LgEjIgcGHwEWMzI3PgEyFhUUBgcOARcVFBY7ATI2NDY/AT4DFxQOASIuAj4BMh4BAfQKCGsICgoIawgKjz5cMYhHCQ1KBAYJBR4lOCoWGyM8AQoIawgKGBIcCh4UDNdyxujIbgZ6vPS6flJrCAoKCGsICgoBfzFULncNCzcEByYbHhIVGgwPQiUUCAoKEiILEAYaHChSdcR0dMTqxHR0xAAD//z/kAOaAywACAAWAD8AWEBVODYCAwUTAQIDAkwABgQFBAYFgAAFAwQFA34AAwIEAwJ+BwEAAAQGAARpCAECAQECWQgBAgIBYQABAgFRCgkBACcmIiAdGxEOCRYKFgUEAAgBCAkGFisBNgASAAQAAgATMjY1NiYrASIGBxQWFxM2NTQmIyIHBgcVMzU0NzYyFxYVFAcGDwEGDwEGBwYHFTM1NDc2PwE2Aca+ARAG/vb+hP7uBgEMvB4mAiYeAhwmAiYcqBpqUkAoRARuEBBODBAQCAwWCgoVCwYOBGwEBhYcLgMqAv74/oT+7gYBCgF8ARL9HiYcHiYkHB4mAgFIIixOTBoqaAQEGhwYFBQYEhYMCA8HCBEJCBQ6CAQMEBQQEiIAA////4kDqgMzABEANAA9ADxAOSUXEwMDAgFMAAAEAIUABAIEhQACAwKFAAMABgUDBmoABQEBBVkABQUBYQABBQFRExMuHSYXJAcGHSsRND4CFzIeAg4ELgIBFzYzMhUUDwEGIgYnBw4BHQEzNTQ/ATI+Ajc+ATc0JiMiAxQWMjYuAgZKfqxhX658TAJIgKrBrnxMAU4fLi4yAgYEBg4CKBYMdQMGARQOGAYTFAFUQFUPKkMqAiZGKAFeX658TAFKfqzArIBIAUp+rgEOZR0WBQMIBQwCFQwaGCYaAwMGCAoKCRAoJDFE/o0gIiJAIgEkAAAAAAT///+JA6oDMwARACEAQwBMAJC3MyYjAwUEAUxLsApQWEA2AAYDBAMGBIAABAUDBAV+AAcIAgIHcgAAAAMGAANpAAUACAcFCGoAAgEBAlkAAgIBYgABAgFSG0A3AAYDBAMGBIAABAUDBAV+AAcIAggHAoAAAAADBgADaQAFAAgHBQhqAAIBAQJZAAICAWIAAQIBUllADBMTLxwVFxgXJAkGHysRND4CFzIeAg4DIi4CNxQeAj4DNzQuASIOATcXNjIVFAYPAQYPAQ4BHQEzNTQ2Nz4BPwE2Nz4BNzQmIyIDFBYyNi4CBkp+rGFfrnxMAUp+rMCufEx2OF6CkIBgNgFeor6kXNcfLWEEAQYFAjgWDHUGAwEUBxMMBhMUAVRAUxEqQyoCJkYoAV5frnxMAUp+rL+ufkpKfq5fR4RcOgI2YIBJX6JeXqJRZR0XBAgBBQQBHQwaGCUaAwYCAQgECwcGESgjMUT+jSAiIkAiASQAAgAA/7oDSAMCAAgAFAAoQCUUExIREA8ODQwLCgsBAAFMAgEAAQCFAAEBdgEABQQACAEIAwYWKwEyFhAGICYQNgE3JwcnBxcHFzcXNwGkrvb2/qT29gEEmlaamFiamliYmlYDAvb+pPb2AVz2/lyaVpiYVpqYVpiYVgAAAAIAAP+dA48DIQAIABQAKEAlFBMSERAPDg0MCwoLAQABTAIBAAEAhQABAXYBAAUEAAgBCAMGFisBMgAQAAQAEgABJzcnBycHFwcXNxcB0bgBBv76/pD++AIBBAGWjY1Pjo1PjY1PjY4DHf76/o7+/AQBDAFqAQ79sI6NT42NT42OT42NAAIAAP/JAysC8wAUACAAKEAlIB8eHRwbGhkYFxYLAQABTAIBAAEAhQABAXYBAAsKABQBFAMGFisBMhcWFxYUBwYHBiInJicmNDc2NzYTNycHJwcXBxc3FzcBlnBeWzU3NzVbXt9eXDY3NzZcXsN9VXx+VH9/VH58VQLzNzVcXt1fXDU3NzZbX91eXDU3/mx9VH1+VX19VX99UwAAAAIAAP9pA+oDUwAIABQAIUAeFBMSERAPDg0MCwoLAQABTAAAAQCFAAEBdhMSAgYYKxE0AAQAAgAEADcXNxc3JzcnBycHFwEmAZwBKAT+4P5c/uLXfZycfZycfZycfZwBXs8BJgL+3v5e/t4CASYzfZycfZycfZycfZwAAAACAAD/aQPoA1EADAAYACFAHhgXFhUUExIREA8OCwABAUwAAQABhQAAAHYVEwIGGCsBFA4BIC4BED4BIB4BATcnNycHJwcXBxc3A+iG5v7w5oaG5gEQ5ob+rUehoUehoUehoUehAV2I5oaG5gEQ5oaG5v6QR6GhR6GhR6GhR6EAAAIAAP+fAx8DHQAbAB8AUUBODAEKCQqFBQEDAgOGDQsCCQ4IAgABCQBnEA8HAwECAgFXEA8HAwEBAl8GBAICAQJPHBwcHxwfHh0bGhkYFxYVFBMSEREREREREREQEQYfKwEjBzMVIwcjNyMHIzcjNTM3IzUzNzMHMzczBzMBNyMHAx+ZHLXDHHAc3xxvG4uaG7XEG3Ac3xxwHIv+2xzfHAHO33Dg4ODgcN9w39/f3/6x398AAAMAAAAAA5gBzAAIABEAGgA6QDcIBAcCBgUAAQEAWQgEBwIGBQAAAWEFAwIBAAFRExIKCQEAFxYSGhMaDg0JEQoRBQQACAEICQYWKxMyFhQGIiY0NiEyFhQGIiY0NiEyFhQGIiY0Nm4uQEBcQEABjC5AQlhCQAGMLkBAXEBAAcxAWkJCWkBAWkJCWkBAWkJCWkAAAAAJAAD/bwPeA00ABAAJAA4AEwAYAB0AIgAnACwASkBHEAoCBAUEhRELAgUCBYUOCAICAwKFDwkCAwADhQwGAgABAIUNBwIBAXYsKyopJyYlJCIhIB8dHBsaGBcSERIREhESERESBh8rFTQgECARNCAQIBE0IBAgATQgECARNCAQIBE0IBAgATQgECARNCAQIBE0IBAgAQT+/AEE/vwBBP78AW0BBP78AQT+/AEE/vwBbAEF/vsBBf77AQX++w+C/vwB74L+/AHvgv78/aiC/vwB74L+/AHvgv78/aiC/vwB74L+/AHvgv78AAAAABIAAP9VBBIDaAAPABMAIwAnADcAOwBLAE8AXwBjAHMAdwCHAIsAmwCfAK8AswD9QPo0IC4UKAUIIhYCCgsICmc1Iy8XKQULIRUCCQQLCWcyHCwQJgUEHhICBgcEBmczHy0TJwUHHRECBQAHBWcwGCoMJAUAGg4CAgMAAmcxGysPJQUDAQEDVzEbKw8lBQMDAV8ZDQIBAwFPsLChoJycjYyIiHl4dHRlZGBgUVBMTD08ODgpKCQkFRQQEAEAsLOws7Kxqaagr6GunJ+cn56dlZKMm42aiIuIi4qJgX54h3mGdHd0d3Z1bWpkc2VyYGNgY2JhWVZQX1FeTE9MT05NRUI8Sz1KODs4Ozo5MS4oNyk2JCckJyYlHRoUIxUiEBMQExIRCQYADwEONgYWKzcyFh0BFAYHIyImJzU0NjMXNSMVEzIWHQEUBgcjIiY9ATQ2Mxc1IxUTMhYdARQGByMiJj0BNDYzFzUjFQEyFh0BFAYHIyImJzU0NjMXNSMVEzIWHQEUBgcjIiY9ATQ2Mxc1IxUTMhYXFRQGByMiJj0BNDYzFzUjFQEyFgcVFAYHIyImNzU0NjMXNSMVEzIWBxUUBgcjIiY3NTQ2Mxc1IxUTMhYHFRQGByMiJjc1NDYzFzUjFdEsPD4qaSs8ATwsaWlpLDw8LGksPDwsaWlpKj48LGksPD4qaWkB1Ss+QCloKzwBPCxoaGgrPj4raCw8PCxoaGgqPgE+K2gsPD4qaGgB1So+ATwraCw+ATwtaGhoKj4BPCtoLD4BPC1oaGgqPgE8K2gsPgE8LWhojj4qaCw8AT4raCo+0GhoAj0+KmkrPAE+KmkqPtFpaQI+PitoKzwBPipoKz7RaGj99z4qaCw8AT4raCo+0GhoAj0+KmkrPAE+KmkqPtFpaQI+PitoKzwBPipoKz7RaGj99z4qaCw8AT4raCo+0GhoAj0+KmkrPAE+KmkqPtFpaQI+PitoKzwBPipoKz7RaGgAAAIAAAAAA0MCfQALABcAMUAuBAEAAAECAAFnBQECAwMCVwUBAgIDXwADAgNPDQwBABMQDBcNFgcEAAsBCgYGFisBMh4BBiMhIiY0NjMBMh4BBgchIiY0NjcC2Sw8AkAq/Y8sPDwsAnEsPAE+K/2PLDw+KgJ9PlQ+PFg8/pQ+VjwBPFg8AQAAAAACAAD/nwFhAx0ABgANADdANAoBA0oDAQBJBAEDBQOFBwEFAgWFBgECAAKFAQEAAHYHBwAABw0HDQwLCQgABgAGEhEIBhgrNxUzByczPQIjNxcjFfFwp6hwcKincO+nqamn36inp6gAAAEAAP9qAfwDUgAJAB1AGgQBAUoJAQBJAgEBAAGFAwEAAHYREhEQBAYaKzUzESM3FyMRMweqqv7+qqr+aAHs/v7+FP4AAQAAAAAD6AKiAAYABrMFAQEyKxE3CQEXASeUAWABYJT+DJQCDpT+oQFflP4MlAAABgAA/2oChwNSAAgAEQAaACMALAA1AEpARy0BBQQkAQMCGwEBAANMCgEECwEFAgQFaQgBAgkBAwACA2kGAQABAQBZBgEAAAFhBwEBAAFRNDMwLysqFBMUExQTFBMSDAYfKxU0NjIWFAYiJhE0NjIWFAYiJhE0NjIWFAYiJgE0NjIeAQYiJhM0NjIeAQYiJhM0NjIeAQYiJkhmSkpmSEhmSkpmSEhmSkpmSAGNSmZGBE5eUgRKZkYETl5SBEpmRgROXlIaNEhIaEhIAawzSkpmSkoBqzRISGhISP1ENEhIaEhIAawzSkpmSkoBqzRISGhISAAAAAEAAP9qAogDUgAHAAazBgIBMisRNwEXCQEHAZQBYJT+oQFflP6gAV6VAV+U/qD+oJQBYAABAAD/agKIA1IABgAGswYDATIrFQkBNwEXAQFg/qCUAWCU/gwCAWABYJT+oZX+DAADAAAAAAPoAokAFwAgACkAOkA3DAACBQQBTAAEAwUDBAWAAAUCAwUCfgAAAAMEAANpAAIBAQJZAAICAWEAAQIBURMUExcqJQYGHCsRNjc2NzYzFhcWFxYVBgcGBwYjJicmJyYlFBYyNjQuAQYXNDYyFhQOASYGOk9hgYOJe2dJQAY6T2GBg4l7Z0lAAQiKxIqKxIpWWHxYWHxYAV4xPVAxPAI6NUxJJTE8UDE9Ajs1TEglXoKCvIIChls8VFR4VAJYAAAABAAA/7QD6AMCACEALgBFAEsAPEA5NwEBAEc+NiUkAAYCAR0BAwIDTAsBAEoAAAABAgABaQACAwMCWQACAgNhAAMCA1FFQzIwLSs1BAYXKxE2NzY3NjMyFzc2NzIfARYPBwYvASY/AScmJyYlFBc3JjU0Nj8BIyIGEzczMjY1NCc3HgEzFhcWFQYHBgcGIyI/ARYVFAYGOk9hgYMdHkoKDQQEMxEPOS8pkCkvOQ8QNQ8PMQhnSUABCC8wCUQzMRJiirEpEmKKLz8CBAJnSUAGOk9hgYMZOG4JRAFGMT1QMD0CgRACAiAHGmVPSPpIUGQZCh8IGVYENUxIJUo7VBgZM1AKVIT+fEeCXko7bQICNExJJTE8UDE9n70ZGDNOAAAAEQAA/4cDygNTAAgADwAWABwAIgAoAC4ANAA6AEAARgBMAFIAWABeAGUAbACNQIprXVtRTzIbGRUTCggASi0CBwhDJQIJBGFXVT47NyEfDQsKAQkETAAACACFAAEJAYYPAQgOAQcDCAdpEQ0GAwMQDBMFEgUCBAMCZwsBBAkJBFkLAQQECWEKAQkECVEjIwkJaWhkY05NTEtIR0ZFQkFAPzo5MTAsKyopIygjKCcmERAJDwkPExIUBhgrETQAJAACACQANxYXNjcmLwEzNjcmJwY3Fhc2NwYDFhcmJwYTFhc2NzUnMzUmJwY3Fhc1IwYDFhczNQYXMzY3Jic1Fhc2NyM1MyYnBgc1NjcmJyMTNjcmJwYDFhc2NyYDFhc2NyMGAxYXMyYnBgEcAZABHgL+5v5s/ug9B3Y0OSsEu7sEIT43ZnszOStKg0pYdUApNRcEKUVKvLxOSx8rRUgCWiUxTgJFZAJOMT1ESkUpBLy8BCBKTkhFMVoCNXVYLzUpQEorOTJdDDk0dQi7BCEhBLsGZTcBbskBGgL+4v5y/uAEARi7pnUlF2p1H2hcGStxiCcXZUsW/TVME0BUEwEPb2YWBLsfnQMaWHUXBNpM/adkQrsEt0JkEQQgBBZmbx9iWBoDHwQXc0z8uxNMIhNUAwBLZRcnXP2HFyV1pnUBWFxol3ErAAAAAgAA/2oC8gNTAAoAEwAiQB8IAQFJAAECAYYAAAICAFkAAAACYQACAAJRExoSAwYZKxE0NgQWFRQHCQEmNxQWMjY0JiIG3AE63DX+vP68NdtchFxchFwB2ZzeAtqee0b+UgGuRntCXFyEXFwAAgAA/9cDjwLlABYALQDithgBAgAFAUxLsAtQWEA3AAcIBQgHcgsJAgUACAUAfgoEAgACCAACfgACAwMCcAAGAAgHBghnAAMBAQNXAAMDAWAAAQMBUBtLsAxQWEA4AAcIBQgHcgsJAgUACAUAfgoEAgACCAACfgACAwgCA34ABgAIBwYIZwADAQEDVwADAwFgAAEDAVAbQDkABwgFCAcFgAsJAgUACAUAfgoEAgACCAACfgACAwgCA34ABgAIBwYIZwADAQEDVwADAwFgAAEDAVBZWUAbFxcAABctFy0qJyQjIB0aGQAWABYzEzMSDAYaKyU3FyMVFAYjISImPQEzFRQWNyEyNic1AQcnMzU0NjchMhYHFSM1NCYjISIGBxUCP6iocGBH/rJGYm8iFwFOFyIB/rKnqXBiRgFORmIBbyAY/rIYIAG33985RWJiRTk5FiIBHhk5AU/g4DdFYgFkRDc3GCAgGDcAAgAA/7EDWwMLACQARwBdQFpDJQIGCS8BBQYXAQMCCAEBAwRMAAkIBggJBoAHAQUGAgYFAoAEAQIDBgIDfgABAwADAQCAAAgABgUIBmkAAwEAA1kAAwMAYQAAAwBRRkUmJSU2JSY1FCQKBh8rARQVDgEjIiYnBwYiJj0BNDY7ATIWBg8BHgE3MjY3Njc2OwEyFhMVFAYrASImNj8BJiMiBgcGBwYrASImNzU+ATMyFhc3NjIWA0sk5JlRmDxICxwWFg76DhYCCU0oZDdKgicGGAQMawgKDhQQ+g4WAglNUnBLgicGFwUMbwcMASTmmVGaPEgLHBgBBQMBlro+OUgLFg76DhYWHAtNJCoBSj4KOA0MAbj6DhYWHAtNTUo+CjgNDAYElro+OUgLFgAAAgAA/2kD6ANSAA4AHQBRQE4YFAIFBg4DAgEAAAEDAQNMFQEESggHAgUGAAYFAIACAQABBgABfgAEAAYFBAZpAAEDAwFZAAEBA2EAAwEDUQ8PDx0PHSITJCISIhEJBh0rFREhBxYzMjY3MwYEJyInAzYkMzIXNxEhNyYjIgYHAZKgbJZ9wiGKI/7ss8+SiSMBFLPPk5L+bqBsln3CIZYBkqBrlnWt5gGSAcSu5JKS/m6ga5Z1AAAAAAMAAP/5A+gCfQARACIAMwBGQEMLAgIEAg0BAAMCTAAEAgMCBAOAAAMAAgMAfgAAAQIAAX4ABgACBAYCaQABBQUBWQABAQVhAAUBBVEXFiQUFRgWBwYdKwEmJxYVFAYuATU0NwYHHgEgNgE0JgciBhUUFjI2NTQ2MzI2BRQHBgQgJCcmNDc2LAEEFxYDoVWAIpLQkiKAVUvgAQTi/rcQC0ZkEBYQRDALEAHZC07++P7a/vhOCwtOAQgBJgEITgsBOoRBOkNnlAKQaUM6QYRyiIgBSQsQAWRFCxAQCzBEEMwTE4GamoETJhSAmgKefhQAAAEAAP/IAe8C+gANABdAFAcBAQABTAAAAQCFAAEBdhgSAgYYKxEBNjIWFAcJARYUBiInAYcSMSUS/tABMBIkMhIBYQGHEiQ0Ef7Q/s8RNCMSAAAAAAEAAP/CAe8C9QAOABhAFQoDAgEAAUwAAAEAhQABAXYUFwIGGCsxNDcJASY0PgEXCQEGIiYSATH+zxIkNBEBhv56EzAmGRIBMAEwEjQiAhP+ef55EiQAAAAH////owMOAxkAHQAhACsAOABFAFIAXwB3QHRcVk81LwULCgFMEA4MAwoBCwEKC4ARDw0DCwkBCwl+AAUTAQcABQdnBgQSAwAIAwIBCgABaQAJAgIJVwAJCQJfAAIJAk8eHgEAWllUU01MR0ZAPzo5MzItLConJCMeIR4hIB8aFxQSDw4LCAUEAB0BHRQGFisBMhYOAScRFAYHISImNxEiLgE2NzM1NDYzITIWHQElFSE1ExEhERQWMyEyNgEyFgcRFAYiJicRNDY3MhYVERQGIiY1ETQ2NzIWFREUBiImNxE0NjcyFhcRFAYiJjcRNDYC2RUgAhwXelb++1Z6ARYeAiIUMzwtAWwrPv4rAWw0/is+KgEFKzz+ewoQAQ4WDgEQcgoQEBQQEHIKEBAUEgEQdAoOARASFAIQAnweKiAB/l9WegF8VQGhHiwcATUqPj4qNTU1Nf3DAaH+Xys+PgF9EAn+xwoQEAoBOQoOARAJ/scKEBAKATkKDgEQCf7HChAQCgE5Cg4BEAn+xwoQEAoBOQoOAAoAAP9qA2sDUwAhACsANQBFAEkAUwBjAGcAdwB7AHdAdGg2AgwBSwABAA8AAQ9nDgICAAAHBgAHZwAGCQUCAwoGA2kUEAIKFxMCDQwKDWcWEgIMFRECCwgMC2kACAQECFcACAgEXwAECARPe3p5eHZzbmtnZmVkYl9aV1FPS0pJSEdGREE8OTU0NTMSEzMVIzMjGAYfKxE1PgEXMzU0NhchMhYXFTMyFhcVFAYHERQGIyEiJjURIiY3ITU0JgchIgYXExQWMyEyNjcRIRMRNDY7ATIWFREUBisBIiY3MxEjEyE1NCYHISIGFRMRNDY7ATIWFREUBisBIiY3MxEjExE0NjsBMhYVERQGKwEiJjczESMCNiZeNicBOSc2AV0lOAEmGUg0/gw1SBokPgLtEA/9UQ4SAT4mGQH0GSQB/Y8/EA8+DhISDj4OEiA+Ph8BdxIN/scNEn0SDT8NEhINPw0SHz8/nRAPPg4SEg4+DhIgPj4COUQlNAEfJzgBNigfMiZEGiQB/e01SEg1AhMmGT4OEgEQD/1wGSYmGQIT/gwBlw0SEg3+aQ0SEg0BlwE4Hw4SARAP/RIBlw0SEg3+aQ0SEg0Bl/5pAZcNEhIN/mkNEhINAZcAAAACAAD/agM4A1IABwALAG1LsBFQWEAmAAEAAAFwAAQDBQMEBYAHAQUFhAIBAAMDAFcCAQAAA2AGAQMAA1AbQCUAAQABhQAEAwUDBAWABwEFBYQCAQADAwBXAgEAAANgBgEDAANQWUAUCAgAAAgLCAsKCQAHAAcREREIBhkrETUhNTMVIRUBESERASH2ASH88wLiAnmNTEyN/PECpP1cAAAAAv///2kD6QNTABgANABCQD8HAQUGAgYFAoAECAICAwYCA34AAAAGBQAGaQADAQEDWQADAwFhAAEDAVEaGTEvLCsoJiMhHh0ZNBo0GxMJBhgrASYnJiIHDgEHBhQXHgEXFjI3PgE3NjQnJgMjFRQGIiY9ASMiJjQ2OwE1NDYyFh0BMzIWFAYDVkheWsRaXpAmJCQmkF5axFpekCYkJCavtyg4KLccKCgctyg4KLcdJycCwEgmJCQmkF5axFpekCYkJCaQXlrEWl7+orccKCgctyg4KLccKCgctyc5KAAAAAAC////agMlA1UAFQAqADhANScBBAIKAQABAkwAAgQChQAEAQSFAAEAAYUGAwUDAAB2FxYBACUkFioXKg4NCAcAFQEVBwYWKwUiJicBJjQ2Mh8BETQ2MhYVERQGBwYzIiY1ETQ2NzYWFwEWFAYiLwERFAYBMQoPB/79DhwkDbYZKhgODQW2FBkODQ0aCwEDDhslDrUalgYIAQMOJBsOtQMgFBkZFPxyDhcEBBkUA44OFwQHBgv+/Q0kGw22/N8UGQAEAAD/tgOVAv8AIgBFAGgAbwCpQKYVDgISBzgxAg4IW1QCDwkDTBQBAAEAhQUBAQYBhQQBAgYHBgIHgBYMCwMHEgYHEn4RAQ0SAxINA4AAAxMSAxN+CgEIEw4TCA6AEAEOCRMOCX4ADwkPhhUBBgASDQYSZwATCAkTVwATEwlhAAkTCVFHRiQjAQBva2ppZWNeXFhXU1FMSkZoR2hCQDs5NTQwLiknI0UkRR8dGBYSEQ0LBgQAIgEiFwYWKwEiBh0BIyIGHQEUFjsBFQYeATI+ASc1MzI2PQE0JisBNTQmASIGHQEjIgYdARQWOwEVBh4BMj4BJzUzMjY9ATQmKwE1NCYFIgYdASMiBh0BFBY7ARUGHgEyPgEnNTMyNj0BNCYrATU0JgUzFSMnByMCHREYKhMWFhMqAgoVGRUKAioTFxcTKhn+ohEYKhMXFxMqAgoVGRUKAioTFhYTKhgCNREYKhMWFhMqAgoVGRUKAioTFxcTKhn9f1MjBwYjAv8ZESoWE9ETFioMFw0NFwwqFhPRExYqERn+3RoRKRcT0BMXKgwXDQ0XDCoXE9ATFykSGVQZESoWE9ETFioMFw0NFwwqFhPRExYqERlUfQEBAAAAAAMAAP9pA+oDUwAIABEAHQAyQC8dHBsaGRgXFhUUEwsCAwFMAAAAAwIAA2kAAgEBAlkAAgIBYQABAgFRExQTEgQGGisRNAAEAAIABAA3FBYENhAmBAYTNyc3FzcXBxcHJwcBJgGcASgE/uD+XP7iaeYBQubm/r7mkYmJbYmJbYmJbYmJAV7PASYC/t7+Xv7eAgEmz6LkAugBQOgC5P7ViYltiYltiYltiYkAAAACAAD/vQOEAv8AQwBQADxAOT0GAgIAKBsCAQMCTAQBAAUBAgMAAmkAAwEBA1kAAwMBXwABAwFPRUQBAEtKRFBFUCMgAEMBQgYGFisBIgYPAQYHJyYGDwEGFh8BBhQXBw4BHwEeAT8BFh8BHgE7ATI2PwE2NxcWNj8BNiYvATY0Jzc+AS8BLgEPASYvAS4BIwcyHgEUDgEiLgE0PgEBtQ8XAw4zKkUOGwg/CAUMNgQENgwFCD8IGw5FKzIOAxcPfg8XAw4xLEUOGwg/CAULNwQENwsFCD8HHA5FJzYOAxcPPy1NLS1NWk0tLU0C/xMPRxMjFwUKDW0NHQowJCQkMAodDW0NCgUXIxJIDxMTD0gRJBcFCg1tDhwKMBg8GDAKHQ1tDQoFFyEVRw8T+i1NWk0tLU1aTS0AAAACAAD/5wNrAtcAHgAnADxAOQYBAAADAgADZwACBwEEBQIEaQAFAQEFWQAFBQFfAAEFAU8gHwEAJCMfJyAnFxUSDwoHAB4BHggGFisTIg4BFREUFjMhMjY1ETQmIyEiJjQ2MyEWPgE0LgEHAzIWFAYiJjQ2+iE6IjEiAkgjMDAj/eIRGRkRAh4MFw0NFwwqERkZIhkZAtUiOSL94iIxMSIBoSMwGSMYAgoVGRUKAv5fGCIZGSIYAAAABQAA/+cDawLVABkAJgAzAEAATQBkQGENBgIEAAFMCwIKAwAEAIUMAQQBBIUAAQYBhQ0BBggDBlkOAQgDAwhZDgEICANhCQcFAwMIA1FCQTU0KCcbGgEASEdBTUJNOzo0QDVALi0nMygzISAaJhsmCwoAGQEYDwYWKwEiBgcGHwEHBhQWMj8BFx4BNzI3Nj0BNCYjISIGFREUFjI2NRE0JgMiBhURFBYyNjURNCYHIgYdARQWMjY9ATQmByIGHQEUFjI2PQE0JgFFCREDCg4qvAwZIQ27KgYWCQUICBUMAVoZJiYyJSXqGSUlMiYl6hkmJjIlJekZJiYyJSUC1QwJDxYquw0hGQy8KgYFAwgQCY4MFSUZ/Y8ZJiUaAnEZJf6zJhn+3RkmJhkBIxolpyUZfRkmJhl9GSVTJRopGSYlGikZJgAACAAA/2oD6AMoABkAIgAyAD4ARwBQAFkAYgCiQJ8ABgEDAQYDgAACDxAPAhCAEwEAFAEFAQAFaQQBAQADBwEDZxUBBxYBCQoHCWcAChgNFwMLDAoLaQ4BDBoRGQMPAgwPaRIBEAgIEFkSARAQCF8ACBAIT1taUlFJSEA/NTMkIxsaAQBfXlpiW2JWVVFZUllNTEhQSVBEQz9HQEc7ODM+NT4sKSMyJDEfHhoiGyIXFRIQDAoFAwAZARkbBhYrASIGByMiBhURFBYzIRE0PgE7ATU0JisBLgEHMhYUBiImNDYTIgYVERQWMyEyNjURNCYjBzMyFhQGKwEiJjQ2FzIWFAYiJjQ2MzIWFAYiJjQ2BzIWFAYiJjQ2MzIWFAYiJjQ2AfQoQA2vIjExIgEkIjki+jAjrw1AKBEZGSIZGY4RGRkRAU0RGRkR+qcRGRkRpxEYGBERGRkiGBi4ERkZIhkZlhEZGSIYGLgRGRkiGRkDKC4lMCP9uCIxAXciOSKnIzAlLlMZIhgYIhn+sxkR/jYRGRkRAcoRGVQYIhkZIhimGSIZGSIZGSIZGSIZfRkiGRkiGRkiGRkiGQAFAAD/agP/A1IACgAOAB4ALgA6AJpACTgvCgEEBAIBTEuwGVBYQDQAAgQEAnAABwEAAQcAgAAAAIQABAkBAwYEA2gABgoBBQgGBWcACAEBCFcACAgBXwABCAFPG0AzAAIEAoUABwEAAQcAgAAAAIQABAkBAwYEA2gABgoBBQgGBWcACAEBCFcACAgBXwABCAFPWUAaIR8RDzo5NTIpJh8uIS4ZFg8eER4RFDQLBhkrCQERFBYzITI2NREDIREhByEiJjUxNDYzITIWFTEUBgcjIiY9ATQ2OwEyFh0BFAYlERQGIyEiJjURATMB//4BJBwDfxsld/zvAxGJ/jgOEhIOAcgOEhLy7goMDAruCwwMAdklG/yBHCQB/woDUv6A/dgcJCQcAij94QJNchIODhISDg0TVw0KEgoNDAsSCg2b/dgcJCQcAij+zwAAAAQAAP/NA5UC1QARABoAIwAsADlANgkBAAQAhQgGAgQDBIUHBQIDAgOFAAIBAoUAAQF2AgArKicmIiEeHRkYFRQMCggHABECEQoGFisBISIGFREUHgE/ASEyNjURNCYBFAYiJjQ2MhYXFAYiJjQ2MhYXFAYiJjQ2MhYDQf1mIzEZIgxgAkcjMTH+ExcmFhYmF6cXJhcXJhemFiYXFyYWAtUxIv12EhcBDGAyIgH0IjH+sxMXFyYWFhMTFxcmFhYTExcXJhYWAAAABAAA/+cDlQKrABkAQgBPAFgB6UAWQD0CDAs2HwIODDMiAg0PLCkCCA0ETEuwCVBYQEoACwYMBgtyEgEMDgYMcAANDwgJDXIACAkJCHAQAQAKEQIGCwAGaRMBDgAPDQ4PaQAHAQIHWQAJBQMCAQIJAWoABwcCYQQBAgcCURtLsApQWEBPAAoGCwYKcgALDAYLcBIBDA4GDHAADQ8ICQ1yAAgJCQhwEAEAEQEGCgAGaRMBDgAPDQ4PaQAHAQIHWQAJBQMCAQIJAWoABwcCYQQBAgcCURtLsAtQWEBGAAsGDAYLchIBDA4GDHAADQ8IBw1yAAgHBwhwEAEAChECBgsABmkTAQ4ADw0OD2kJAQcFAwIBAgcBagkBBwcCYgQBAgcCUhtLsBNQWEBKAAsGDAYLchIBDA4GDHAADQ8ICQ1yAAgJCQhwEAEAChECBgsABmkTAQ4ADw0OD2kABwECB1kACQUDAgECCQFqAAcHAmEEAQIHAlEbQEwACwYMBgtyEgEMDgYMDn4ADQ8IDw0IgAAICQkIcBABAAoRAgYLAAZpEwEOAA8NDg9pAAcBAgdZAAkFAwIBAgkBagAHBwJhBAECBwJRWVlZWUAzUVBEQxsaAQBVVFBYUVhKSUNPRE8/Pjs6Ly4rKicmGkIbQhMSEA8NDAoJBwYAGQEYFAYWKxMiBhURFBYzFBYyNjUhFBYyNjUyNjURNCYjBzIWFA8BFhQHFxYUBiIvAQYiJwcGIiY0PwEmNDcnJjQ2Mh8BNjIXNzYFMhYdARQGIiY9ATQ2BSIGFBYyNjQmpyMxMSMYIhkB9BkiGCMxMSM6ERgMJBgYKAwZIgwoKFgoJAwjGAwkGBggDBgiDSAoWCgkDP4FERkZIhkZAYgiMTFEMTECqzEi/gwiMREZGRERGRkRMSIB9CIxjhgjDCQoWCgoDCIZDCgYGCQMGCMMJChYKCANIhkNIBgYJAxCGRGmERkZEaYRGSoxRDExRDEAAAAAAgAA/+cDawLVAAsAFwA8QDkWDQICAwFMBQEDAQIBAwKAAAIChAQBAAEBAFcEAQAAAV8AAQABTwwMAQAMFwwXExAHBAALAQoGBhYrEyIGFBYzITI2NCYjBRcRFBY7ATI2NRE3pxMXFxMCmhMXFxP9j9EWE1QTFtEC1RcmFhYmF6f6/t0TFxcTASP6AAAEAAD/5wNrAtUACwAXACMALwBWQFMtJCIZBAYHAUwIAQAAAwIAA2cJAQIAAQUCAWcKAQUABwYFB2cABgQEBlkABgYEXwAEBgRPGBgODAIALy4qJxgjGCMfHBQRDBcOFwgFAAsCCwsGFisBISIGFBYzITI2NCYHISImNDYzITIWFAYFFxEUFjsBMjY1ETcHERQGKwEiJjURJyEDQf1mEBoaEAKaEBoaPf3BEBYWEAI/EBUV/azRGg9UEBnR7hANNg0QhgGAAtUaIBkaHhs+CxIMDBILafr+3RAaGhABI/rI/rsMEREMAUWfAAAAAAYAAP/sA5UCzQARACcAKwBaAF4AYgCJQIZXPjMDBAMBTBMBAAgAhQwVAgsBAgELAoAOAQ0FBgUNBoAUAQgJAQELCAFnCgECDwEDBAIDZxABBBEBBQ0EBWcSAQYHBwZXEgEGBgdfAAcGB08tLBISAABiYWBfXl1cW1NQQ0E6OCxaLVorKikoEicSJiEfHh0cGxoZGBcWFRQTABEAERYGFisBIiMFDgEVERQWFwUWNjURNCYXFTMVIxUzFSMVMxUjFSEyNjURNCYjBzMVIyUyFh8BFh8BND8BPgEzMh4BDwEXFgYjIiYvATQnJjUxFA8BDgErASIuAT8BJyY2BTMVIxUzFSMBygQE/rMQEhIQAU0THxhrVFRUVFRUASQTFxcTfVNT/fMKEAMdBgQDCCIDDwcKEAUGNzsJExMJEQQlAQMJJQMQBgQKEQQGPjoGEwIdU1NTUwLNQwMXEP38EBcDQwMaEwKKEBpLVFNTVFNTVBcTAfQTF1RTHQsKRgYLCAcSSwYKDhMIcWwQHgoHUwIFCQUHDlMHCg4WCmxsEB5wVFNTAAAAAAIAAP/nA2sC1QAVACsARkBDJh0QBwQCAQFMBgECAQKGCQQIAwABAQBXCQQIAwAAAWEHBQMDAQABURgWAgAoJyMgHBsWKxgrEhENCgYFABUCFQoGFisBISIGFBYzExEUFjsBMjY1ERMyNjQmIyEiBhQWMxMRFBY7ATI2NRETMjY0JgNB/WYTFxcT0BcTphMX0BMXFxP9ZhMXFxPQFxOmExfQExcXAtUXJhb+sv7dExcXEwEjAU4WJhcXJhb+sv7dExcXEwEjAU4WJhcAAAIAAP+9A5UC/wAUACgANkAzIQEDAgFMAAMCAQIDAYAAAQGEBAEAAgIAWQQBAAACYQACAAJRAQAoJx4bCwoAFAEUBQYWKwEiBwYHBhQXFhcWMjc2NzY0JyYnJgMnJj0BNDYzMTIWHQEXFhQHMQYiAfRxYV44OTk4XmHiYV44OTk4XmEFiQ0XExMXfQwMDSEC/zk4XmHiYV44OTk4XmHiYV44Of24ig0Q0BMXFxO/fQ0hDQwAAAMAAP+9A5UC/wAQACAAJABGQEMAAQUGBQEGgAcBAAACAwACZwgBAwAFAQMFZwAGBAQGVwAGBgRfAAQGBE8SEQEAJCMiIRoXESASHwwKBwYAEAEPCQYWKxMiBhURFBYyNjURITI2NCYjBSIGFREUFjMhMjY1ETQmIwUhESGnIjIXJhcCHRMXFxP+iSIxMSIB9CMxMSP+DAH0/gwC/zEj/eMTFxcTAh0XJhenMSL+DCIyMiIB9CIxU/4MAAAAAwAA//0CVALEAAgAEQAaAEJAPwYBAAABAgABaQcBAgADBAIDaQgBBAUFBFkIAQQEBWEABQQFURMSCgkBABcWEhoTGg4NCREKEQUEAAgBCAkGFisBIgYUFjI2NCYDIgYUFjI2NCYDIgYUFjI2NCYB+yU0NEo0NCUlNDRKNDQlJTQ0SjQ0AsQ0SjQ0SjT+9TRKNDRKNP71NEg1NEozAAAAAAQAAP9qA+MC1QAMAB8AagBzAHBAbWhlKCcdBQYCYF1XUzs4MCwIBwZPTkEDBAMDTAgBAAEAhQABAgGFAAMHBAcDBIAKBQkDAgsBBgcCBmkABwMEB1kABwcEXwAEBwRPbGsgIA4NAQBwb2tzbHMgaiBpSUcYFg0fDh8HBgAMAQwMBhYrASIOARQeATI+ATQuAQMiBwYHBh0BFBYzISY1NDY3JyYzIg8BBgcGBycmBhUHBhYzFxQHBhUUFxQXBwYVHwEeAT8BFxYfARQWOwEyPwE2NxcWNjU3NiYjJzQ3NjU0Jzc2NScuAQ8BJi8BNCMHMhYUBiImNDYB9C1NLS1NWk0tLU0tR1ReOUUXEwFaDSsoBTbmBQcEEwoODCUDCiUDBAMhAgIBAyEEJQIEBQIlBh4TBAYGTwUIBCIUJgMJJgMEAyICAgQiBCYEBQMqIBYEDSUfLCw9KSgC1S1NWkwtLUxaTS3+NhUYJy46PhMXJC88ZyUBCAkpCAYIDBEDBANDAwkZBAoNBwsFCAkZBAlCAgMCAxAEFgcqAwUIKg0UEAMEA0IECRkECQ0HFQ0ZBAhDBAMDERkJKQmGLD4sLD8rAAACAAD/lANrAyEAHAAxACtAKCYBAwEBTA0BA0kAAAIAhQACAQKFAAEDAYUAAwN2MTApKCQjHBsEBhYrAQUOAR0BFBcWFxYXFhc2NzY3Njc2PQE0JiclJiIDJyY0NzE2Mh8BNzYyFzEWFA8BBiIB0/7cFhwrJkI4RDouLjpEOEImKxwW/twPIzZ0DQ0MIQ1X1Q0hDA0N8Q0hAxiBCikYxHJiVUM5JiAJCSAmOUNVYnLEGCkKgQn9o3UMIQ0NDVjVDQ0NIQzyDQAAAAQAAP+TA+gDKAAIADEAPgBUAINAgC0BCgYsIwIFCkIBBAUDTA4HAgMBAgEDAoAQAQoGBQYKBYAADAQMhg0BAAABAwABZwACDwEICQIIaQAJAAYKCQZpCwEFBAQFWQsBBQUEXwAEBQRPQD8zMgkJAQBNTEVEP1RAVDk4Mj4zPgkxCTAnJh8dGRcSEA0MBQQACAEIEQYWKwEiBh0BMzU0JhcVFAYiJj0BIyIGFREUFjMhJy4BNyMiJyYvATQ+ATIeAR8CNxE0JiMHMh4BFA4BIi4BND4BASIPAScmIgYUFzAxFxYyPwE2NCcuAQH0ExdUFxcXJhfQIjExIgFFJRkRDK8SCwcDAjlgbVw6BAklVDEj/h0vHBwvOi8cHC8B5w8Os2AMIRoNfQ0hDNEMDAcOAygWEyoqExZTKhMWFhMqMCP9jyMxJhlIIAsIDAsjOSEdMyEIJlQBwiIx0BwvOjAcHDA6MBv+sgyzYAwYIg19DQ3RDCENBgYAAAAEAAD/agPjAv8AHQAjAG4AdwB6QHceAQMAFwEFAmxpLCsEBgVkYVtXPzw0MAgHBlMBBAEFTFJFAgEBSwgBAAMAhQADAgOFAAIFAoUAAQcEBwEEgAkBBQoBBgcFBmkABwEEB1kABwcEXwAEBwRPcG8kJAEAdHNvd3B3JG4kbU1LIR8WFAgGAB0BHAsGFisTIgYVERQWMyEmJzE0JjU0PgE3MjYzMhc1NC8BJiMHFyMiJjUXIg8BBgcGBycmBhUHBhYzFxQHBhUUFxQXBwYVHwEeAT8BFxYfARQWOwEyPwE2NxcWNjU3NiYjJzQ3NjU0Jzc2NScuAQ8BJi8BNCMHMhYUBiImNDb6IjExIgEXEwYEQXNGBx0GHQwZyBkhCOW8ExbUBQcEEwoODCUDCiUDBAMhAgIBAyEEJQIEBQIlBh4TBAYGTwUIBCIUJgMJJgMEAyICAgQiBCYEBQMqIBYEDSUiMTFEMjIC/zEj/WYjMSgsBh0GSHxSCgQEiSIZyBk/5RcT+gkpCAYIDBEDBANDAwkZBAoNBwsFCAkZBAlCAgMCAxAEFgcqAwUIKg0UEAMEA0IECRkECQ0HFQ0ZBAhDBAMDERkJKQl9MUUxMUUxAAAAAAEAAP+9A84CzABIACdAJD41MyooIR8WFAsKAQABTAIBAAEAhQABAXYBACUkAEgBSAMGFisBIg4BBwYdARQXFhcHDgEeAjY/ARYXBw4BHgE+AT8BFhcVFBYyNj0BNjcXHgI+ASYvATY3Fx4BPgImLwE2NzY9ATQnLgIB9Vytji8FBR4sVAoIBhEYFghUKDY5BwEMFhkTBDw2NRkiGTE0OwQTGRYMAQc4NStRCBYYEQYIClAvHwQFL42tAsxGgVcMCAUJCjgyVAgWGBEGCApUIx1wChkVCwIPDHYTBH8RGRkRfwQQcwwPAgsVGQptHCRRCggGERgWCFA2OQgLBQ0HV4FFAAAAAwAAAAADxAKrABsAKAA1AEFAPgYBAAcBAgQAAmkIAQQABQMEBWkAAwEBA1kAAwMBYQABAwFRKikdHAEAMC8pNSo1IyIcKB0oDw4AGwEbCQYWKwEiBwYHBgcGFBcWFxYXFiA3Njc2NzYnJicmJyYHMh4BFA4BIi4BND4BFyIOARQeATI+ATQuAQH0gWxTQSkcBAQcKUFTbAECbFNBKhsKChsqQVNsgTlfODhfcl84OF85IjkiIjlEOSIiOQKrQjNVNTsJFAg7NlUzQkIyVTc6ExM6N1UyQn04X3JfODhfcl84UyI5RDkiIjlEOSIAAAAAAQAA/60DhAMPADIAWUBWDwwCAQAIBwYEBAIBHRoCBgQDTAUBAQFLAAUCAwIFA4AHAQAAAQIAAWcAAgADBAIDZwAEBgYEVwAEBAZhAAYEBlEBACkoIyIcGxYVFBMODQAyATIIBhYrASIHBgcnBzcnNjc2NxUzNR4CFyMVMw4CBzUjFS4BJyY1IxQXFhcWMjc2NzY0JyYnJgHTZlpXPTok2UgtQUJNSFSOWQgiIghZjlRIWpUqLEk7OmJl7GRiOjs7OmJkAw8sK0042SRJPCUmByIiCFmOVEhUjlkIIiIJZE1RXHZkYjo7OzpiZOxkYjo7AAAAAAgAAP/SA0EC6gAWAB8AKwA0AEAASQBVAF4AiUCGAAEMDwwBD4ARAQATBRIDAwQAA2kGAQQVCRQDBwgEB2kKAQgXDRYDCwwIC2kOAQwADxAMD2cAEAICEFcAEBACXwACEAJPTEpCQTc1LSwiIBgXAQBcWldWUk9KVUxVRkVBSUJJPTo1QDdAMTAsNC00KCUgKyIrHBsXHxgfDwwGBAAWARUYBhYrASIGFREjIgYdARQeATMhMj4BNRE0JiMFMhYUBiImNDY7ATIWFAYrASImNDYHMhYUBiImNDY7ATIWFAYrASImNDYHMhYUBiImNDY7ATIWFAYrASImNDYFIRUUFyEiJjUBBCY3IA0SJT4lAcokPiU3Jv50DRISGhISddANExMN0A0SElsNEhIaEhJ10A0TEw3QDRISWw0SEhoSEnXQDRMTDdANEhL+9AGMGP6lHyoC6jcn/hcTDSklPiUlPiUCMic3pxIaEhIaEhIaEhIaEn0SGhISGhISGhISGhJ9EhoSEhoSEhoSEhoS5QolJCofAAAAAwAA/4sDxwMxADsASABlAQtAFCMgAgcFNzICCQgXAQMJDAEMBARMS7ANUFhAWgAHBQYFBwaAAAYIBQYIfgAICQUICX4AAwkECQMEgBABDAQCBAxyDwENAg4ODXIRAQAABQcABWcSAQkTCwIEDAkEaQAOAQoOWQACAAEKAgFnAA4OCmIACg4KUhtAXAAHBQYFBwaAAAYIBQYIfgAICQUICX4AAwkECQMEgBABDAQCBAwCgA8BDQIOAg0OgBEBAAAFBwAFZxIBCRMLAgQMCQRpAA4BCg5ZAAIAAQoCAWcADg4KYgAKDgpSWUAxSkk9PAEAYmBdW1hXVFJPTUllSmVDQjxIPUg2NCopJyYiIRQSEA8LCggGADsBOhQGFisTIgYVERQWMyEmNSM1LgEnMx4BMzI3NjcuAS8BJjU0Njc1MxUeARcjLgEiBhUUFh8BFhc+ATMyFxE0JicTIg4BFB4BMj4BNC4BBzIWHQEzMhYUBisBFRQGIiY9ASMiJjQ2OwE1NDanHCcnHAE9MyE1QAFMAisiEgwOFwUeHDFmOzNDMT0BSgMmOiQdIS5DGCRULQwWJxsgP2s/P2t+bD8/bD8OFEIOFBQOQhQcE0MOExQNQxQDMScc/SMcJ01aRwc7LhcbBBwcDREGChVWLT4ISEgIOysWGxkWERUICQ8hGBoCAU0bJwH+Lz9rfmw/P2x+az9kEw5DExwUQg4UFA5CFBwTQw4TAAACAAD/zQNCAu4AHgAqAENAQAAFBAMEBQOAAAMCBAMCfgYBAAcBBAUABGcAAgEBAlcAAgIBXwABAgFPIR8BACckHyohKhgVEg8MCQAeAR0IBhYrASIOARURFBceATMhMjY0JiMhIiY0NjMhMjY1ETQmIwUzMhYUBisBIiY0NgELGy4bCgkwIQIVDhMTDv3rDhQUDgH0HCYmHP6R6Q4UFA7pDhMUAu4bLhv9qA4KISsUGxQTHBMnHAIVHCfIExwUFBwTAAAAAwAA/+8DQQLNAA0AHQAyAFNAUDIBBwQxJiEgBAUHAkwJAggDAAQAhQAEBwSFAAcFB4UABQYFhQAGAQEGWQAGBgFhAwEBBgFRDw4BAC8uKSgkIx8eFxQOHQ8cCAYADQENCgYWKxMiBhURFBY7ASY1ETQ3MyIGFREUFjMhMjY1ETQmIwMzFScHBiIvAQcGIiY0PwE2Mh8BN6ccJyccNBMTchsnJxsBshwmJhzIpjtUChsKK0wKGxUKZAsbCis7As0nHP2oHCcgIwJYIyAnHP2oHCcnHAJYHCf+9ac8UwoKK00JFBsKZAoKKzsAAAAMAAD/agPoA1IADAA+AEsAVgCIAJUAoADSAPwBLgE7AUYCHbWhAQcCAUxLsAtQWEBWFwsCBQcGBwVyHxgdDBsFBgEHBgF+AAEABwFwAAAEBABwAA4AEwIOE2cUCAICGQ0CBwUCB2keFhwKGgUEFQkCAxIEA2gAEg8PElcAEhIPYREQAg8SD1EbS7ATUFhAVxcLAgUHBgcFch8YHQwbBQYBBwYBfgABAAcBAH4AAAQEAHAADgATAg4TZxQIAgIZDQIHBQIHaR4WHAoaBQQVCQIDEgQDaAASDw8SVwASEg9hERACDxIPURtLsBlQWEBYFwsCBQcGBwVyHxgdDBsFBgEHBgF+AAEABwEAfgAABAcABH4ADgATAg4TZxQIAgIZDQIHBQIHaR4WHAoaBQQVCQIDEgQDaAASDw8SVwASEg9hERACDxIPURtAWRcLAgUHBgcFBoAfGB0MGwUGAQcGAX4AAQAHAQB+AAAEBwAEfgAOABMCDhNnFAgCAhkNAgcFAgdpHhYcChoFBBUJAgMSBANoABIPDxJXABISD2EREAIPEg9RWVlZQUwBPQE8ATABLwCXAJYAigCJAE0ATABAAD8BQwFAATwBRgE9AUYBNgE1AS8BOwEwATsBIgEbAQoBAQD0AO0A3gDXAMsAygDJAMgAxwDGAK8AqgCdAJoAlgCgAJcAoACQAI8AiQCVAIoAlQB+AHcAZgBdAFMAUABMAFYATQBWAEYARQA/AEsAQABLADQALQCZABUAEwAgAAYAGSsBFA4BIi4BND4BMh4BNyYnLgEnJi8BJisBIg8BBgcOAQcGDwEGFB8BFhceARcWFzMWMjczNjc+ATc2PwE2NCcBIi4BND4BMh4BFA4BEyImNDYzMTIWFAYXJicuAScmLwEmKwEiDwEGBw4BBwYPAQYUHwEWFx4BFxYXMxYyNzM2Nz4BNzY/ATY0JwEiLgE0PgEyHgEUDgETIiY0NjMxMhYUBiUuAScmJyYnIyYnJisBIAcOAQcGBwYHMQYHBh0BEBceARceARcWFxYgNzY3PgI3NhADDgMHBgcjJicuAycmJzU0PwE2Nz4CNzY3MxYXHgMXFhcVBgMuAScmLwEmKwEiDwEGBw4BBwYPAQYUHwEWFx4BFxYXMxYyNzM2Nz4BNzY/ATY0LwEmASIuATQ+ATIeARQOARMiJjQ2MzEyFhQGAm8hOUI5ISE5QjkhsgILCSUYHCkUMVAhNysSKRwYJQkLAgEBAQECCwklGBwpCDK2MggpHBglCQsCAQEB/tI0VzMzV2hXMzNXkRIaGhISGhpWAgsJJRgcKRQxUCE3KxIpHBglCQsCAQEBAQILCSUYHCkIMrYyCCkcGCUJCwIBAQH+0jRXMzNXaFczM1eREhoaEhIaGgEcAgsLEBozRwETExlUo/7zDCEtFSAZMAoDAQEBAwsKFEgtIyUNAfkMKyAtSCcEAYUDHDlLNB0YxhkcNEo5HQMBAQEBARAOOUs0HBnGGRw0SzkcAwEBAVAJJRgcKRQxUCE3KxIpHBglCQsCAQEBAQILCSUYHCkIMrYyCCkcGCUJCwIBAQEBAv7VNFczM1doVzMzV5ESGhoSEhoaAV4hOSEhOUI5ISE5dCkcGCUJCwIBAQEBAgsJJRgcKRQxoDEUKRwYJQkLAQMDAQsJJRgcKRMyoDL+wDNXaFczM1doVzMBVxokGhokGgQpHBglCQsCAQEBAQILCSUYHCkUMaAxFCkcGCUJCwEDAwELCSUYHCkTMqAy/sAzV2hXMzNXaFczAVcaJBoaJBqCHiwWIRovCgMBAQEDCwsQGjFJExMZVKP+8wwgLBUpOwsJAQEBAQkLOlM2CQIl/lU0SzkcAwEBAQEDHDlLNBwZY1IzEzAqJTkcAwEBAQEDHDlLNB0YxhkBVhglCQsCAQEBAQILCSUYHCkUMaAxFCkcGCUJCwEDAwELCSUYHCkTMqAyEyn+hDNXaFczM1doVzMBVxokGhokGgAABAAA/2oD6QNTAA8AEwAfADYAWkBXLgEGAykiAgIGAkwKAQAEAIUABgMCAwYCgAsBBAkIAgMGBANnBwUCAgEBAlcHBQICAgFfAAECAU8VFAIAMzEtLCsqJiUhIBQfFR8TEhEQCgcADwIPDAYWKwEhIgYVERQWMyEyNjURNCYBIxEzJyIuAT4CHgEVFAYBIzU2LgEiDgEXFSMRMxU2NzYzMh4BFQOK/NQnNzcnAywnNzf9xn19PhMgEAgbJiMVJAHafQIPHyUfDwJ9fRcYIB4mQSYDUjcn/NQnNzcnAywnN/zUAbU/FSMmGwgQIBMaJP4M+hIhFBQhEvoBtU4hFBkqSCoAAAAE//z/agP0A1oADAAXACQAMQA+QDsBAQEAKwECASYBAwUDTAQBAgEFAQIFgAAFAwEFA34AAwOEAAABAQBZAAAAAV8AAQABTxUYFBNCEwYGHCsTJz4BHgEXISYjIg4BJSEWDgIHEz4BJgU0PgEyHgEUDgEiLgEXBy4CNjcTHgI3MfyPTeL10j/+aAcPOmdJAZ0BHy0bidp7zCMRJ/5rMVRiVDExVGJUMfuQesdsBz3MGmB3OwGe+GBjEYFqATFXP3P1zXUBAWIzeHOMMVQxMVRiVDExVMX5EpLe92v+nzhLGBAAAAAB//X/ZwQNA1MAbAAsQClYT01EQTYtIg8JAUkCAQABAQBZAgEAAAFhAAEAAVEBAENCAGwBawMGFisBBgcGBw4BFxYXFhcWNjUnBicmJyYnJi8BJicmLwEmNzQ/ARYXFh8BFhcWNzY3JicmJyY1JjY3JicmPwE2FxYXFhc2Mhc2NzY3Nh8BFgcGBx4BBxQHBgcGBxYXFh0BFBcWNzY3Njc2JicmJyYnAgF8bWtHSSgmJVRWdRESASghHBYRDQoGBAoPCwsKFAEMCxcUDgwJHjMgJQYaQyw5HiMBGxoIAQMRCAsPFBgdIj+DPyIdGBQPCwgSAwIIGhwBIx85LEMPCQoICRJ1VlQlJihJR2ttfANSATg3YWT0dXNWWCgDEAxfCQMDCwkOCQwJGhQOCQYOCAYCAQIOCQ8NMwUDEC4XCBQaMTpcJkgcFBosLQEBAwQLDRcRERcNCwQDAQEtLBkVHEgmXDoyGRQIDRYaIowMCAgDKFhWc3X0ZGE3OAEAAAEAAP9pBM8DXgA4AEBAPRcBAQAgHAICASkBBAMDTDgRBwUCBQBKAAABAIUAAQIBhQACAwKFAAMEA4UABAUEhQAFBXYjIhQnFh4GBhwrAQYHPgE3BgcuAQ4BFRQXJiQnDgEWFyYnFRQeARcGIyInHgIXDgEjIiceATMyNzY3Njc2NTQnNjcEz0VMKDkOS1U1mJBYB5j+72AhAjo3PTU0XDogIhgYEEdfNkOiVR4eV8Vnp46BYFkxLwFLMwLcHwkYSCwsETgiOYBOHR0IinY5gXIlAh4DO2lIDAkFM08tATU3BDg6QTxtZoJ9gBULNk0AAAMAAP9qA+QDUgAPACUAOwApQCYAAwIDhQACBQKFAAUEBYUABAEEhQABAAGFAAAAdmVlZWU1MwYGHCslFRQGIyEiJj0BNDYzIR4BERUUBiMhMDEjIiY9ATQ2OwEwMSEyFhEVFAYjITAxIyImPQE0NjsBMDEhMhYD5BwU/HsUGxwTA4UUHBwU/SClExwbFKQC4BQdHBT9IKUTHBwTpALgFB0+pBQcHBSkFBwBHALRpBQbHBOkFBwc/nqkFBwcFKQUHBwAAAAJAAD/agPkA1IAEAAhADIAQwBUAGUAdgCHAJgAgEB9GhAZDhIFAAEAhREPAgEIAYUYDBcKFgUICQiFDQsCCQIJhRUGFAQTBQIDAoUHBQIDA3aKiHl3aGZXVUZENTMkIhMRAgCSj4iYipeBfneHeYZwbWZ2aHVfXFVlV2ROS0RURlM9OjNDNUIsKSIyJDEbGBEhEyAKBwAQAg8bBhYrEzMyFh0BFAYrASImPQE0NjMBMzIWHQEUBisBIiY9ATQ2MyEzMhYdARQGKwEiJj0BNDYzITMyFh0BFAYrASImPQE0NjMBMzIWHQEUBisBIiY9ATQ2MyEzMhYdARQGKwEiJj0BNDYzITMyFh0BFAYrASImPQE0NjMBMzIWHQEUBisBIiY9ATQ2MyEzMhYdARQGKwEiJj0BNDYzMKMUHBwUoxQcHBQC4aMUHBwUoxQcHRP+j6QTHBsUpBQbHBP+kKMUHBwUoxQcHBQC4aMUHBwUoxQcHBT+j6QUGxsUpBMcHBP+kKMUHBwUoxQcHBQC4aMUHBwUoxMdHBT+j6QUGxwTpBMcGxQDUhwUoxMdHBSjFBz9GxwUoxQcHBSjFBwcFKMUHBwUoxQcHBSjFBwcFKMUHAFyHBOkExwcE6QTHBsUpBMcHBOkFBscE6QTHBsUpBQbAXMcFKMTHR0ToxQcHBSjFBwcFKMUHAABAAAAAQAAcwsY0l8PPPUADwPoAAAAAOFmszIAAAAA4WazMv/1/zoEzwOBAAAACAACAAAAAAAAAAEAAANS/2oAAATP//X/6wTPAAEAAAAAAAAAAAAAAAAAAABwA+gAAAPoAAAD6AAAAaH/+QNCAAAD0P/1A2X//AJ0AAAEFf/1A9T/+QPU//kDjwAAAzEAAAMwAAAD6P//A6AAAASbAAAEmwAAA+gAAAR2//8CvAAAA+j//gLZAAAC2QAAAtkAAALZAAAEegAAAsEAAALBAAAC7gAAA+v/9gPo//8D6gAAA1kAAAOqAAADoAAAA6AAAAOgAAADoAAAA6AAAAMIAAAD6P//A5j//ANZ//0DmP/8A6n//wOp//8DSAAAA6AAAAMrAAAD6AAAA+gAAAMxAAADmAAAA94AAAQRAAADQgAAAXIAAAH8AAAD6AAAAoQAAAKIAAACiAAAA+gAAAPoAAADyQAAAvIAAAOgAAADWQAAA+gAAAPoAAAB7wAAAe8AAAMN//8DawAAAzgAAAPo//8DMv//A+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA/8AAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA/UAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPHAAAD6AAAA8cAAAPoAAADxwAAA+gAAAPoAAAD6P/8BAH/9QTPAAAD5AAAA+QAAAAAAAAANgBsAMgBEAF6AbQB9AJYAvQDsAQOBDgEYATuBTIFmAXOBhoGkAbiB3QH2AhqCO4JMAnUCjIKngsuC6IMnA0MDe4OtA8CD64QRBE0EdgTOBQ2FLAVNhXIFkIW+hc4F3oXyBgGGEYYoBjqGWAa1BsYG0wbbhuGHAAcGhwyHJQdJB4mHlwfEB+mIAIgeiCkINAhmiKGItYjRiOmJI4k5CWAJdwmfidaKAAoZCnYKh4qlCtmK8wsJiyELNQttC4YLtQvvDA+MLYxMDH6MwwzbjPkNs43UDfCOIA4+DlaOlwAAAABAAAAcAFHABQAAAAAAAIAbAC6AI0AAAEODgwAAAAAAAAAEgDeAAEAAAAAAAAANQAAAAEAAAAAAAEACQA1AAEAAAAAAAIABwA+AAEAAAAAAAMACQBFAAEAAAAAAAQACQBOAAEAAAAAAAUACwBXAAEAAAAAAAYACQBiAAEAAAAAAAoAKwBrAAEAAAAAAAsAEwCWAAMAAQQJAAAAagCpAAMAAQQJAAEAEgETAAMAAQQJAAIADgElAAMAAQQJAAMAEgEzAAMAAQQJAAQAEgFFAAMAAQQJAAUAFgFXAAMAAQQJAAYAEgFtAAMAAQQJAAoAVgF/AAMAAQQJAAsAJgHVQ29weXJpZ2h0IChDKSAyMDIzIGJ5IG9yaWdpbmFsIGF1dGhvcnMgQCBmb250ZWxsby5jb21vcGV4LWljb25SZWd1bGFyb3BleC1pY29ub3BleC1pY29uVmVyc2lvbiAxLjBvcGV4LWljb25HZW5lcmF0ZWQgYnkgc3ZnMnR0ZiBmcm9tIEZvbnRlbGxvIHByb2plY3QuaHR0cDovL2ZvbnRlbGxvLmNvbQBDAG8AcAB5AHIAaQBnAGgAdAAgACgAQwApACAAMgAwADIAMwAgAGIAeQAgAG8AcgBpAGcAaQBuAGEAbAAgAGEAdQB0AGgAbwByAHMAIABAACAAZgBvAG4AdABlAGwAbABvAC4AYwBvAG0AbwBwAGUAeAAtAGkAYwBvAG4AUgBlAGcAdQBsAGEAcgBvAHAAZQB4AC0AaQBjAG8AbgBvAHAAZQB4AC0AaQBjAG8AbgBWAGUAcgBzAGkAbwBuACAAMQAuADAAbwBwAGUAeAAtAGkAYwBvAG4ARwBlAG4AZQByAGEAdABlAGQAIABiAHkAIABzAHYAZwAyAHQAdABmACAAZgByAG8AbQAgAEYAbwBuAHQAZQBsAGwAbwAgAHAAcgBvAGoAZQBjAHQALgBoAHQAdABwADoALwAvAGYAbwBuAHQAZQBsAGwAbwAuAGMAbwBtAAAAAAIAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAECAQMBBAEFAQYBBwEIAQkBCgELAQwBDQEOAQ8BEAERARIBEwEUARUBFgEXARgBGQEaARsBHAEdAR4BHwEgASEBIgEjASQBJQEmAScBKAEpASoBKwEsAS0BLgEvATABMQEyATMBNAE1ATYBNwE4ATkBOgE7ATwBPQE+AT8BQAFBAUIBQwFEAUUBRgFHAUgBSQFKAUsBTAFNAU4BTwFQAVEBUgFTAVQBVQFWAVcBWAFZAVoBWwFcAV0BXgFfAWABYQFiAWMBZAFlAWYBZwFoAWkBagFrAWwBbQFuAW8BcAFxAAlkb3duLW9wZW4HdXAtb3BlbgRpbmZvBHBsdXMEc3RhcgtzdGFyLWZpbGxlZAZjYW5jZWwDZXllCnN1bi1maWxsZWQDc3VuCGluZmluaXR5C2Rvd24tb3Blbi0xCXVwLW9wZW4tMQ1lbnZlbG9wZS1vcGVuBnN0YXItMQRjaGF0C2NvbW1lbnQtYWx0B2NvbW1lbnQHZGlhbW9uZARsb2NrDXVzZXItY2lyY2xlLW8LbG9jay1maWxsZWQGbG9jay0xBGZsYWcLZmxhZy1maWxsZWQFdmNhcmQGbG9jay0yCmxvY2stZW1wdHkGbG9jay0zBHVzZXIEbm90ZQN0YWcKZmlsZS1leGNlbAlzdG9wd2F0Y2gLcGx1cy1jaXJjbGUMY2FsZW5kYXItaW52CGNhbGVuZGFyCmNhbGVuZGFyLTEOY2FsZW5kYXItZW1wdHkKY2FsZW5kYXItMgpjYWxlbmRhci0zDGluZm8tY2lyY2xlZAxoZWxwLWNpcmNsZWQOaGVscC1jaXJjbGVkLTEOaGVscC1jaXJjbGVkLTIQaGVscC1jaXJjbGVkLWFsdA5jYW5jZWwtY2lyY2xlZA1jYW5jZWwtY2lyY2xlD2NhbmNlbC1jaXJjbGUtMRBjYW5jZWwtY2lyY2xlZC0xD2NhbmNlbC1jaXJjbGUtMgRoYXNoBWRvdC0zAnRoCnRoLW91dGxpbmUCZXEPcmVzaXplLXZlcnRpY2FsEXJlc2l6ZS12ZXJ0aWNhbC0xC2Rvd24tb3Blbi0yB2JyYWlsbGUJbGVmdC1vcGVuCnJpZ2h0LW9wZW4FZXllLTIHZXllLW9mZgVnbG9iZQhsb2NhdGlvbgRsb29wCWFycm93cy1jdwthcnJvd3MtY3ctMQVleWUtMwtsZWZ0LW9wZW4tMQxyaWdodC1vcGVuLTEFdHJhc2gHdHJhc2gtMQd0cmFzaC0yDWNpY2xlLXBsdXMtMDEOZXhjaGFuZ2UtYXJyb3cGbWFya2V0D2NhbmNlbC1jaXJjbGVkMghzZXR0aW5ncwZ3YWxsZXQHYWNjb3VudAhjb3VudGluZwhtZXNzYWdlcw9tZXNzYWdlcy1kb3R0ZWQEc2FmZQZmaWx0ZXINZmlsdGVybmZpbGxlZA9taWNyb3NvZnRfZXhjZWwNY2xlYXItZmlsdGVycwVjbG9jawRjb3B5DW1lbnVfdmVydGljYWwOcHJvZmlsZXNldHRpbmcOcHJvdGVjdHNldHRpbmcPdmVyaWZpZWRzZXR0aW5nDmZpbGVTdWJzZXR0aW5nCmNsb3NlZF9leWUFZXllLTEKbGFzdHRyYWRlcwdteW9yZGVyBW9yZGVyCW9yZGVyYm9vawhvdmVydmlldwVvcC0wNgVvcC0wNQVvcC0wNAVvcC0wMgVvcC0wMwNyb3cEZ3JpZAAAAAABAAH//wAPAAAAAAAAAAAAAAAAAAAAALAALCCwAFVYRVkgIEu4AA5RS7AGU1pYsDQbsChZYGYgilVYsAIlYbkIAAgAY2MjYhshIbAAWbAAQyNEsgABAENgQi2wASywIGBmLbACLCMhIyEtsAMsIGSzAxQVAEJDsBNDIGBgQrECFENCsSUDQ7ACQ1R4ILAMI7ACQ0NhZLAEUHiyAgICQ2BCsCFlHCGwAkNDsg4VAUIcILACQyNCshMBE0NgQiOwAFBYZVmyFgECQ2BCLbAELLADK7AVQ1gjISMhsBZDQyOwAFBYZVkbIGQgsMBQsAQmWrIoAQ1DRWNFsAZFWCGwAyVZUltYISMhG4pYILBQUFghsEBZGyCwOFBYIbA4WVkgsQENQ0VjRWFksChQWCGxAQ1DRWNFILAwUFghsDBZGyCwwFBYIGYgiophILAKUFhgGyCwIFBYIbAKYBsgsDZQWCGwNmAbYFlZWRuwAiWwDENjsABSWLAAS7AKUFghsAxDG0uwHlBYIbAeS2G4EABjsAxDY7gFAGJZWWRhWbABK1lZI7AAUFhlWVkgZLAWQyNCWS2wBSwgRSCwBCVhZCCwB0NQWLAHI0KwCCNCGyEhWbABYC2wBiwjISMhsAMrIGSxB2JCILAII0KwBkVYG7EBDUNFY7EBDUOwAGBFY7AFKiEgsAhDIIogirABK7EwBSWwBCZRWGBQG2FSWVgjWSFZILBAU1iwASsbIbBAWSOwAFBYZVktsAcssAlDK7IAAgBDYEItsAgssAkjQiMgsAAjQmGwAmJmsAFjsAFgsAcqLbAJLCAgRSCwDkNjuAQAYiCwAFBYsEBgWWawAWNgRLABYC2wCiyyCQ4AQ0VCKiGyAAEAQ2BCLbALLLAAQyNEsgABAENgQi2wDCwgIEUgsAErI7AAQ7AEJWAgRYojYSBkILAgUFghsAAbsDBQWLAgG7BAWVkjsABQWGVZsAMlI2FERLABYC2wDSwgIEUgsAErI7AAQ7AEJWAgRYojYSBksCRQWLAAG7BAWSOwAFBYZVmwAyUjYUREsAFgLbAOLCCwACNCsw0MAANFUFghGyMhWSohLbAPLLECAkWwZGFELbAQLLABYCAgsA9DSrAAUFggsA8jQlmwEENKsABSWCCwECNCWS2wESwgsBBiZrABYyC4BABjiiNhsBFDYCCKYCCwESNCIy2wEixLVFixBGREWSSwDWUjeC2wEyxLUVhLU1ixBGREWRshWSSwE2UjeC2wFCyxABJDVVixEhJDsAFhQrARK1mwAEOwAiVCsQ8CJUKxEAIlQrABFiMgsAMlUFixAQBDYLAEJUKKiiCKI2GwECohI7ABYSCKI2GwECohG7EBAENgsAIlQrACJWGwECohWbAPQ0ewEENHYLACYiCwAFBYsEBgWWawAWMgsA5DY7gEAGIgsABQWLBAYFlmsAFjYLEAABMjRLABQ7AAPrIBAQFDYEItsBUsALEAAkVUWLASI0IgRbAOI0KwDSOwAGBCIGC3GBgBABEAEwBCQkKKYCCwFCNCsAFhsRQIK7CLKxsiWS2wFiyxABUrLbAXLLEBFSstsBgssQIVKy2wGSyxAxUrLbAaLLEEFSstsBsssQUVKy2wHCyxBhUrLbAdLLEHFSstsB4ssQgVKy2wHyyxCRUrLbArLCMgsBBiZrABY7AGYEtUWCMgLrABXRshIVktsCwsIyCwEGJmsAFjsBZgS1RYIyAusAFxGyEhWS2wLSwjILAQYmawAWOwJmBLVFgjIC6wAXIbISFZLbAgLACwDyuxAAJFVFiwEiNCIEWwDiNCsA0jsABgQiBgsAFhtRgYAQARAEJCimCxFAgrsIsrGyJZLbAhLLEAICstsCIssQEgKy2wIyyxAiArLbAkLLEDICstsCUssQQgKy2wJiyxBSArLbAnLLEGICstsCgssQcgKy2wKSyxCCArLbAqLLEJICstsC4sIDywAWAtsC8sIGCwGGAgQyOwAWBDsAIlYbABYLAuKiEtsDAssC8rsC8qLbAxLCAgRyAgsA5DY7gEAGIgsABQWLBAYFlmsAFjYCNhOCMgilVYIEcgILAOQ2O4BABiILAAUFiwQGBZZrABY2AjYTgbIVktsDIsALEAAkVUWLEOBkVCsAEWsDEqsQUBFUVYMFkbIlktsDMsALAPK7EAAkVUWLEOBkVCsAEWsDEqsQUBFUVYMFkbIlktsDQsIDWwAWAtsDUsALEOBkVCsAFFY7gEAGIgsABQWLBAYFlmsAFjsAErsA5DY7gEAGIgsABQWLBAYFlmsAFjsAErsAAWtAAAAAAARD4jOLE0ARUqIS2wNiwgPCBHILAOQ2O4BABiILAAUFiwQGBZZrABY2CwAENhOC2wNywuFzwtsDgsIDwgRyCwDkNjuAQAYiCwAFBYsEBgWWawAWNgsABDYbABQ2M4LbA5LLECABYlIC4gR7AAI0KwAiVJiopHI0cjYSBYYhshWbABI0KyOAEBFRQqLbA6LLAAFrAXI0KwBCWwBCVHI0cjYbEMAEKwC0MrZYouIyAgPIo4LbA7LLAAFrAXI0KwBCWwBCUgLkcjRyNhILAGI0KxDABCsAtDKyCwYFBYILBAUVizBCAFIBuzBCYFGllCQiMgsApDIIojRyNHI2EjRmCwBkOwAmIgsABQWLBAYFlmsAFjYCCwASsgiophILAEQ2BkI7AFQ2FkUFiwBENhG7AFQ2BZsAMlsAJiILAAUFiwQGBZZrABY2EjICCwBCYjRmE4GyOwCkNGsAIlsApDRyNHI2FgILAGQ7ACYiCwAFBYsEBgWWawAWNgIyCwASsjsAZDYLABK7AFJWGwBSWwAmIgsABQWLBAYFlmsAFjsAQmYSCwBCVgZCOwAyVgZFBYIRsjIVkjICCwBCYjRmE4WS2wPCywABawFyNCICAgsAUmIC5HI0cjYSM8OC2wPSywABawFyNCILAKI0IgICBGI0ewASsjYTgtsD4ssAAWsBcjQrADJbACJUcjRyNhsABUWC4gPCMhG7ACJbACJUcjRyNhILAFJbAEJUcjRyNhsAYlsAUlSbACJWG5CAAIAGNjIyBYYhshWWO4BABiILAAUFiwQGBZZrABY2AjLiMgIDyKOCMhWS2wPyywABawFyNCILAKQyAuRyNHI2EgYLAgYGawAmIgsABQWLBAYFlmsAFjIyAgPIo4LbBALCMgLkawAiVGsBdDWFAbUllYIDxZLrEwARQrLbBBLCMgLkawAiVGsBdDWFIbUFlYIDxZLrEwARQrLbBCLCMgLkawAiVGsBdDWFAbUllYIDxZIyAuRrACJUawF0NYUhtQWVggPFkusTABFCstsEMssDorIyAuRrACJUawF0NYUBtSWVggPFkusTABFCstsEQssDsriiAgPLAGI0KKOCMgLkawAiVGsBdDWFAbUllYIDxZLrEwARQrsAZDLrAwKy2wRSywABawBCWwBCYgICBGI0dhsAwjQi5HI0cjYbALQysjIDwgLiM4sTABFCstsEYssQoEJUKwABawBCWwBCUgLkcjRyNhILAGI0KxDABCsAtDKyCwYFBYILBAUVizBCAFIBuzBCYFGllCQiMgR7AGQ7ACYiCwAFBYsEBgWWawAWNgILABKyCKimEgsARDYGQjsAVDYWRQWLAEQ2EbsAVDYFmwAyWwAmIgsABQWLBAYFlmsAFjYbACJUZhOCMgPCM4GyEgIEYjR7ABKyNhOCFZsTABFCstsEcssQA6Ky6xMAEUKy2wSCyxADsrISMgIDywBiNCIzixMAEUK7AGQy6wMCstsEkssAAVIEewACNCsgABARUUEy6wNiotsEossAAVIEewACNCsgABARUUEy6wNiotsEsssQABFBOwNyotsEwssDkqLbBNLLAAFkUjIC4gRoojYTixMAEUKy2wTiywCiNCsE0rLbBPLLIAAEYrLbBQLLIAAUYrLbBRLLIBAEYrLbBSLLIBAUYrLbBTLLIAAEcrLbBULLIAAUcrLbBVLLIBAEcrLbBWLLIBAUcrLbBXLLMAAABDKy2wWCyzAAEAQystsFksswEAAEMrLbBaLLMBAQBDKy2wWyyzAAABQystsFwsswABAUMrLbBdLLMBAAFDKy2wXiyzAQEBQystsF8ssgAARSstsGAssgABRSstsGEssgEARSstsGIssgEBRSstsGMssgAASCstsGQssgABSCstsGUssgEASCstsGYssgEBSCstsGcsswAAAEQrLbBoLLMAAQBEKy2waSyzAQAARCstsGosswEBAEQrLbBrLLMAAAFEKy2wbCyzAAEBRCstsG0sswEAAUQrLbBuLLMBAQFEKy2wbyyxADwrLrEwARQrLbBwLLEAPCuwQCstsHEssQA8K7BBKy2wciywABaxADwrsEIrLbBzLLEBPCuwQCstsHQssQE8K7BBKy2wdSywABaxATwrsEIrLbB2LLEAPSsusTABFCstsHcssQA9K7BAKy2weCyxAD0rsEErLbB5LLEAPSuwQistsHossQE9K7BAKy2weyyxAT0rsEErLbB8LLEBPSuwQistsH0ssQA+Ky6xMAEUKy2wfiyxAD4rsEArLbB/LLEAPiuwQSstsIAssQA+K7BCKy2wgSyxAT4rsEArLbCCLLEBPiuwQSstsIMssQE+K7BCKy2whCyxAD8rLrEwARQrLbCFLLEAPyuwQCstsIYssQA/K7BBKy2whyyxAD8rsEIrLbCILLEBPyuwQCstsIkssQE/K7BBKy2wiiyxAT8rsEIrLbCLLLILAANFUFiwBhuyBAIDRVgjIRshWVlCK7AIZbADJFB4sQUBFUVYMFktAEu4AMhSWLEBAY5ZsAG5CAAIAGNwsQAHQrEAACqxAAdCsQAKKrEAB0KxAAoqsQAHQrkAAAALKrEAB0K5AAAACyq5AAMAAESxJAGIUViwQIhYuQADAGREsSgBiFFYuAgAiFi5AAMAAERZG7EnAYhRWLoIgAABBECIY1RYuQADAABEWVlZWVmxAA4quAH/hbAEjbECAESzBWQGAERE') format('truetype');
 }
 /* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */
 /* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */
@@ -17,7 +17,7 @@
 @media screen and (-webkit-min-device-pixel-ratio:0) {
   @font-face {
     font-family: 'opex-icon';
-    src: url('../font/opex-icon.svg?22057364#opex-icon') format('svg');
+    src: url('../font/opex-icon.svg?72312620#opex-icon') format('svg');
   }
 }
 */
@@ -133,6 +133,7 @@
 .icon-trash-1:before { content: '\0207'; } /* 'ȇ' */
 .icon-trash-2:before { content: '\0208'; } /* 'Ȉ' */
 .icon-cicle-plus-01:before { content: '\0209'; } /* 'ȉ' */
+.icon-exchange-arrow:before { content: '\0210'; } /* 'Ȑ' */
 .icon-market:before { content: '\e800'; } /* '' */
 .icon-cancel-circled2:before { content: '\e801'; } /* '' */
 .icon-settings:before { content: '\e802'; } /* '' */
diff --git a/src/assets/fontIcon/opex-icon/css/opex-icon-ie7-codes.css b/src/assets/fontIcon/opex-icon/css/opex-icon-ie7-codes.css
index 9e67a559..96db0f74 100644
--- a/src/assets/fontIcon/opex-icon/css/opex-icon-ie7-codes.css
+++ b/src/assets/fontIcon/opex-icon/css/opex-icon-ie7-codes.css
@@ -75,6 +75,7 @@
 .icon-trash-1 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0207;&nbsp;'); }
 .icon-trash-2 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0208;&nbsp;'); }
 .icon-cicle-plus-01 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0209;&nbsp;'); }
+.icon-exchange-arrow { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0210;&nbsp;'); }
 .icon-market { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe800;&nbsp;'); }
 .icon-cancel-circled2 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe801;&nbsp;'); }
 .icon-settings { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe802;&nbsp;'); }
diff --git a/src/assets/fontIcon/opex-icon/css/opex-icon-ie7.css b/src/assets/fontIcon/opex-icon/css/opex-icon-ie7.css
index c14da143..33bca454 100644
--- a/src/assets/fontIcon/opex-icon/css/opex-icon-ie7.css
+++ b/src/assets/fontIcon/opex-icon/css/opex-icon-ie7.css
@@ -86,6 +86,7 @@
 .icon-trash-1 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0207;&nbsp;'); }
 .icon-trash-2 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0208;&nbsp;'); }
 .icon-cicle-plus-01 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0209;&nbsp;'); }
+.icon-exchange-arrow { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#x0210;&nbsp;'); }
 .icon-market { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe800;&nbsp;'); }
 .icon-cancel-circled2 { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe801;&nbsp;'); }
 .icon-settings { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = '&#xe802;&nbsp;'); }
diff --git a/src/assets/fontIcon/opex-icon/css/opex-icon.css b/src/assets/fontIcon/opex-icon/css/opex-icon.css
index bd00882f..6a83f4a9 100644
--- a/src/assets/fontIcon/opex-icon/css/opex-icon.css
+++ b/src/assets/fontIcon/opex-icon/css/opex-icon.css
@@ -1,11 +1,11 @@
 @font-face {
   font-family: 'opex-icon';
-  src: url('../font/opex-icon.eot?26088334');
-  src: url('../font/opex-icon.eot?26088334#iefix') format('embedded-opentype'),
-       url('../font/opex-icon.woff2?26088334') format('woff2'),
-       url('../font/opex-icon.woff?26088334') format('woff'),
-       url('../font/opex-icon.ttf?26088334') format('truetype'),
-       url('../font/opex-icon.svg?26088334#opex-icon') format('svg');
+  src: url('../font/opex-icon.eot?50181082');
+  src: url('../font/opex-icon.eot?50181082#iefix') format('embedded-opentype'),
+       url('../font/opex-icon.woff2?50181082') format('woff2'),
+       url('../font/opex-icon.woff?50181082') format('woff'),
+       url('../font/opex-icon.ttf?50181082') format('truetype'),
+       url('../font/opex-icon.svg?50181082#opex-icon') format('svg');
   font-weight: normal;
   font-style: normal;
 }
@@ -15,7 +15,7 @@
 @media screen and (-webkit-min-device-pixel-ratio:0) {
   @font-face {
     font-family: 'opex-icon';
-    src: url('../font/opex-icon.svg?26088334#opex-icon') format('svg');
+    src: url('../font/opex-icon.svg?50181082#opex-icon') format('svg');
   }
 }
 */
@@ -130,6 +130,7 @@
 .icon-trash-1:before { content: '\0207'; } /* 'ȇ' */
 .icon-trash-2:before { content: '\0208'; } /* 'Ȉ' */
 .icon-cicle-plus-01:before { content: '\0209'; } /* 'ȉ' */
+.icon-exchange-arrow:before { content: '\0210'; } /* 'Ȑ' */
 .icon-market:before { content: '\e800'; } /* '' */
 .icon-cancel-circled2:before { content: '\e801'; } /* '' */
 .icon-settings:before { content: '\e802'; } /* '' */
diff --git a/src/assets/fontIcon/opex-icon/demo.html b/src/assets/fontIcon/opex-icon/demo.html
index ae6b2f99..a8167c40 100644
--- a/src/assets/fontIcon/opex-icon/demo.html
+++ b/src/assets/fontIcon/opex-icon/demo.html
@@ -146,11 +146,11 @@
     }
     @font-face {
       font-family: 'opex-icon';
-      src: url('./font/opex-icon.eot?43374703');
-      src: url('./font/opex-icon.eot?43374703#iefix') format('embedded-opentype'),
-           url('./font/opex-icon.woff?43374703') format('woff'),
-           url('./font/opex-icon.ttf?43374703') format('truetype'),
-           url('./font/opex-icon.svg?43374703#opex-icon') format('svg');
+      src: url('./font/opex-icon.eot?44260891');
+      src: url('./font/opex-icon.eot?44260891#iefix') format('embedded-opentype'),
+           url('./font/opex-icon.woff?44260891') format('woff'),
+           url('./font/opex-icon.ttf?44260891') format('truetype'),
+           url('./font/opex-icon.svg?44260891#opex-icon') format('svg');
       font-weight: normal;
       font-style: normal;
     }
@@ -477,6 +477,9 @@ <h1>opex-icon <small>font demo</small></h1>
         </div>
       </div>
       <div class="row">
+        <div class="span3" title="Code: 0x0210">
+          <i class="demo-icon icon-exchange-arrow">&#x0210;</i> <span class="i-name">icon-exchange-arrow</span><span class="i-code">0x0210</span>
+        </div>
         <div class="span3" title="Code: 0xe800">
           <i class="demo-icon icon-market">&#xe800;</i> <span class="i-name">icon-market</span><span class="i-code">0xe800</span>
         </div>
@@ -486,11 +489,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe802">
           <i class="demo-icon icon-settings">&#xe802;</i> <span class="i-name">icon-settings</span><span class="i-code">0xe802</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe803">
           <i class="demo-icon icon-wallet">&#xe803;</i> <span class="i-name">icon-wallet</span><span class="i-code">0xe803</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe804">
           <i class="demo-icon icon-account">&#xe804;</i> <span class="i-name">icon-account</span><span class="i-code">0xe804</span>
         </div>
@@ -500,11 +503,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe806">
           <i class="demo-icon icon-messages">&#xe806;</i> <span class="i-name">icon-messages</span><span class="i-code">0xe806</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe807">
           <i class="demo-icon icon-messages-dotted">&#xe807;</i> <span class="i-name">icon-messages-dotted</span><span class="i-code">0xe807</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe808">
           <i class="demo-icon icon-safe">&#xe808;</i> <span class="i-name">icon-safe</span><span class="i-code">0xe808</span>
         </div>
@@ -514,11 +517,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe80a">
           <i class="demo-icon icon-filternfilled">&#xe80a;</i> <span class="i-name">icon-filternfilled</span><span class="i-code">0xe80a</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe80b">
           <i class="demo-icon icon-microsoft_excel">&#xe80b;</i> <span class="i-name">icon-microsoft_excel</span><span class="i-code">0xe80b</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe80c">
           <i class="demo-icon icon-clear-filters">&#xe80c;</i> <span class="i-name">icon-clear-filters</span><span class="i-code">0xe80c</span>
         </div>
@@ -528,11 +531,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe80e">
           <i class="demo-icon icon-copy">&#xe80e;</i> <span class="i-name">icon-copy</span><span class="i-code">0xe80e</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe80f">
           <i class="demo-icon icon-menu_vertical">&#xe80f;</i> <span class="i-name">icon-menu_vertical</span><span class="i-code">0xe80f</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe810">
           <i class="demo-icon icon-profilesetting">&#xe810;</i> <span class="i-name">icon-profilesetting</span><span class="i-code">0xe810</span>
         </div>
@@ -542,11 +545,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe812">
           <i class="demo-icon icon-verifiedsetting">&#xe812;</i> <span class="i-name">icon-verifiedsetting</span><span class="i-code">0xe812</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe813">
           <i class="demo-icon icon-fileSubsetting">&#xe813;</i> <span class="i-name">icon-fileSubsetting</span><span class="i-code">0xe813</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe814">
           <i class="demo-icon icon-closed_eye">&#xe814;</i> <span class="i-name">icon-closed_eye</span><span class="i-code">0xe814</span>
         </div>
@@ -556,11 +559,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe816">
           <i class="demo-icon icon-lasttrades">&#xe816;</i> <span class="i-name">icon-lasttrades</span><span class="i-code">0xe816</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe817">
           <i class="demo-icon icon-myorder">&#xe817;</i> <span class="i-name">icon-myorder</span><span class="i-code">0xe817</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe818">
           <i class="demo-icon icon-order">&#xe818;</i> <span class="i-name">icon-order</span><span class="i-code">0xe818</span>
         </div>
@@ -570,11 +573,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe81a">
           <i class="demo-icon icon-overview">&#xe81a;</i> <span class="i-name">icon-overview</span><span class="i-code">0xe81a</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe81b">
           <i class="demo-icon icon-op-06">&#xe81b;</i> <span class="i-name">icon-op-06</span><span class="i-code">0xe81b</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe81c">
           <i class="demo-icon icon-op-05">&#xe81c;</i> <span class="i-name">icon-op-05</span><span class="i-code">0xe81c</span>
         </div>
@@ -584,11 +587,11 @@ <h1>opex-icon <small>font demo</small></h1>
         <div class="span3" title="Code: 0xe81e">
           <i class="demo-icon icon-op-02">&#xe81e;</i> <span class="i-name">icon-op-02</span><span class="i-code">0xe81e</span>
         </div>
+      </div>
+      <div class="row">
         <div class="span3" title="Code: 0xe81f">
           <i class="demo-icon icon-op-03">&#xe81f;</i> <span class="i-name">icon-op-03</span><span class="i-code">0xe81f</span>
         </div>
-      </div>
-      <div class="row">
         <div class="span3" title="Code: 0xe820">
           <i class="demo-icon icon-row">&#xe820;</i> <span class="i-name">icon-row</span><span class="i-code">0xe820</span>
         </div>
diff --git a/src/assets/fontIcon/opex-icon/font/opex-icon.eot b/src/assets/fontIcon/opex-icon/font/opex-icon.eot
index 5e9c2780e1651a7529b14875d6a22439bab7b8ae..5a07673f991c90e8e0603bfe1256166d765f8c66 100644
GIT binary patch
delta 1189
zcmXAoUuauZ9LK-s-kX~?X>J<L-?nbCCh1K7tbgnutBgL32}5U{Zf>2rW^K|qo93Ft
zT75`5XvK+cuF<Xo86qMmdl<_W`Y><`zKDnqdr%O|q(UBi7=kcIyZF65_wqTP^ZT8g
zoO|y1-L<RA(ltfbE&<2ZF6cwrXwZ?rFm}GQ3lQS~CZ{q9^WIxO6d7Ly>|0awg)sBH
z&VJ6uNSQO4Q$7E^%b4Rv(@Y|7GT+R2jc%BkeJ6FP^7TJJ;}xK=o=zsFW7ogYfZ{aA
zhtf<mgtSi?f5teH&J-3tb{?&N!Ne^tdTTa2mH07xWfNFj<PZMLBo<8N!)7;d#`=Ts
zTq2YFJ7mu@UILWg%xu2!-G+M`SegWE!)7jN7OPKHfr~fGUy2iAWktz$tV3`z#5Jfp
zy)N3p>FdzMdmM-%3=MjDRS7FfbGfR-bfvk5dcEw?qEW%|5$wYO9K<V_<(<Pk7Iy9r
zu!=QY#^rKM-LPf3hR!+n%XgJVcaycIZNJs>%2rxzD{4vMyRyJ@K#j7%A(~HUf#+#O
zf^k}v;00Qf;4p2I;6+-O;3e8F!4bMaf}?cf4kh4acDQ*99HX5Q9H;rn7MP%25}cq7
z3Ac|L&%y$)(%gszUZXt{oTML;V3K}Vf&}g5`ZX^noT7aaOwoP`c*wPY1W7t5L5dDZ
zFhjRUkfvKDc%5#O;57Y+1aHu+a0^6d+1V{Yh7L<GM?WgzQSEnpbfBcv>-E!WR6PP8
z;uskl>=2sb5D?0<P&8$k#iK2=p2V`Q+IUR!0lz>r;*SU7hO5C2pYYjrf2XZI)*)g~
z4E6689=3j;$E(}*f%e!S!{H%+K={3S`(DAc=ySO354MfAh^rbJiw6ytt?CUKE?0|F
zs77nlxY4qzH?SLNHEyV3Zz$y5${7Jo3whOZv|V>T*mgx)UDd4(Z>aLic%i#3?+A{b
zbU*zs-0DuP-APsY`66JsJXstTW@W87DAayd``uEg@>j_z4n6i&<XmJkx)}XER_vJA
zgFVxa{~F&F|D-e3`BPV{YpLsY_w}A&&+WZ8d-wHL`+EEC4>S$T4QvkmJUl-9{mA0T
zy(cF|Su8tWn^_q>6HtX&KD_jYBHpa@F5gkyMsi^)otT?Rb|-SV?AsO3`_G8V@w49=
F{{xiy6cYdd

delta 932
zcmXAnUr19?9LK-+ZcgW)O)LMU)uK5wbz0h7<U<cq5oB6smX^-{)#fhkA{N%9W{mz&
zdc~xA2r94?v2KVD6$KGK`p`omn7+gwgn|%C%KFZ84xjruzu&pPdpP%;&`Wt_QZ{9b
z0N#58CYLd9Y)&26cPF?7kg5PQwfH>BgJ<c>j3<HEZ!O)bjd`~4D?TjkN{6r6`TG*%
z4-6AKJOPFIWX9ukT!;5!`_H7vC&0`_0>3)jJgp9M<#XWjUCz5YnTX3Y4l$l#Z141`
zJ-0sB{(H>C5*K~#^|yG2zQ0%nf}?z4!RP5w<eSM>pfAkW*5&cFEoH_A7;|3!qWA;q
z-<jlT;93ZXaVQtslq*wvr-0#E?TJ(`X@jyqcLEZNA&tVYHY%XwSv~=y)XNDwY%s#8
z4a+udT6Sm)a_%;XSr^JtfrB`ObL<LKbg%U=hA@nWn$z%Aw;B^Avpf2Ewl3WsGiV4#
zIE;eBG?$KoN?I1+2yGCciZ%*RO~(julr{-)jE)tchK>{9IBgc7mgc5N5IDg>f&g`N
zq5vo9BmsAYh(&;Unm;)T8fczq6r8401UN&l6QGe^FF+H$K>!b(%Jn0uEN-UL1Zbht
z1!$!+1Zbl(1!$)?3eZ7k3D8Mr3via+B;b)CvRQ!hG_P?KWO+HT3E-o*3eW}Ub@8|N
z>rbl#h1u%dSYD&Gd>K~5+F>oG#PqWoQER2aGRd!dgS#c|eP4$DrY}J{WOv#_Ikuc$
z$7aV$?xXF-yq>(bJ4*9S`QH4G1@;29u%>X@sTMU9%@@}e&+fdxYrMo#5^{C9ev~!4
nZSE2G%AP-K_s_4VT}?Mge$ClGuUoD!%KB>ffTUO4cxU+!f;HwM

diff --git a/src/assets/fontIcon/opex-icon/font/opex-icon.svg b/src/assets/fontIcon/opex-icon/font/opex-icon.svg
index a36d149f..e4cecd75 100644
--- a/src/assets/fontIcon/opex-icon/font/opex-icon.svg
+++ b/src/assets/fontIcon/opex-icon/font/opex-icon.svg
@@ -158,6 +158,8 @@
 
 <glyph glyph-name="cicle-plus-01" unicode="&#x209;" d="M854 704c-196 195-512 195-708 0-195-196-195-512 0-708 196-195 512-195 708 0 195 196 195 512 0 708z m-103-422h-183v-183c0-37-30-68-68-68s-68 31-68 68v183h-183c-38 0-68 31-68 68s30 68 68 68h183v183c0 38 31 68 68 68s68-30 68-68v-183h183c38 0 68-30 68-68s-30-68-68-68z" horiz-adv-x="1000" />
 
+<glyph glyph-name="exchange-arrow" unicode="&#x210;" d="M305-150c-14 0-23 4-32 14l-259 259c-19 18-19 45 0 63s45 19 63 0l182-181v800c0 27 18 45 46 45s45-18 45-45v-910c0-18-9-36-27-41-5-4-14-4-18-4z m195 0c-27 0-45 18-45 45v910c0 18 9 36 27 41 18 9 36 4 50-10l259-259c18-18 18-45 0-63s-45-18-64 0l-181 182v-801c0-27-19-45-46-45z" horiz-adv-x="818" />
+
 <glyph glyph-name="market" unicode="&#xe800;" d="M541 767a42 42 0 0 1-41-42l0-42-42 0c-25 0-41-16-41-41l0-209c0-25 16-41 41-41l42 0 0-42a42 42 0 1 1 83 0l0 42 42 0c25 0 42 16 42 41l0 209c0 25-17 41-42 41l-42 0 0 42a42 42 0 0 1-42 42z m-333-291a42 42 0 0 1-41-43l0-41-42 0c-25 0-42-17-42-42l0-208c0-25 17-42 42-42l42 0 0-42a42 42 0 1 1 83 0l0 42 42 0c25 0 41 17 41 42l0 208c0 25-16 42-41 42l-42 0 0 41a42 42 0 0 1-42 43z m583-84a42 42 0 0 1-41-42l0-42-42 0c-25 0-41-16-41-41l0-209c0-25 16-41 41-41l42 0 0-42a42 42 0 1 1 83 0l0 42 42 0c25 0 42 16 42 41l0 209c0 25-17 41-42 41l-42 0 0 42a42 42 0 0 1-42 42z m-624-84l83 0 0-125-35 0a42 42 0 0 1-7 1 42 42 0 0 1-6-1l-35 0 0 125z" horiz-adv-x="1000" />
 
 <glyph glyph-name="cancel-circled2" unicode="&#xe801;" d="M0 350q0 207 147 354t353 146 354-146 146-354-146-354-354-146-353 146-147 354z m109 0q0-162 115-276t276-115 276 115 115 276-115 276-276 115-276-115-115-276z m145-137l137 137-137 137 109 109 137-137 137 137 109-109-137-137 137-137-109-109-137 137-137-137z" horiz-adv-x="1000" />
diff --git a/src/assets/fontIcon/opex-icon/font/opex-icon.ttf b/src/assets/fontIcon/opex-icon/font/opex-icon.ttf
index dd5767bfbe540f127a9f7c96a4c658eb2404925b..dea39e803695d23b42f64237b3e24f160020404c 100644
GIT binary patch
delta 1163
zcmXAoOKclO7{~v!yIv<wyiUNe<0Pae^`khC=0W06P}Kt}5-P<&TOb9JZDKo=I5vq1
zp;BWb99}9>sc8ukst|`tpn@tkwQ{ILLE?fCryh!gh>CKEP)<ll0p-DeJ-hntZ@zDK
zc6N5Y-TYR$dqcUnzt9ed1c0&ejG5bd<EI72Hvs4M_*_27JdY2);KfMg(wQ?o|DI#a
zexp8Z&gPhJV7yG%q^I6WeP(_2H&A;W$gfT&&56j$*BY=e!TzC1CTarOWyYT~4oznA
z^B3z*?S09_ZBBZ7Dm!leoV~sd6pOs!&x|>rQ!X@kfVb@j1gFhRax>tZWn2Q3-*Va6
z{10oM9iTJ@IO4gPWNxAIXa)H6*2i0?#ijBIk&UiGa4^JoP^+yj+Qs3k(8Rm!h#&|J
zdigIARFsCYONrR(RiaT2V(%~x<0ziQOPJz0gE`Ds&ku10%eacG<#WoKBg>ohvZ?Nt
z6N;les_C_l+q3e>TGQGkwV?1j+2AQ)gR;SKnr~-=r)fok1g%Q&46RA<EbWlsIa-(C
z1nrdIBwZuHDY~{w0eGGbF5Ct$&~*~LNY_g+Lc1k6O&by}9vj>T8@x<&AvSo0Zj@k@
zzE6TN`hE#a+ROPjyc}?bZjxY}_DR4E-tbG1q?;v3(E$n4bc+O&bgKlf(rpr)r5}*s
zHJa6JgYXm^`y|NFK?$bm2PNF9<=T&q7L>icy|ZdqJ&7j7FnnY%Dm29<Ae3WJG-Z*6
zqb;&F#G<Y`xJ`3@pFlX|i}_=QyT*wo(d5*9osN!3R74&g>fa|CdG$3ldUdBh&=DDA
z7$5Tah0m*Z92888K9|S2yJNJ4+?BwQShL}FRJ;Mh?QW?Ps?i!YZnj*}YuF668aLIT
zHxTe{&lrA93wYHf+Nsy=?zls(?#lL>H(-Sl`R=w^SM#A!&tw0<qgHF}Udrm{hk)(!
z%K5m+S)1nvh3L213lVXA|FzIkXgypE{~lS0jvT;&iHGjS+GC$|raFJ=igcB_?sTv8
zH22&&c&qntZ>6ud@4tcif$4$up<m;P_>aTI;jKqT4zWzC|5(miD*9ECD_?u(4@JCg
hl}h&%kCB`opERe_$!>FICi|w9eD4Wiee?eJ#{ZLs47mUR

delta 934
zcmXAnUr19?9LK-+Zc~?krlpx_HgV3(zh%uuK1M~5Ei?P0rE|?K+uUkHR+uxJu&BVg
zB2qmBy;zADH^hesA0mA8p$8+de2Ec4K?o|9eecdWe9q_m&YyeEx#uiS%PUjzNNIF8
zAUObZy8O=I)0g?HjHiLr@2<YEne9yRw=A-{gC2iZ&H63I9~fqMoS`7wvl&m)X&&Fr
z?%$b-Pk?b82(5YD&MQ`9(<|Wi2>WebHl!8kM;XsEws`&F$b-e!%@=G~;iB(+0he?1
z=bL{(bb<rE`JIuVd_UU+48|Fod!2swN<nIfG5h7u!9XbdcRqU-xEliu*5D0yaA4-}
z3^2CvXsu0BlolyaJ_U)BAx%J+tX0ulIDHCwsh=Gdn4yPW`5~E=4B4trU~^Nst}88-
z*kwZ_j^H>hqK7$%F#3`?j!}%^nKC4Q<yTWUeob-6>81>ADT7@rnR?ZT{;@8aU{wPr
zX>LXXO|&e)DOx9hgVqahnl=c~Os5ENhE5frg-#RTENv8^mF6)?6gbC9x&Y^CZc_sn
z=u82Rh(wkEZ8U$o2HI)fu?8;DIRad!w+hffZxf)C&K1B(=W+c+9w&Fv+XZmZ`2t*_
zcL?C73k2w<cM9O43kC4fMFL!<cL{huNE8cjjpoDFK%tKnvjBd&M1WpEoisi?s;)ai
z)kWbiuPZuCjjJ%}l9#odV;JUaXjb9_4N^dz8#pK_C4;$Y=AcPBVX3ji%FJc`)?({M
z`SU&cib%!#y$32&Dt(n7t1MOF>Xz!+ns9A<?NVK9-NL>n`zPzO>SMNE+pmT$yV*W&
j-#GLq`62^q&z*do6i|j@OKR8fvaB}8k4ftIy}7Lard;Q*

diff --git a/src/assets/fontIcon/opex-icon/font/opex-icon.woff b/src/assets/fontIcon/opex-icon/font/opex-icon.woff
index f3dbaf00e48e3125597ee0dc4e6790c5de26091e..91ddbc94e623ee051fa85e9f1fadc63ebcafe891 100644
GIT binary patch
delta 20724
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

delta 20513
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

diff --git a/src/assets/fontIcon/opex-icon/font/opex-icon.woff2 b/src/assets/fontIcon/opex-icon/font/opex-icon.woff2
index 9afebb929a86126440c5c41876c12cb055411e95..a914a9b2758554fba1aac8b6055a4b29293a6ce3 100644
GIT binary patch
literal 20264
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

literal 20140
zcmV(>K-j-`Pew8T0RR9108Xp`4*&oF0GDh408UW=0RR9100000000000000000000
z0000SR0d!Gk7fuC37iZO2nvDcc!9`g3xQw&0X7081A{ySAO(e42Z|;PfgBt2g$LL+
zjbq+z1E5AbsP;d<BN4*J0fERcoP{)la<b3<|4&Iy#t@dlG&Svihn&@D3NFFjB#d-k
zG7>UPIF<dTtmtTzO=L+cuH|>Ru>=K=pui*+i_K#5U1oiRFF$qEFV~ilZH!1~_?>%U
ziKp;75N;S74V@+#O%7MMYV?Wx@?ymnUg(g5f6@OdN+=#WY=uMN1w|IBHYPev@z$Zu
z3Z7upi?SDRcm}qO?UPI<FU0d>?(Y3RQ`CkJe5hn7f#j)BDz!sOz{5B9y>}*)3BrRc
zyhVT%0A(xG)>WtqSs}lZJ-!3Hp8b1?U5N}Lu_B2Gu`(qwlWpvXu|kd6iq%k3)Y!jN
zl~i3hcXTY(MY#5^ey3jf<xbC6z4d>`Qf_EZGrV43FAMQ|Ib>eI2{mwL{J|rNmYupq
zch$A^4ga41o^vrIn-7Zj+&1^!K5+npf$orQPBsUvha$KbRF5cv;aB`a-rnDUy24~E
zQI~1Vc}F(Woj+Y*S0}K!O6n9HH-)ocK)z-t<xI*0fz8sJK?Z;W_<y)}@4Wjz20lpE
z5(~@50xi)nPb8Bz{kr~_Y36(1b@v$9H9X@@Bu{dx_HYgbxg{tw9NDcs6QWuM8^jkX
ziIoM4Qu(1jm4~Ti74CYS48K4D)CUJaSCrx(kDWct+NLLk3CLy3rnIa76vyBY8jS)M
z;{j3DYUafuJOBvmJLu-~kx*K+jX{EF!0SN!{PRV0SmbQnZ<uwO&ir4?q(q7+3;72b
zqdEnmg?ql$3jc4dt&GW$>G*%|W)=u(8&Q4Er4jLzO+unJ5C`|EN0vbMRGrEg#G$bF
zZ<~8xE!mbWkNHN%+<<nYe?_^VK}atE;{LDBlwLOLbu0%8%sv9a0dmQ{+w5f6+pZlZ
zf;D0NuOsf?n`*ZIFUS*k5p;wzbu*lSE`?r_Q!ZU}F3PumvB3X-7r^cUq!tSWa7oz!
zB%XH{l4c3&PVqD(#Y?<%3V8)eXAn{Wg1Q@0x`LF>A;-#X$fYYcrOGQxSEa{QDw@Vs
z>ArVD&;SJ{&1rM@Nk`VsiUOu1a0G6xva@2x{rdkiV{f^k(nbjN|32R^rq-EC#%g;j
zw%ZlOhzvo75W(F2Z-cSfAGqz2MWa0;)$cI!z5YO@DU_ohzB;?b@gM+IU{(N#cqka)
zTG4E84jwT89!TD<FWXu)AGX1Tm6%u50^4a__K474x?>g~_UB9hzE3}Vp9MV#KmaBb
zc$m}kL-oLaiT{>jyx`5V@g2NfqHqA=0uWAs+D9xG=ks+>W)!iyI}~suGhmHPk0X+w
zM9>sO<Af_bf`}!NOmZlriZ+fW6k__kVFv+$z!3^G_{0)N2H7PpT}O99AV$yQT0S%q
z805{57|Sze=d-luVA~&Q3?;>z(7^wX@BkZd02lB89|(XDh=3Rp3YsM=7}l_GY}m46
z&jFqz0wNM8WX>pDxT137&Vwf}G;|D1ENtF5xOjZ{^5ZW+AU+I^K%&qXEDo<mAd<)w
zDvi!yve+Chk1tTy(A3h_(bdy8FccaYo0yuJ0~!HQR~_gpaPQD3RuGx;z78Uh5;;*w
z6ceRHIZ;Ve7lGO$QC}1qi$-%D(OLr9OGIZ$=&lonmV)7R!N|H|bZHn{I>wiQiDhDP
zS(sWjrq>%Y%fak&F}FO-FCPmlz~TzAv?BCYjOCSJWu;hM8P+xk>l=%Wjl<@~qrVB*
z+C*$`26lEgb~h7yn~nX=!NHc{aH}xbIvj01j`tu=wgIQxh_h|N`8MNXTX4CpxY{;c
zZ#QnX2e*3|ciW5mJ%Wer!{Z)>*^)z$9*XP;<VQkrWRyoiwF>G5XcnSf72U4TuZCgQ
z7<Yqdb<AsEu_l&lVYN2a>tM56Y<Gv<BJ3CAums1YI4#3@U0l|~bvbS;a9<yf4e;C$
zuZ{5D7@tk>-4wsg@Ly$-?R)l#{}YRUFksTaldF|z`=0P_8~XaE!{Qo7AN`2p(*vZ3
z2U~1DAIgPc1~oX4DkC`XwhsYxK1O{=2n+XNfZ8i#{>g+bk&(Q&NzRux4GkYa@?=c#
z3rLosg}NALIW$CX(KmR-DefFDOzyv;(<L@%n&qK!G`H?jbE&d1q+CXzprg=^N;%VM
zs3p8xv{Cw*M>SwQtf6-uH<n$GemQEI_*&F&FYauY7+8JUy!xn=qJhw2l*n(OB+T;J
zQs|w7Mik$w6S>Ssypzt|Ct(>an_ji938cg45ZpU(v0@xjLxdi0&vCeqWtbayZ^~z?
zZBU5VWaN>yfRbXh4--@ql!tcEEIvR7DGhd)H_Y|)<5AJ128yDRtlClr>8fhlPJWo+
z6Ey&{&krUknpXeSNVB6uQ0dV50~3zaiL#FQ-D@Ygp^4m%gY{tn4!ar2Vr0+k6jlff
zYzN4C1kns8tiG}w5TeeI!+Ry4DF(H6KQue*tGf^7B0F<(P}>f34f1y7BGreG7a_SK
zl>1;f4ph_<+Mr?vT;MXh#4=%cQLXBqOmMD_!4H@{#waA6aa;v6VjMj<*$8WgdtZbk
zhj#Hr3tW1Pi4s~7x6T%KsHU1BZ}2^i0rdojL=Yd{EBQPQRCme`G%DEO5lO=o+b1rm
zw$k?q1~QINHgxE=k2ktu70P0BBvPKzbghA?ERxXfRHWM!ZE@^_SQLWc15c#Wpzc<D
zvnB`PKFgcLi)!+a6lZB)QbZg`Kryo$M(qvz4x8XnQ9%%F{|ePz;{p>2d355C7M5y+
zYY9OC@`2><n#+?U@<^;E*s~m45>?74Ch%9Rz0*EQB#PKjLlCGbNYoMx)D{$~1QT@$
z8g&a6>Je<zD>&;XAhdTte{7#P-!33tB?aWz$&6)X$LGpZ%Z59?-ew(4APO9ZAgY@U
ziFUya_u&ri$A$;6;X!P82pb;8hDWgBQEYe&8y?3tI1O6jRy5=GXns&BzEZLiHh3c9
zs?DOKp=kejo6Lb|Ks{+om=mSG_qp6)j^^WQJB4Gr!Zsb|`pMLV+I>_E)dkY*eg5Dg
z=o`}OmM{_RXZLcTc%ZT8G@J6Dhni|d=F*}Tc)m@RK}$41-2?{$WN8J(vn6+(R*S&~
zS+Ul?h9sqQD!2s(B&D<&-}Vbr3FIz}#`PCAuc}yh+#&9DfbzTXrz^Ko5i|MX2YT#Y
z#_57+DXzk5HgZ(J(x9V6N$~h5`ozC`>8_N`cFbByvu(9nc9Tnr1En=-x+yh>D)*W$
zJ|YDu`c_~vv_kasU?}%mZnx$0L8#G@qzQ9ISuUH=3Y>I-oAnfPiI`-$XM|~bn0F7+
zf=VqAoEfXEMR&Rk)xY#69T;W$%oLfjG?!ksm4%x}8z2pm9!zhiOC5<*8KO%(x`LL3
zO>)BtrIgClwFl!i-Ih25_bBLcPw|4^(>wQs@`*hRU?&{y66`g1AuWW0F#8&G2j)m!
z(y2w7)x29+b?=Ff%)$QmtL=5^*ZBZgkH(ybz(&MQPsHmM#?@j_8eoChW^|OL6iqcz
z-3;)%c(=)cO8rJEWDd6b7|9)R3;Ud(Pl<s56MTpcd(|bGGb}3W_pB(&$%*x#NOKy*
z{hkH<kh$*TY*q~UO-8!wN4ep0f12~p1rowrV};h2<z~&v)j!Hzp@Nz?P*G}g4Q`Gf
zlHjv<gA5JFEoBgOi~x<gt_MRSg_}qLi}r1N1OWtt6No!OfERS%h6n@3I%77-o5O)(
zE2Z8>3UsJ<^<ddc;eDjQfVRUafec~FWi&y+IM_~*0@FZd69mkI-v!=-dGOk0YyA#N
z-3I16cX&pC*SpC%qL)2G!oDGLa0GfKB8&>GiaX?M_+l-=AkomIzX6ezC`wc%S^?<>
z8HQ%UK(SP@RdG~t3&=CbXSn}kz_0hMwgbJE)zHy(!iH7zZis8Z9>6FM#vjym`rCyf
z!2jEY?dgAq{*Q$D-|B}3g(v=lhd+Q9VlJALEDD7FyP8o+$d)GvR57U%<@p_o4we@b
zbLBY<C&Gh1p+QJgz9P~JheG|bWlD$P&5A%0rXvFxLh1{Vj7(MveR#G^PDZ{Jhdv!!
zZEb^xNnp6V&6Fajteu<BpF7Q514^fdsx-EQwp!EMU@WoqM_4_Q$|^#3@OJ6!(z<e1
zknSIKr4a-4g_<I<tgaKoZyp=_K<Q2tR@AyKBW#*B@CA$PtqMOiC&+xwi$_K+l=iH&
z4$od{(rBeHxHIfjSbg_sy0mYnT&P`j=u&D@ftk~-sq}Q5iQ}<BAegx==W``@c~$W?
zKdxL4o~NB#DCb|Y_RyLHarAUQ2|js6V?WF##G~y9J8tH~$4)10r&~>{OQp^xm*G3Z
z*{{D{{1}arIc=;D?XT-)<ek|dySkso^-Vi1M&~B_89Nchg$m~kDz^FS8uC26oym8z
zcx|GPo3bpGauwgWfmDQ4&gct7ibVo+<LAQlXBLt6xo44BDR*PuU<f5<jh3kChKz-h
z>#G}dmYeh{eC6qv@8=PuZ&~4oIvaMH#%}JmvINFYTu^MIl&J3>)m|@I`zW-XyTbA&
z!QAp6Xmj+7j^yn%ygQQ=>>w@K>6oZ{3ErH$xgK4huqw?Xeo<->u~4Q%FYjDM`tUh<
zt_VwyrOb<3AG@!<_0MM~{#n6YP&4P|G*9y)DnB9aJD)Z~Q(DKwM}Q^{UG%gA$`3J%
zx!XMIwS#4@`D<{k(W7>(@O8WCFC=QeMfUW+xMkg$)??F^c+o#-mQIJKo$h^n_qZI%
z1&8d4v3Ekd;b+&dueC-rlR8Q=QyqBcx+<FgV#HX^>p)Xeq2C(98wpKfoi++w1K{YI
z(UDQoKv?vJaZ4<K_N3KbR5WxlAZ|x1*IvkuH37ci)ma><(Hl2hP<!&+4eQTCOy9ij
zoZMCBZ(4g+>1P^#Xmw~D3DNAB1Md9E@lyW#=Wq3v{p()y(Esv7Z|OJGk8_jEX9n_$
zlDWOf=Z&`W+rCO>8k$RV+!NBC-TFlRtkeAcwMYCS;k6nOb)pm?_6Dqfwz=!wP>l+!
z#u@LeOA=>a^V~#!sVIh9u?^tZSGsaf9f+GfmlYE&Ym0V!e6&+D2+T}_(wwGqw-_&L
zC>iKh8T(MXZt=P$P3xrIwLz|qtX!qklDkEzj2=i7@=#Wwm*;Go@8=#6zxRxrOp|t>
zbsq+}%qqap2ZGh&D2~1KYXu}CyeA+s1Kl-6WZpf1d!c5fuUMp_gsLWHlt-Z{KeSpj
zrU92rbxq5~LLOxM-+cejyBuOMDAu4dv602i302&>KM@L$=8w5PXiXis@FNkAJWoCf
ziiEd5bzq1z^u<@d>BE6)D1Qp2P+;{#r@gUS@U!RjJ>#<$GTl*vV<CpD%RX;-Z-%Vs
zjJLVN*)9L9PU;>>PS#}=+a*hU(Ijjwd4m0eihC^SdCfi%-D(CrK-;Wm_pL{<BJ$$p
zM0!@uMRrIQszmg8OgFnQXjW|2`GxwoR$CBoa-04{JBV+PgeM@kt~gYH4RQ!sSYi=y
zBC`hh>V)(sc87y+e|+3pQdWH^96LHxl{^)g=XFdx1%0I8rMTx=9crK74WzxR9K{!n
z1&G<cujYnE_UD3#<K%XmHwfo|`QeQYjZ1x=9?nfND=CMD%`1^DYBD($xIB%)DET?C
z7F^7-j)AubLyhwl$W;tS{Gbv@^)WI*sLA!d$FUXy3|X5`)Sj*<R*Qnl6of0Jr7N4o
z^MT#yoj5TWNMrW#v?SmE`qcmK`|I=rVBSg`LQZUdbh(51$Guvp0THuDLzxJG%^#dl
zAYHEOAl74?>R6CR-MVFZp>(1lB#{_I+%JyNaY^bw>$?>HRxk%7IaQZq*)DfejF_bq
zbJIDWp@im=TR5D<bv+BUPhr`DI?`!?poqx+g7$F9)ITdI7lE(&-`VZ;-KGESAPo{o
z)xZJuL+3{&R9asIPHba=xjD6JVHqdm;PrqVwG{#0Qk?6rPPbnB(a!#=(GJy4s4f0&
z%+|$Tons3M<YKHnt!~rLz8KIT3~2~>ow97+ST^O-J8@m9;k!(S`Y^<S0@-%L6psj=
zP|(9Yp*!2Df*A}jJMQ|o`vS%cAStBrq4}BmiC#u|xDKK(C)IjAugiF2SL<#v2Lb(u
z?RV1V6ny*ObY6vk3iwT0l?d_co2sv;1~|3DzXluri(4J~t<>vmmrXK@rNo3OAuI?L
zhpz-B?6=7*digUN*E<W_>${8p1$Ds>EtUrmui&uqw=P4grP?B|X#VevSMUW<i<e`7
zQ<P7zaA>B>9km6jmH5~T<<(@DIWBkIs-EZGl9<+HQ?1nV01o?%q;5p+B`?1MF%Z^X
zkK-B?FRIZzs1Xe%ESfWNYf?P4$fX}ok49J+pdSz(zSB%t1{I-1(a7FW4wS2<+%%iC
zxxBhgeu?RO3GeoU?-jA9EAKI*vkFHazcLdQR1Kjqbp{;Wq?~f=MDBg?YxZY#6z5F4
zv)UkoTyj9(sN1F#x3ExR#NkE6lU2l3_1NkPt^ohv*qIkxy^#;ZEPpRi#5rSP0BsId
zDVAD^`3&jK0Ck4aY;D3?!Xq>CoZZ}>gcH{>GyQ$?x4!0*jClR<hNN*=QeMS?6e~VH
z#PoXFRPDiqI)lq1`yxUI6d3izkneg4-Du;s6G~eJ0MZ#LKm{i{71xAr-3GJP3d2Xp
zGjSjhx-qQ2Ru8yuzIA%N*s$KM>uZA37uTw0C8P7?KNm2=s({*RVXj3j;Pq)Nbudm!
zIaTqQ;|Tvy-6LmZacNHZ;)!kmTYom&N%E?l;*jD=F4bAMt&`;Xpn3uPe`{xcdvjNn
z;&Wjot)h;1C58H!ziCBX9P>@SsVxQ3GEiVeg8?$lR#1pyhJ?Gk1Vs%Fqq`;#t$~lu
zDjG`hzO<@)TTGxD*T7WoLjc1KAeCRcUTWg*Js+f|?5YrRQ`6%P=1vT*r!~|XDst2Y
zB%t%?u_7S$z}d8e3Z1B^xCL~;9O57PHiysi9cJj%FBjfoWT{xBQsv6tlVq#r7Yqs=
zQM26T^)WyrU9zlF4(;g0^%i5nO*Qum=5ZyTlIkH+Jh|W{#7qYoNbyM3RTJV+G_UoM
zPmbuO9Ax8ScxyxSr>*+9Jx?tA^R7Ri9ejUw9e>zKJ6vkYd%Q`33dpH+IP-xb;?`Ob
zEOWWoC@f7nSVyN%Qw%bVrX)gOWq4+TF2j{sI6k>q8@_3Ug!;bGcM~%-Z5&en>^5Kl
z9YQsHrSGx4W)PokEefzmyBrW&IXE_uOQM#DgAUTbZwjk*_gGpBfi+Pg5(mR}Bd%oS
z@#$RA5hd8DuWCcxL_n1kzN_>h$Wbz)06l6CKtam$Fj)XH(!4$SMUt<p%_4!qaABVl
z#$U%9vLDJj-_#vS$T_p5sw{Ya!&<VcomHE<HauVpS%`o0z-BeqdXmTI9+6j`ljN|F
z)~WRHOq1HIV)qQce@vSYlo!Z(!))yQyhxf+Lwj@<Y~e7PeK1+bZPZA={3hl{tj%B3
z0J+k#+-dtQyrPAAeu<MtKD2N<)sPlFRwuHpQt5BKPMu<+U5Tg*Y|PML_?BJbg#-nd
z4`Fps%Fr)CIZKVwNS41&F$L38<gwp)WA>$F0XLsV4u1t5MyphVk*l;&Ak8Kd^B=sK
zwGH26yKUNPX=k>po6?9P4e)t@mt>%{Kwyn_y%TkG>r~vLAu(@%LZvoOXn^B3c<^pw
zAz@dy5xIbAP<3JSBVL|c=(y1_m*kDdrqoT2yQ>^^O!C4_kH4JVGM~L1fj3OleaGk5
zAVR!#{Mu=GJwNAW8_AMwwmmhnn5~8kf_fGgw?3s8T-}Xq^V#ZhEuZSHC&x%C)YxbX
zF)I@bmjb?aJW+d^Ae4~bb|S7*$nC6Sp{v0dmvWQka0xOdLk;CXVnFa=ccL*{7pP=2
z_s;5adoqg}SC$~W=aj<j#1B3xj>mw7I-4;DLk&zSBbX>eRcx(>1W2u<aw?+jRV$;Z
z<`zm#T$MoD>uCqTH>L?P9=<3l2)OCw9)lP@p7V+kS}{TzIx5q^mx<2)?vVy6mhs*M
zd^KCw>7Lo=k}GY!W2dX{q<5tzbh*L&fz*UZj?SUY47B%rY85hCNf5Q+$*deL0Cddz
zRlL1<=j_@HihrJ^)ODG1MK}yYU2uy5Q$iX_Mjz-3{vmSjCx^sQ{c}DzEQuI|;KcZl
z3C;f7@f2;z`7C^{w3o8Wof`@9Hd8DaXQ4?|D&^T`Zjeo?ZeLynag;3@#Z8H@XI?zd
z{Awm$r;O>kHFDBU2q8D;?z4$MIB~1w@^-zclE^(!5ejc#3T8UswQbV+-7Xf0sHWiH
zE-;>7*CrYXw8SCSlPgIr#Zr{9k*bF`Ka72NQY9<Zg+(3bPr^_AbN?n^S12#g&OUFo
zgn}?kUJ5139HgkeO+_Ww@m_I?>*U%m6D;E2|Iv`IlB#59jdT6*pB&_xNcc?$Q6I*7
z@x-!GMJ2q-hE>1CGA*VJCv{pyabklKFEb%IXe*zCYVX=rUYyuXuQrYS)TN@!`Jj-Y
zC%HtrAP2p?-RBFyJTCV%f~>#QNFCppS&3BY>eg`O*U6>XH_1}gLM7}LogBBQPEhwt
z;Mjln_%GsK@~`_Z<tP5AW3fU%)!3bSWl7qZxS6PRBe@lk6Y|>V(P+MxtnXr9`nI~m
zH3#wH>iFsGx*M1jXP8pkDh{Ze8UhsU`T=uP=6{oNnt<&7AAMY!`+`HSF9H0A^XOaj
zZ{FIaze4#8pM~al{@f)eytIBXN;Lo8`5k8Q*dPXRef;?9>crS*ICh-;7BX<O9|gV3
z(7Q#kW2>dibd(_pKVn^;&>wL;B?Gm9oJ!UG>=PT*?u`<L6-Tj3QINI8m9!g{ERkQ?
z+PFHRnK9())~Mv<tCl=B*aV*p0z>HQPg5<r#!MUHN6~a^QPz%|(B9nLNHtW5K8Q`N
zPtz==<D`!9wNuA?s_Ed~yKB$rvG9DMRM|pvEdBL;Kl}L;uE}|`$Cp;*BDNp&CtN+_
zE}us803PdHsLbgo9dW@YVMOt7p|si6Xs{`tXefSFAiNJRM+~Lj*&r?UfCa`<C6gin
z9y`FP&UkEh$M)>ojV*+7^VTbbZMLU2JmcPBBo4+W+}C;Nny1_zbKf7=UMrUhs|rim
zS!G|b<Y1gGonPTMj_KrNEaH4F7OK)I2Q9_L=%?&TVue05big7O{yv2`S(WL<SZ+_<
zLx~^;d!;aQuhxr^yS|Ifa4y@)d91*@7CT1}gFI7Nx#RUj)UMuxUnd<jFfedk`M3Kl
zDBtOR1X*&^C4#kB$m7QlcU_$B;u2(mIvclxTV(%Mf%aXh{GsyN{>~oy2YJZuL?J#E
zvx&=omd5Zpko9cKW|N?dx%xGIWA~GX3h0edbn<M$xvnnIZ7D@Q+`EE#d@Aua|2W-y
z{3B+#S4ei*5cj)hra48Fd_vm)GOK$q?G5wn{qbGPp(v&I^FDhH?7{T(?5{|<`g7dp
zX6pGIt6#Hk%C&0=^VzxYV!uy#I`h*62mVM+N@@XHQeDq?D~_~|e>AmBSyhaZfD}Ke
zqFoX0(`neUzn_NY7xw4pBd~Dts@rTlI0YvD)w_SJy<cXt`m;H*C%h|51zMJtDeKD`
zn*4VVqd$u$ed0T5Gck0<e}Fl_lJ+ug{uKP=h@O~!CGGCEe+P=b@0PMd9T}=G3SRB~
zECOF&iahL=-R8a_RzrGQ8~ANg%PnZjA#kdrhi<>a=ufoyS@!^IAk(^^#quim?9d?F
zXAfPu-6`$vmaTF=xw$Lx9VjaBk*YLV&L@8mmX!17e#~g=_@=Gv+vxyJw_6(0^Sr}D
zi>wgZC_XK<p<!AekcopNeE#)I1E-$TSKDZMai8fZ>d1<4a9$)73FcpnoQ{f*1W!ps
zV!@dxe=8i5wL$ar@<cM23}jQYE}>B4HV6l&6JQZpfF}(X1;JpT0_uM!l9^<0C%FO9
z<Rt!DiH8igSQvqf?^#~lsF0)K8+}p4td72hKj{;GIDawLUJ}OM5Z9%?MvfL;|6_5n
zPmazFj_1cNO2Q=ev5SZE#fv>ps@<zU)uKIokT1;N-kbBnnD4s5zxuIZyWuKk!py+f
z3v++&skzl}))dXonB&!&9c#*#eegv6fuUs!%?V(Cu`?>GV4B_J&CXXJzA#;N0J3^;
z`EQNA)^~R^+xF#kq&a^K>;mf3GMYwzSGH1m_oN>tk2AYhT|p!VP5g%Ske%!MY4?kG
zdS(wG4~}eTQ0h2Yt#we_nq9?L$)#hZ7U#Y@*AylzSw1|x%$tsiSH72NyplF~`P<<>
z@CNq>`+S=LjPEgG`(n1@s{DC>foed-)UH}qV47(g6DPch+!GTUv}Vk*WtMbrwtCLa
zXRp*PG3jm+D={UJjTgn_T#IaJ2-Sg^+2K?Be6K`50<VO(G=)w<@5!fXn{I?pzn7PG
z#EXW?%7#Se0bEHi1jcp54${@;AlW=FVsqL=Vzp)xtg3=usaKydY-s3Jt-H;d?xC(x
zP2Fdyd)#yvS^06*Ri}S{wgE-{qw{uZ@2V07uD8DGxch3{tm*M!*D`T4*wO}y|EH*`
z2IToH*AafcsZ*c0x$cc@@q_u~>phQw1GSf1KM}sPdK($}i#^mEjWOk|)q2k->#<(@
z$W9~cw;Drdwa{@8SMk0LR=Qt?AIDqRnz_^ojI0pZ^mZ$&WU*E8VP<mme<l<P5|b@V
z1j)&K;bH=OlhBvQ6|Pw6S9+r_N@%r)F~O{5w57$sq^?=5r5)T2%mT}=QP;ht)BCei
z*!=H-;X<w(Pv!=<2(~JfSy?#9Jc@C>_GP1^r8guQnUYB9U^c6Gx0XhHj$7-`>x>&1
z?8YCFJc&}-0p?!}5b{E8%_yldR>gb+%aUiKVR$cF7uMfcWA%J}+<L=Hf7T!IVGXMk
zg-TQLqc4@aLPJp-u2$@9X7L4-C)L&_0yC_YdLUsHj$dHFk>)9>ff{~ta-G!pnxmLh
zUwa7_H7T{`qlP65&Ie@@?|^+cHl1!1zv8_jlSA`<D%cl(hAht`_8kSAyhi)MkBP}U
z=`{jvX}ZG%X?R+M0$e<;&<dAXSQIowjIel^vKDS}f*6Z1&*3c!qlP&AW*gWgjOINu
z&xNU~Pb~dr;Nsp=6sm3<eR>*=i#g}#PEr2>-+1N@$HSR5E((gK1dcTKKY>7ek8ph7
zD|?nA=zA?7<Iodfv_=O<-du(2;n{&;_&3Kj$FXM+7V3hjw%CLDAq&SDUWpiXc-A7;
z0jE%Drl-Hi+G5Ir*)igf!ELI*z}h%O9K)8$e#5c5V@T%5xA}bju{S5h;N+(CZHgii
z<blCep<tg8PJxWJLdtQzOvVAdJaW)_E&Z+ax?zp=PSh4g@h+JBpa1Z)&!3Mo&y4bW
zp8UczcyTUi{GjiUFO`=_;wb<SLPCQ~ly9P&@2IbHL4V<pv+r?VS8f8j3IfCsB00_{
zf$ICEuXBEX(a>XdDK4h`$aiRDJ&3ltdHJ2`1PVkkna{d;rY~5nTO%D=OaMBFC@D-h
z^_IG0`&29L*x$dr>}h*Ez~x1T|Nc;()ecp^l$41%jyXPtJBG~T^;fQe;MBFxx@%By
z^4dZFLai2D?$bU2`})8q+P+46wEcBM!%{<NG1Pb$m=A>wY^%n{vHPUz<n0Ll|JiZ4
z27Z$3DG;Ot3Se9ne6v}_s^a3OD%~IP6zD12%S33@+^n+3d*U%Ftp23`k}7aI-U#6C
z>*T)A(7;tg+EOirJINc}V|`GIF}XiIi%rsq5$&8CzBF=aj)ZXBZQ{};K=(1<$&tzB
z?WBIj*Kf2;n!Gf5%WK4VD$2=t&~U@Ly!P0Wc1RN|HjEmwAZKb-q`X+7gIl19_6N5I
z_EUB!d#(Kj^9n)UWG2~3^ZsEp<xV6p4ZLMJ=NHlllppGcZ_uinI1yPGXN+elQfHq8
z`WUz57^m2q29ouuXW)%NQwoO?7`VAvh3dD~Ry!HldD~&J^lMfX&RG0<wHYPF`1VCr
zhpOGGL*0StIM_iTa7mL0A%uf-gM?<)fU4hWKs|sNI5>cSRFlS`KqmIYY2(Nss8iKp
z)v4~pbRO*7Aozvp?UQ~XZO~c*VMrS!EN}*P3keU^Q9fLH(`;}T-%Mxv%ifuaxb0w4
znkKDg@OaZyPIEOWe-&@rWm0EB3uD7-Q)IOv($uhe7jmPIx^82OcXVEL^qGuyC}c9N
zH?i<O*AqA;&7p#)*`{O6CrJIc+})eeg(g~){0{%?0Nr1n>_Kmp?(4iC?9DVXl`e;H
zhfr3DXFPoc29_4Tai|iT8+}iFul*2RQF80wWzX-F?YU+6qUx5eY-_4ab1P^%fx4d^
z6n6Fs2Z){A_V^;27?<_9N92db@T)|w&|HJP1~#AmikRHQqW-A9mUgtCe=`0t&!ot}
zJW#HjSWHM$2A|VZp9xI|l;?u0HKAv~8?rOCwWnk^f%aeGbKx+Dtp9p4FovjjmeDG*
zJb4Q1TwwzxDnQPYsst|%lr9(X74TBW9#IcIS^|{$h0}p=`XSAk;G6j;wjxc&X-G}3
z=N$rT*-9n576?+Nj*O&!Gn$$_@<WtE)_jJw0SAZ`A!?GRu;dCGsDc1+GO1S;jvUB9
zk03`}quWLVIseBWDSIDuRI61ewEdjMPXHo>`}-l9*yXLo*B9B@)!7*lu@EW(?*ask
zT>3t!QoWN{tYq)hHSe?@PVnivDkihpNdR!4RCaQ5gYSB4YGUQpH5!dP_CSq+)zloQ
z#+G7S(jJk?gCK<f9l;YuL3{EKj4C#$cS{2Z0rjb^O~3!%gpkl@5Ud<iER_!H-JXI8
z^o{Sewok99ZrQG@BwBYD+pKq}j@jJl+z5c45?<(Vim1HNdmeb|e>?vDF`uOGg!`Q+
zNDw3?hL6P$vdp{V6h-lER2VTdFic?fAq!pZv(!BI)$V+^S+hLqtb5+0y!^a8zYIi{
z?qa?m#9YYFXT$!~HMcwf(blLSwi!z%<wo~Ub$Q+>7pR`=mjS%z>Tn*)?as^3MP>wX
zpj?~>Kuv+^fUlv`Lj(W`%oJAkkO2T7VNegO)cgeXQ%l@+2|9OGVQ^nSu{u1%YB&A;
z+i}&{$?=n_@%5RG=}W0ja`H~UKD{HI9rp0vUS*nrPTSn%0Y)|~nJgz*mKO}5if5U!
zU{BfujyogGcj{Q1Pa=cnhRf2Tsdk202EQj5njIbtIR3Q84oT}h5?o7D8W>ATr4dA_
zNh#)zV{_9eE$VngWIC<Rx1kl>&&y#2g$4$ZqXzqeU&zNPGj>XAtDm!ICg2v>)}%=C
zi<j5@P-Rs$7$5H=4Z*zXTd`jZt~>Fq0o}{!1vkqx!bNsyd%jiANN(oy?TG(Brzy%}
z%_`)jm%IhX6h*qy<fz?k4Hp|+q?=ZsmV8SBijZ_j4s#m+gy1+|?3roBGDYEjd+*ue
z4uSUeU>6SG3$?cPn>PBoqMX%C&4-pxJLsUfj>#(p*{c05&dt=U;E;n>!S~}s%TfAP
zF2um0dtI`{R>4r6&S7RK91?<ah^Ll|F*4{+ki<}@1X^ae0HPB^Gp|Cz1+>hYBB*09
zRBYvv4c$9~pMhrJ<AZVG5WEa3#?VR=Lm^PPq#P9=`m@kQ9;pBHENWIWCM9`SWizY1
z-1uu9wA?Y?F&UbxGd!B5D(HH0e07Znu0Hvqnk5mPGuL2Ae%dcgPHvo)hyho}pTa^_
zJc%+x79q{ZknoCm7-V{cwY>>1JYsD9<hqI@NipCdAQKRAiaA)lh?wWTx&OkNFoc4n
zzF()b(f$6{WwO(D3iwC(Rcp5GVPR#NuIVB5!Fv+be&&THgRpDeS!{$I9i|G+j+7f_
zUTmy0G$8f;KBbM;Mp%rB)T4(FpEyxia8&bcpJRDD@htlHOTeR^p4MB$bLd|uA06(|
zyJ%aA_Cfl@Hq`QQqTHU|M_|vPd=V~ys9{LSdW*r&EkQxM^uxo<Oo?-1^wwD<q6z=X
zd-Rv#b;ep}3t0Nnc{IEh8<Rofp>WNpG^4p0Nf)sYUOJG5U@;g-YXFC&d9hd|i%y3$
zHG2p&Id-M`ca1N7B(ADT0T`|es|I36Fl)B9G$xxm>rv#kMrALt*hOrn-^lVv(7@1b
zwz0-cZ}Moij#)PabEgCVWcnm}OTEeQa#Yr}Zqkhk#4S+G6I;ro((sh{bRI=vj87$(
z7>aG=b!fIs#@bru%SPL<SKb7`H=bR9<Kg~?a0=WOj%|W23E1q1ZCLziNZ8heg!}#p
z=nrt<sPV#mlLy0F)V#^*u)tZSZ`JF-{=nl$9p<5~>LP^w8Aj-$J+}Djm#_A)ci)uB
zQpt&=ISbBt=ny%TlsE?faPCp^o}N#=cFj)BRojsn?Q?j!Lc7n%N+gwvR-hLpjBeYb
zVYslPwh_+8*_S}JrV^1=NLMoly@0#wSsbFc*V7eM$&$x-PwV7z4Jkc}bn1gHAn*Gx
zfB#hg{{DZy1qWxoo7$?UEGjx33*+)<i`||uDe<rvvvjH^pr|HnO38F$DyPC4+Nq^f
z&6h}+%yYNJ0h@cufXT~hLQfTQ{5Zv@x{9XmlO79``U18+!ra}%k}SAP5?d<2?Il7F
zmgqnPh(V<H#1WESIv`s~El7un{5jlQ{)Fo=vW3`c7O%xmykxq|<%?ylZhD5$N_a4>
z(<)*Q8mene|79*VPr}9GN^lB>*k*N#UxeW#I1<+w3ZOOt8_Q!2lb|Vn9)n#ru1pL|
zBFVywTwHeME)Xq9K}3M)q$XnPi66&FdU;`PhZ2KqCAJu|wJYq<k@v?`xUjb6<5Qx@
z!Ba_8BfdsX4i2O8dPa6r_tkWpe~I6W`CRK_$F!@p71_D$a|q-rxeG_afmsqGHEJX7
zt=Wtj3I^Wp((M9m<ydo%$hOvwxip_?X2)2l<zpm(*p6yO=#)ws2_$Y2f!AT^9OpP^
zg>&{8YNR;`fW8jJc@(^{(<H#;kR)U!u@$+6Y$aAAd%?Ueq?)8-suR>|9Wkft)MOn~
zN9vpUnPzi#UJvu50Qn7%NvBOMu0%k*o3;M+^b$J9IU9Wpo$Z{1R*fxelhASKSV2iA
z_nT@Np>-TUte12+_An5Ugi1z~Ls22}yrvZqT8mgj8)E6++>w~Shk3)^n@gI$sEfNd
zZ(tB6{D46iATS@ogv1x<c0^S{NNlX!$fWFq&OvW+y+*DV&D_rHqpO`n;X^SlA%u`$
z7@O?~<Gocrg@-)Qrl#IbF%Sb6Lx6Ve?Kp268JNM?iT;JWLZydYu{>4|-ZoC@Rzx3#
zlhABzrleE4MSCL)mTrD7N#~|=IH}z9Uo1E{!JqgS<}r}9w#_46%nX>D-l(aWA<O^|
z2;O6#i3pPYgOx+upRIjk#K(k!B>tclNt-cSx=Q--7MU3`yNQ!o*%idv$PjKWy{bAw
zL!ti)xZjh>EmN(V#U4HZ=p1y?EiXT6PB}mRe};KnO5cw<KCu_-BqVa7CI&b=<6Q<O
zE+$M<CjpWnKt;-zoq5n$qew$F&yJ}iHbBV&5*La!z}gvG`C*wRWFb>X?EX7}YYKB}
z!s`Nb{vCn)RrX9QsV?z4cCM6~L5>v&D@EiJD=Q~N<Vt~%981k8ox@&FB-K49u~W**
z9}wn&E@3_{erai*FayjJ9=zX}C%EB7F6eADHI|Cb#>6bl*<17lq6Mjh1P~>XR)p-v
z1=Q(WHycu`(s56+-C<gbL@xi12#|Ij*}wY6=f*3aS2y~WU;Z!LV)fD`rBX-eC(Z+)
zre>Znv#_AUa`tk=_UBsi0{U+xYf3U;<YyGbuP%+2m>S<QvY%`tw%)nZN;vS_Z!_pP
z^yBUOY2GzNKmv#n62$(k2PtPIU3H#up(ci=!9PyO<^2`$fTdOYVM|lE#rY<elj=Qv
zeJf%_wXe4pYoUQYrM{l^NtaFXIYptPQBhU#6#&k^KQi+7=bT-JFsWx;XWdybW%G1>
zp&*9Ak8PahT5_hF5Indsh(dJN(Nl*HpE^nr-B(w`OXG0TN-eldDI3j=A=YEX*m`lk
zBm#S;MNXny9MvzZpR}?<k_A2BI|;~PM#LbZ+_)<tq03m_Lk9zRy4;wwm}qh&(>2U3
zDkXTIPbM!TgO}y=I@8AifUmx00LPgKec_x#dEp2{!CcAVOXT}bOW|Y&CC9mA42HDX
z)l@9N2sQ-R0)GZ2)ktQs>$grba#=E7i*GY4qub@!t<9eU{*16Bf=v1m7KS-ZL`|+1
zhAmt%&9;p5I7bN*1sUHr3n3@@a52a^;}s!X#gXGY%%j6?bB6H?fdv5p1qT8Om3E*|
zp+Z&wj!ZZME)w#h9TP5u2-A)fD}s~k7%)*ohJI_lvHj_sZ30|d_mN<g8?Yt8t=gcz
zyk!?>XEhi0-g)82U)Z}vWAk=7b_qC&<wZ&$d6n9>blXc+ECCzdF&i5{BahMAYEOrT
z4cLmdd}ih;Z@Sa+y{X}^n$&gcOoYojG_l5>X%SccTTcU`7H1eyKV2#Q;S3fE{9{@Q
z<;|!o%A{@?2my!jXtClLjJP}tE|bS<y5mq<CoKxd?`jHYzy;dY+n@RRy|$2=g2Z}V
z>?rJF-k<t-Hw}ulVG@2~c6nWx-x03N=e`U7=Jv(mzwgU<&M|Bga^q=|ZAfc~E#s!@
zcHKorux+bd2x*r|W()*kvAuNh^ow;U1lhhrnj7CXiBydI<$_?T)r)uinZzB9ai`=^
z4htlWx@)dzo}#xtRGg0YibUHmpKNMABA@+A{`DF1WBOwpkzV$<gEQZiETblU8v55?
zValI(Zy^@z0`dpaEqrolL2<_e@b0BHTdng?%J%~gGKdJZbLo)|I!!L8?e4&3cC&x(
zKF%Hby9#-`r*O^aPrrf(>HW%(ebyI%07rC8HBiJU@Rp_rWl}cD<xZt?g(AM30>PUD
zCzX&(NhS{mlDXPn&z<b^H#V9W&hTIPrt?2eA0kta3XLb*7F<&dZDfOGrf%k{;a`~h
z=P}P3o?+(qGk+OY*|}lM2W@4BDXu@aP6~}*H))BT=IRzyIYkjKS2&fD%PE^dnbPzE
z?;=h$;2!qjzhZ|_6E#=18sZj<ko6M|apP+v?2G!15pBu}6R?g~lJ#vk)R&o;EF1ir
zh%NshjYxBk60%0T6%LQ%ICH$*@h*Oyud*m1n^x~xQ)gus!e)f=1I&o8EOnMmmS-%t
z9&{5;x9B8j+VU9y{Omse>XHipzsIe)Am@@%9A#HQW6o-D6g^`ph(Y?dl|%q-^zth-
zC(-$t3v19SO~M|RaI{H60GgJkEqf89G4N?5wApFP@nuQ}jiBezgvzlKL$zO*VFzGO
zp!2(H@9YBr|NrZDx|Sjrr1y>T?7v^?&cM6VGbTdI#3%b-&5N>MUe+NIaCMpeE;5WK
zzJ&qii6w#!(V&kEy6!pTOTyZK{zy#7?|NOHre8qiP`;`@h@KQ?)hK%Z9~44<#LKh*
zb*Kxlhb_vo3~=ljT>|VijD6U~vt#vS(@w@h=3*(o(!voHPM!D0j>}}*-1m^%pv(=i
z{G1x07R&z=2p}&vb?6S1K9z1E<Sl!b!w-4EZPE4rY@@fJN%}uL&cJTlJo9HBLDTpc
z*or=Y93+BAfbVloRC?$%i8LfDB9NnSW`hN6Da!4Li!TwOM5rt%)YYFb(KYp&9#u41
z?m+oQRl&r!!UivmfsXk?gj+KsyV#U4JOZnR&Q6!L>#?tkz>s-NoJ^OXR)lp`x?x=!
zjJWn*EQ#A-F#~kYJ&yxwE1T*X!|WR>7tCML!>3D15m2X2I859oO#s<xBG?1LrV56>
zuF@nZ!Xn}ux^=olU+()RGDw935F8azIil1f<oA1!A|Z>hnW-u@`Xyr^6d!Fvr4KQ>
zy>$%HmjL1eP#mG~22C_qn{W}|;VyekTsG$%1|^YGc{Sv@xm#1~b1lkXtIdsrfXHGF
zn=HPD<w7821m(1@@=S0VF=JCkjBZz5-(7H<6cBYox)q+<aVNwFUmGBFMxxTaHUZtC
zic6rlxZtz1;NxolmOLUmXX<=$_io0gjo2hm4mRAb%hFj^>#ZW9p=ZoE+(_#5_{blY
z?PP-cATJ?gJq*Eil|UaX5S{nPh=O(~C^s}YM6{97DxD(Dw+Xqol~y;mt}F2TZWJ;~
zF#2C_Yf+4yliNM-2|TCd3Pa&^utNSDb?<(C-{a~V5uV;oVo~k4teDQ@KPfN{7w`P_
z3R8*}mAE!(65Deine-em3P056wm}3tXF>Lj4sEI>UEvv~6|`N$`#`*Q*0ohBi#+p%
z$yh>V9KLSpQ(X`#kSdCR#^gwFOFm(w?J(mdG+y-OKs<Gnw^bQOzF-t>IdBfMqqEb`
z-?f$l(;8@`q}MKK87eW6kdg8O02Xla6|=H+z(!wU#V)EPbN31hO%(*yaJB35Y^`59
zGwlt1Rc3A827)4s{R!Hv*x?DwNFQYM%YSX`y)y{8BSHtvlUu5!>?t1*$PEfN^@$8d
z=0pIoBLaI6*bK{<5RVaV&=aT2mJJ{W)bxnaj^b7=I3n_Wp@>G0oZKm3Psx;#G-s3)
zBN@eWneZ8{bsJ;g&}!38gDA8$eBi`xzaIBRh7lA$-miRI{kZ)6^f+Di_v5{-vY{A!
z52ZLU4dyam_T|Fa2S6GJ3*Z8uoGJoSvB{>S?i|+$sjmtN2I7$&bAUAQTpW<V3FF-s
zP)ZAT5#EIbmO+$=gfvPc)8ul}w~jj;<hP^k1M%{4T_v$!1UdI8`6BpD$|eY|n(dNU
z7>in?ora-lfLu!WNQd6Ke!^63i<w@crWeN)21`%(+jymv*3-Q5E%jk)zC!b7wxBc_
z0NlW@&7fjBA*5^(X&aKNhR?`zIKs^PmjTf@{E1}V1+X4A(w`P*!RZ9beE5C`=fYUe
zDvw!<Joh1JzD#+`vVqis@0}K1X*-B1Xi{m61Rer-OC2E|W5Xw`?ms@*-C4}Wqd~9T
zs{5YnScW7pBmt|XVlI(Pq}SKexfCiOFbc{KfQ$pCA-bX>{Q>Goz$N@oUjlOK-lp5Q
zp~u+5FTVoX=Nr(pGF-e%mjmhRI&HPPj<-?UWG{KhuxTxYF7)6C_qc*Ep^XT%6CG2a
z0pB`c?4B6LXVt>ia?9EZUQP`^0Dlc%mt`21-<y_IMV3SXgXr7q%hTh-{WiBvU4_zk
zXwBvu8#qnAswNtr02g52$gIU6Nz7<y0q0!$)R$BdB~3U*8uX><H3#aZ8)FdAde=^2
zJ5Jw)!oHQwl|T}&yKfc25Dk_gYGm!#^yxlbkB9EkUxXZ6hA+=)6Fw(b@#-}3P>+KR
zP+`e0hm0)|+{56;8ALhZF{8S1LuQtx@K1A}>?M331crB26f7H7(l4qGpvl_)JWJ=D
z<f3_OA>mA#XN^QEF*dAG8ZvDYp86f7IwMV%MUfDU4GzaVosLa!V!F1jG8rxMD2*nu
z2=5d4j8jT&j8Pya2mX2p%sF%c&%4G+7vhqOFD$R1DE>Jl+dbvMbgdinG2Ep&kCXJ$
zw2W22e+c5mFB&I*ON^28;l;XE77Z3X7f}->*v`>epIf*<8%R*~i|?1cO}O4Zjg)F%
zhu=G3V+FMJg#5Xh!u4*fFCK%w%pF<snm?MJE%RyJNVn``j@HuVttw$0!zqeK*OZq8
z7=2YBn*Z8a&c?$*w^jEoT@)x%#MEa{o-U`Z`9GNWN39e8w<Y<(K!p_6yYi+n$zu^U
z$r5(+Z!NypS54QhY?PFx$Gjkv4=@vG3yfW=&2dpJk)kiJB&{I0hPOT<vFh{FSlw#f
zq{PUkCr<yD-j2l5VZdG_JeNyY7Nn>zwj_LR6;>gZpBn)z=h9d6Y>_`E3!$c0wz(R+
zSwD_vo*G`-bXDJU?Kqk+)xCXqiO=-3;oOvQI3lV|DQ^>C=H)a{!|9@0M$P;UV<r9q
z^Er4TzeufCDrGV+F92w6YHT=IUsroTQ&X+pZ(6FVtSB#0?cGyUSdgEWo0FZDsoZT2
zmXV&Cl9&*uh?U3a5HnO30&g-nNFo;S``Bc9F(68(0iN9IXkm~{!JqCHpeM7u0d|Ss
zJ6JpKTP+RBxFMWgIsrFz;A9Rbc@vh}*qHnKGXdLiTKiJ#h0x!hc(5GB6)&`EOZ^>m
ziL>U!Efvz`bQ*@eUaJ)Zj$;^#vfMS%o$cu&I-iA;=y=o{MhE>?H`-|j&1j?U_)*U_
z?5JfbdVr>iHI^X>h<3m|>0~;y&OqsdAqVa}Q1c3vXLbZ%X%<8ZkK`4%ott{1g@hHv
zro$=gvgLFa6ZSK23T86#{9cxXKI`1>w|4Eiwi4P3^$KXU^vjR|lXt#pMP1YnB#0%M
zaDa{xMsN!mdxEhkl7V`4ZL{ai{H?uq4X82@hFopM)m#tMSStq$U;zgO2^K>HK_p~(
z&=(GhEDrIO&)kHXP&OATPStBIWa5~ysR%JfoBo88(<M?5a&JbDam~w-vh=_4ORA8f
zRM*QYT1~?$hLV1uA1&z`Km$|2p`1LMUSTKPe`%jrOYW?fD<`R7+8SPY>8Hr$f|u6h
z*iD1sY6%V!6kIjtM8Fs6zACe`V%vRmzP7;$3==+sl_plRsULqfXygK!c6!aA*@9-C
z1nG*VG)I$)-UOSJSr)KhjCV#U!fjHfT<RPQ$wgOWmiDA|1#ISYMYj$IiQTgW?&Z=1
zH<g4N;LZ0)0vc>%S-Kk8%ncJg4OX(@DjW8R<QdVh{3_kb2TerH<j{9bU6lra#6WWd
zKLR6{|5E*bq9bcH`}71|o11Y-o_MGEr$)%umT^AXqgqpsH%Q51Tu2YJ(ad8NY9t?L
zMQ`tE@o+*>$T$}cyL~N5-98iN+iE$uTBM7)cyVO-`0=jJ*4C=Z^78Dg^z`VcurPl=
zF4xt?$;rwRfdGN$NfU5s;?&sig^}~ePndu&hWZY74t5=D?JxoDZS@B#TdJDN)n>bW
z6?+P@%Cbw<i7zoON*SFN76}0n;S!-=sDB98*97?R=$<Yd6urBZjoGfQ;($rF7@fTa
zVb0n6B%C?A0)PUJCQ+5G<6?^=DF!>yTF;*2WE5I90h*^x&^rd)R@C)qq5K#fRB>1h
zNWF>a+L960s_H`Hdb9%Gao)rON!%z#lRQTrn9{#AeEa!R%tU~;XF<v%0MNl@EnUnf
zn-nTUCk-Ta8o<4U;AU|=pN5{%M^21r`CseEw^y9DSaP-yx3Q5UC;F^U4vzMiX`l*w
zZIh7#@2iQ!(HHIj@bm3kRVrHe7)a5<gF6sQe0PQ_QgIlyIU<th!!Y|nJ`aEXzV54X
zGW1<)THKj}CjWQ{vh82Y>hnEM9pA9n05XoS@FtRHOq$b_IHbA=T{n%UGJ32O+c{u-
zU!hnw12VFwZ+cxrSYjEP!X-teaXAaQCR-EJ)EF7rS~o`b@N-?g?O&2Y1sURO7KH4!
z`LBR*tAppRljoMxwKv3(9S1iHBts6^va1OSgONvgJQh{ngSpSDK*yx>=hCbucUS?1
z4tnwCmcn_@Sg#<UcHv{r70%C1^S&u%76-mkit?6@#P)P8%p*1-l{Y}gIY`N*+Ca&X
zOH?ZZeT_?1MB@U@s8FJk5uRgu758`v`}&(>YOAVlRXwxP)E@Pu2Mp?%sSt>a(4he8
zj@{xi!cmo*0Uj{FuEhjZxr5{yL>g)O7^~T#WkCvTI4s`>aXE@fPv}UDfM9_FXN7=R
z$Qka$6NOmQ@Ji+iZv)}k?`%NBcQm!TChnScM$W$g_X11KoHXBXh_^u-wrtv(Tv6M?
zwjA&^7<d|WUP+Nv*nks7q--fgE|DS^JqZxMtPNch7+N6h@p{<zhL+^U%F-a9TS;wp
z^VSN(Cwni<!oa%_b8tR}QGgUkBT-zm37v8T-Fb(xYx=PyFq~HCbJtE}Gdqm<h)}Ni
z<K+10V0S)o8-cg)*{WRQIhLVGto%4n^GN9E%27_d5B>SOWI1q45dg3B0^x$D{%;AY
z*h+xj(_rwkYS|nGuT>du4e#g{xbAT_1qo@Xx$gNKgYs8j7r-GFl30aEln>H&+WzIV
zAKF^xN$gL-6jFmRbNRD4ab=#aVamUHJarWvas!V{Bj|hn-!W21s^#uAt;nqY-2`zZ
zTa*=DH?{w}B(GDqsm4-SCq6JQ^P2);6>0Sj)|S@`u<phiWzBz1=nV<P-@hM^`rSt0
z*t#n4bjXA_EIrQC`Pen`!;KH0$HF7n@nLuxcINeTy2P%rEDM##o(HICSxz)R3?p9G
zD0p!d{)GpXa!WQz6yb6X7e^!#?w*qhrL1Slf%wrjVP-uw=Mp#<<P1{wRfRk0VV~Vi
zo2=n3*|~(rVPks~?W<J`9K6^l3`d`54~0JvSz{Mk4b1>p%-(6PdIC55SY~RQFaY8g
zCzyzfrKf4hEYU+Vwqu?Jby!;t55ZD~|9SNXL1kz~=8KGrFG`$%CVWx|P1Laf<_x$=
zWu&<kXX(49okHEi)mO80^C<<z+QnZ4G+)WG{;#gAr>PtZ(M)P%9f>>T^zu4>$1+t{
zb47twIE5ro1~R35s+y^Clh}9iT3%)^>T{PM+qvQ)SYAcWy7+xLMOY^sLb|#lgOhPZ
zBA8GC{*4uCm_8sHdJZ4S<e)>$GZW2}B0oF~k1(|KC{OY3<$1n#b$ZN?zPH<`#$uB-
zV63bGEFs>BtlBLCECrz`EUyf&oHTVIA=3$$*)At6u?Akgb?z+{7~1zYVd~!5fpPxo
zF|@r67w??)3VF~*7wvTl!YsNg`gtz>HMx|06$8;Mky^x*frNQKn@=Q4+EHAEQurrQ
zlD#5HHr3TckPMn=qq(N-w#i(<d<89mnizZgp<5}W#~`JGBh`eG?qH$&`14aK>+($(
zVPVV;i&y--&lRv*dtmBYg(QTyjjtXRM|F6PkVzSRdwx0{S?mwqd;H#Qf_9NvC52=O
zgI(|(R4=wksX4Z+i2PfbOXOls?C^J@J2yA($c6Rkk+Setls+c?drchzx^Q$kQn>la
zn#~Fj<ANfvDYilI#zo%<X_}=G!}gqJtI<l^LUexrQXN&L6lJj)NB<3ddu*kKdJpfT
z=4>I`e1X}^oNA(D4Ac^IZ$74gQi`qP;afoQtDo8vqHzDyR<ltLd|e^1;=}&8$Zv1@
zt|bkrbFWrKNklTW!bfbyXrqM8&~C5}IyoyKiR3t2MRhgjrU%7~hcb&oZx92)jtj>r
zj#5-e<zTu^dQ8<DU#hy@w36CFgclE!aEd8tlK|W*&Zt%aq}z`+g;SlFD{aXQiTcm(
z7J0yNMpE0Q<>|R}p=-o$P8Ok2c(MoFZRfbzI>`3^`fwq$u>Z1&HIjQD+Is2Xyw^=!
zTw|xR>OY+9<F_;qtI3jDbxToc8EHPstCn`8gd$4E{=;M?+eYH*=gIDLcjYfDe{#$N
z&)H0yhS0I=E;abF269dk>9a#H|6NbNpF4MLDWh;z?6!P4#l@?;P&Ypk*>wn;@Gpy#
z^*kD{bk^Mj_ef_yB6H><d7>bi5|hWxeCN2MhdgE%9j^vU!B6uCXz-)BzKw6jHD4Xp
zY3y@?oIn|2dGZdQ0f}?a@|SPl4lDBCf9l)l%XHRFd?7M@xTj9xUEAz*T<;3rBw3<W
zhc}GmbXt|i^~++T1mfG@7l+Hkjel(XU97F99@7br!P)@vY`o25-+nTs<$M+Adu~rT
z6~9(>4JyMj2-77G((WClIgfX71jL({-Q3Tzh}yW_B|HMFeg9#wuJ1zR6lTK5Rv?)U
zCh{&WDz4QMuG~lrTfrh`qljM%nIVFQ+lazpRlSXP8*Z$G>ky~mye7n2H#vzkv=F*2
zO|}^`B_Fe09>q<}7t%MfKwK;UCr&b2+=-Vwj^*aVzQ_az;@9ulmL~J2VA2%E;aufu
zUUEy~yq^x!>|e7e<f%w^Aq;0QF0I<RBQt3HgB!^C9AxR(*%*fduLqKcr`eNe_Q=pt
z=io+Yv7%Pvx^~36>qsxNS$~}X0Z-6Ad0zYM@AzU9Gd8mw0ye^t*{r!wGiyGtmZ0XW
zRPYLuepbP;)-drIS9t;A{wH<cu?<ZYxjx?~@bV{>PqLFI2l%v%pq+1W;1hTm2W$x3
ze2kqHX<`jd4ZA(Z`e4Nu_R>D@MOP@H_0dWa7<=m=&jPGNPRtr+#3_<IQK!oB7Eows
z7(h5WjW;gjx=EUFwq4I_me8}0%>Vq;Ut&t#u65r+Pm%n(SH$+JCZ^y46vJ06vf+vu
z)|l4scXX78A|{tK^>~rFqSYy*u9SShD(BS#tX$7qf?!VlG47MJAwLsw0J!zgIIn~R
zJAnSht@o}J70_BQ5X*J~;*TFRyrQ2$@se{1AT$yDER&XCzO*-Nyzqs#bVO`113}<_
zZ#?y*2kyJ)t~+kKz)@CUc$@jV^y^;p5}h*hlMW5k=@bHs_`5WXf(iwXH_d|<hUSQb
z8V{W=b`+4lv;#3@aETd&WMar`xQFGV%5=1fh%PxL4s{9!#XHxB{m}nPkIhmy4cEqh
zEkNk>5<vD!-Sp3cbR86-Q-bgz7WCf)(K1*_RfS;mz1v=|!@c@N7D+67D0a--QXySp
z!hZBdgdgvNzleVYUAMvk;K?<Jd<n+XtF7XV7RMdWLZat?hU9-vU?1)N{XoGQFY#vV
z)<Xpf<Ne<id3^t+&Spkk-p?K(f7`U3;pC!O)M@Uso3t(Y_#-rkZI4AARM-C~`T|nw
z-*;-QQilWEq{$4^iHJr*fWP0?f%g9T1L_~DnpJxS2jPA*F#C2-s*wh*SA3Wvw$R;`
z$Z(?DVvz*2qnR-f4~tJE8vp^ix9jD%lG4KOlP#dn1AxD+Y#JWXf7r(!2?J0DB!FQl
z0BZ_zVgbD(OS`uCmlKI*fFs_PFhE*pbSc|amVZK4x|VVzyZlgqM8~wtKDRX-AP>f^
zYI$Fr%^7jzpHFtlhV%Zj;#>4~Fun5EI(n(6M8KyX+;Gaoo9Y4oqeTCP>{LjysUW%F
zCZ{nS51^;vj3k?)TMFtwSv?w|qcv$9-Rp}F&a9M}^IgW3V0x<%RIVCCyyq;|KQzxL
z`$u~JcZPCigsTG7e~L$_{+8}S&sVazqjiJ;e(<kX0O4?Rpml++r$8V)5TEu6IKWbG
z02Z*#Qm*reW$3)_EdU<y!iv!OS#K4XQ0S}ynWLsfmx1ZJSN~*s1(1gBl|TrRnSq^5
zrl3>OYXW8a?`KA!^Y6XFPG7u=G}r&*jo2byt;DiSA`pEU0f<BDF2aF8l6Jtc>>ou&
z-AE1@N3xI{$y6L064ChbE}TQ&-GgCrZ*Ks%k)oYVgnmdyirB@wSpves(y<*QL!mt@
zUS`;<EuR#hS!!gRBCM%}0r$vU+Y|xWezOt^*)A|Rvq8Y-8P+ed>6MS_4$91na^I1N
zP`Yxg<%jmgb7|X=?P-ZwoOq&)vTxmrgs8X?%m5H$N?VCcPyPI^1J05e5XwMNWk<2+
zw1QT-uwp4@<AHT^N_5Aty}>MsnZ4V@+$pWc;FABW7M+r0Mb&h}wAmd_mm5Y<jLX9b
zzCb7vOQbTnf>f&18m&%muy=5Da&~bwn#^wQ9z1&T?8U1$?^s}P1QLbDU~zag0+B?f
zP-%1qlf~w6d3=GohNhObj;@}*fuYdI*u>P#+`=*!?>n4F7R&zp{C<c0%S9vy9KjiI
zM4G^5Nd=IGaU|i1ua<^s5dC3Gz|xbk7X)fy%~U#70LP1DO!Y!XU&KqASBQOvLzoRI
z$(t|?=Zyi)q$q_1M`R0JV<Ds<1d#BN%f*BuQr2(?O@YgvEE>k6%k!Qj>%~9<Ux+Um
z8M2KdKm{!wv}3U*K%7}|PQ@S*C~&#qvUh2Pns60VTO&4;5rTea3ULp15{~f`BU4*c
zcFed^_zH=cRm>FNijU+AWcR3M`zIF1>+E=&+W@XmlpWrkrr{CoL;${O4<Jhh6=72V
z1u>L_uBD(z1I)ujGua!1JIobNFM8)Yo^u8VX_<@bX?!w(!!$gT{>FBxgyR{oKQQhG
ziWHPBe%>RRcq&|uWi<=V%9>2t2hkW+7oVyIz4LyB_92jmw%3={&64)t+M*+{5);^+
z(C-;h1Shx@aHS|j1ZRD+GR?3k(za>ARr`-_j_4~?0v)01f!aFdG8U*pIX#sW%`TyW
zJln@O8ysO*aE(5ZKHY^WgDfE{lQP^H^6WSptIGZ1N{i@Qw>i8>s{+$v@H9-rmNJ~c
ztdP(u2K%%*Wus7VKg0<%MVdiXoDa7<P+SkKg;qn}lcl}(7;$eLF%oTj^QXBN5kKj(
z2-dUId4cW^xoBy)s(95OqDU5DXp$1;FN1Cl_nvoeUgy!3Flv3<QJ!ep`?D`i(eZ0v
fPsFOF|MRVtq!s*v8UF_VN7!SM*!yN)ktojr%b(~F

diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
index 1bcb4068..ba8edab9 100644
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.js
@@ -1,30 +1,435 @@
-import React, {useState} from 'react';
+import React, {useEffect, useState} from 'react';
 import classes from './EasyOrder.module.css'
-import {useTranslation} from "react-i18next";
-import AccordionBox from "../../../../../../components/AccordionBox/AccordionBox";
-import EasySellOrder from "./components/EasySellOrder/EasySellOrder";
-import EasyOrderNew from "./components/EasyOrder/EasyOrderNew";
+import {Trans, useTranslation} from "react-i18next";
+import {useDispatch, useSelector} from "react-redux";
+import {useGetUserAccount} from "../../../../../../queries/hooks/useGetUserAccount";
+import {BN, parsePriceString} from "../../../../../../utils/utils";
+import {useOrderBook} from "../../../../../../queries";
+import {toast} from "react-hot-toast";
+import {createOrder} from "js-api-client";
+import {setLastTransaction} from "../../../../../../store/actions/auth";
+import {images} from "../../../../../../assets/images";
+import TextInput from "../../../../../../components/TextInput/TextInput";
+import Icon from "../../../../../../components/Icon/Icon";
+import NumberInput from "../../../../../../components/NumberInput/NumberInput";
+import Button from "../../../../../../components/Button/Button";
 
 const EasyOrder = () => {
+
     const {t} = useTranslation();
-    const [activeTab, setActiveTab] = useState(0);
+    const dispatch = useDispatch();
+    const {data: userAccount} = useGetUserAccount()
+    const [isLoading, setIsLoading] = useState(false)
+    const isLogin = useSelector((state) => state.auth.isLogin)
 
-    const data = [
-        {id: 1, title: t("buy"), body: <EasyOrderNew/>},
-        {id: 2, title: t("sell"), body: <EasySellOrder/>},
-    ];
+    const symbols = useSelector((state) => state.exchange.symbols)
 
-    return (
-        <div className={`container card-bg card-border my-2 ${classes.container} width-30`}>
-            <AccordionBox
-                title={<div className={`width-100 row jc-between ai-center`}>
-                    <span>{t("orders.title")}</span>
-                </div>}
-                safari={classes.safariFlexSize}
-                content={data}
-                activeTab={activeTab}
-                setActiveTab={setActiveTab}
+    const [alert, setAlert] = useState({
+        submit: false,
+        reqAmount: null,
+        totalPrice: null,
+    });
+
+    const [order, setOrder] = useState({
+        tradeFee: new BN(0),
+        stopLimit: false,
+        stopMarket: false,
+        stopPrice: new BN(0),
+        reqAmount: new BN(0),
+        pricePerUnit: new BN(0),
+        totalPrice: new BN(0),
+    });
+
+    const handleAvailableAssets = () => {
+        const availableAssets = [];
+        for (const symbol of symbols) {
+            if (!availableAssets.includes(symbol.baseAsset)) availableAssets.push(symbol.baseAsset)
+            if (!availableAssets.includes(symbol.quoteAsset)) availableAssets.push(symbol.quoteAsset)
+        }
+        return availableAssets;
+    }
+
+    const handleAvailableDest = (buy) => {
+        const dest = []
+        for (const symbol of symbols) {
+            if (symbol.baseAsset === buy) dest.push(symbol.quoteAsset)
+            if (symbol.quoteAsset === buy) dest.push(symbol.baseAsset)
+        }
+        return dest
+    }
+
+    const findPair = (buy, sell) => symbols?.find(s => ((s?.baseAsset === buy) && (s?.quoteAsset === sell)) || ((s?.baseAsset === sell) && (s?.quoteAsset === buy)))
+
+    const [selected, setSelected] = useState({
+        buy: symbols[0].baseAsset,
+        sell: symbols[0].quoteAsset,
+        pair: findPair(symbols[0].baseAsset, symbols[0].quoteAsset),
+        type: "ask"
+    })
+
+    const reversePair = () => {
+
+        setSelected({
+            ...selected,
+            buy: selected?.sell,
+            sell: selected?.buy,
+            type: selected?.type ==="ask" ? "bid" : "ask"
+        })
+
+    }
+
+    const [options, setOptions] = useState({
+            buy: handleAvailableAssets(),
+            sell: handleAvailableDest(handleAvailableAssets()[0]),
+        }
+    )
+
+    const {data: orderBook} = useOrderBook(selected.pair.symbol)
+
+    const bestPriceHandler = () => {
+        let bestPrice = 0;
+        if (orderBook && selected.type === "ask" && orderBook["asks"].length) {
+            bestPrice = orderBook["asks"][0][0]
+        }
+        if (orderBook && selected.type === "bid" && orderBook["bids"].length) {
+            bestPrice = orderBook["bids"][0][0];
+        }
+        setOrder({
+            ...order,
+            pricePerUnit: new BN(bestPrice)
+        })
+    }
+    useEffect(() => {
+        bestPriceHandler()
+    }, [orderBook, selected])
+
+
+    const buyPriceHandler = (value) => {
+        let newAlert = null
+        value = parsePriceString(value);
+        const reqAmount = new BN(value);
+        let range = "baseRange"
+        if (selected.type === "bid") range = "quoteRange"
+        if (reqAmount.isZero() && reqAmount.isLessThan(selected.pair[range].min)) {
+            newAlert = <Trans
+                i18nKey="orders.minOrder"
+                values={{
+                    min: selected.pair[range].min?.toString(),
+                    currency: t("currency." + selected.buy),
+                }}
+            />
+
+        }
+
+        if (reqAmount.isGreaterThan(selected.pair[range].max)) {
+            newAlert = <Trans
+                i18nKey="orders.maxOrder"
+                values={{
+                    max: selected.pair[range].max?.toLocaleString(),
+                    currency: t("currency." + selected.buy),
+                }}
+            />
+        }
+
+        if (!reqAmount.mod(selected.pair[range].step).isZero()) {
+            newAlert = <Trans
+                i18nKey="orders.divisibility"
+                values={{mod: selected.pair[range].step.toString()}}
+            />
+        }
+        setAlert({...alert, reqAmount: newAlert});
+
+        const price = selected.type === "ask" ? reqAmount.multipliedBy(order.pricePerUnit) : reqAmount.multipliedBy(order.pricePerUnit.pow(-1));
+        setOrder({
+            ...order,
+            reqAmount,
+            totalPrice: price,
+        });
+
+    };
+    const totalPriceHandler = (value) => {
+        let newAlert = null
+        value = parsePriceString(value);
+        const totalPrice = new BN(value);
+        let range = "quoteRange"
+        if (selected.type === "bid") range = "baseRange"
+
+        if (totalPrice.isZero() && totalPrice.isLessThan(selected.pair[range].min)) {
+            newAlert = <Trans
+                i18nKey="orders.minOrder"
+                values={{
+                    min: selected.pair[range].min?.toString(),
+                    currency: t("currency." + selected.sell),
+                }}
+            />
+
+        }
+
+        if (totalPrice.isGreaterThan(selected.pair[range].max)) {
+            newAlert = <Trans
+                i18nKey="orders.maxOrder"
+                values={{
+                    max: selected.pair[range].max?.toLocaleString(),
+                    currency: t("currency." + selected.sell),
+                }}
             />
+        }
+
+        if (!totalPrice.mod(selected.pair[range].step).isZero()) {
+            newAlert = <Trans
+                i18nKey="orders.divisibility"
+                values={{mod: selected.pair[range].step.toString()}}
+            />
+        }
+        setAlert({...alert, totalPrice: newAlert});
+
+        const reqAmount = selected.type === "ask" ? totalPrice.dividedBy(order.pricePerUnit) : totalPrice.dividedBy(order.pricePerUnit.pow(-1));
+        setOrder({
+            ...order,
+            totalPrice: totalPrice,
+            reqAmount
+        });
+    };
+
+    const fillBuyByWallet = () => {
+        if (order.pricePerUnit.isEqualTo(0)) return toast.error(t("orders.hasNoOffer"));
+        let totalPrice = new BN(userAccount?.wallets[selected?.sell]?.free);
+        let reqAmount = totalPrice.dividedBy(order.pricePerUnit)
+        if (!reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step).isZero()) {
+            reqAmount = reqAmount.minus(reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step));
+        }
+        buyPriceHandler(
+            reqAmount.toFormat(),
+            "reqAmount",
+        );
+
+    };
+
+    const submit = () => {
+        if (!isLogin) return
+        if (isLoading) return
+
+        setIsLoading(true)
+        const newOrder = {...order}
+        if (selected.type === "bid") {
+            newOrder.reqAmount = order.totalPrice.decimalPlaces(selected.pair?.baseAssetPrecision)
+        }
+        createOrder(selected.pair?.symbol, selected.type === "ask" ? "BUY" : "SELL", newOrder)
+            .then((res) => {
+                setOrder({
+                    tradeFee: new BN(0),
+                    stopLimit: false,
+                    stopMarket: false,
+                    stopPrice: new BN(0),
+                    reqAmount: new BN(0),
+                    pricePerUnit: new BN(0),
+                    totalPrice: new BN(0),
+                })
+                toast.success(<Trans
+                    i18nKey="orders.success"
+                    values={{
+                        base: t("currency." + selected.pair?.baseAsset),
+                        quote: t("currency." + selected.pair?.quoteAsset),
+                        type: t("buy"),
+                        reqAmount: order.reqAmount,
+                        pricePerUnit: order.pricePerUnit,
+                    }}
+                />);
+                dispatch(setLastTransaction(res.data.transactTime))
+            }).catch(() => {
+            toast.error(t("orders.error"));
+            setAlert({
+                ...alert, submit: true
+            })
+        }).finally(() => {
+            setIsLoading(false)
+        })
+    }
+
+    const submitButtonTextHandler = () => {
+        if (isLoading) return <img className={`${classes.thisLoading}`} src={images.linearLoading} alt="linearLoading"/>
+        if (isLogin) return t("buy")
+        return t("pleaseLogin")
+    }
+
+
+    const isAllowed = ({floatValue}) => {
+        return floatValue < 10 ** 12;
+    }
+
+    const buyOnChangeHandler = (e) => {
+        const newBuy = e.value;
+        const sellOptions = handleAvailableDest(newBuy)
+
+        setOptions({
+            ...options,
+            "sell": sellOptions,
+        })
+        const sell = sellOptions.includes(selected.sell) ? selected.sell : sellOptions[0];
+        const pair = findPair(newBuy, sell)
+        setSelected({
+            buy: newBuy,
+            sell,
+            pair,
+            type: newBuy === pair.baseAsset ? "ask" : "bid"
+        })
+        setOrder({
+            tradeFee: new BN(0),
+            stopLimit: false,
+            stopMarket: false,
+            stopPrice: new BN(0),
+            reqAmount: new BN(0),
+            pricePerUnit: new BN(0),
+            totalPrice: new BN(0),
+        })
+    }
+    const sellOnChangeHandler = (e) => {
+        const newSell = e.value;
+        const pair = findPair(selected.buy, newSell)
+        setSelected({
+            ...selected,
+            sell: newSell,
+            pair,
+            type: selected.buy === pair.baseAsset ? "ask" : "bid"
+        })
+        setOrder({
+            tradeFee: new BN(0),
+            stopLimit: false,
+            stopMarket: false,
+            stopPrice: new BN(0),
+            reqAmount: new BN(0),
+            pricePerUnit: new BN(0),
+            totalPrice: new BN(0),
+        })
+    }
+    const showBestPrice = () => {
+        if (order.pricePerUnit.isZero()) return 0
+        if (selected.type === "ask") return order.pricePerUnit.toFormat()
+        return new BN(1).dividedBy(order.pricePerUnit).decimalPlaces(selected.pair?.baseAssetPrecision).toFormat()
+    }
+
+    useEffect(() => {
+        if (order.totalPrice.isGreaterThan(userAccount?.wallets[selected?.sell]?.free)) {
+            return setAlert({
+                ...alert,
+                totalPrice: t('orders.notEnoughBalance')
+            })
+        }
+        return setAlert({
+            ...alert,
+            totalPrice: null
+        })
+    }, [order.totalPrice])
+
+
+    return (
+        <div className={`container card-bg card-border ${classes.container} width-30 column jc-start ai-center`}>
+
+            <div className={`${classes.header} card-header-bg row jc-between ai-center px-2 py-3 width-100 fs-02`}>
+                <span>{t("MarketTitle.easyTrading")}</span>
+
+            </div>
+
+            <div className={`width-100 column jc-between ai-center py-2 ${classes.content}`} >
+                <TextInput
+                    select={true}
+                    placeholder={t('TransactionHistory.coin')}
+                    options={options?.buy.map((o) => {
+                            return {
+                                value: o,
+                                label: <div className={`row jc-start ai-center`}>
+                                    <div className={`${classes.avatar}`}
+                                         style={{backgroundImage: `url("${images[o]}")`}}
+                                    />
+                                    <span className={`mr-1`}>{t('currency.' + o)}</span>
+                                </div>
+                            }
+                        }
+                    )}
+                    lead={t("buy")}
+                    type="select"
+                    value={{
+                        value: selected?.buy,
+                        label: t('currency.' + selected?.buy),
+                    }}
+                    onchange={buyOnChangeHandler}
+                    customClass={`width-90 ${classes.thisInput} mb-1`}
+                />
+
+                <div className={`row width-80 jc-between fs-0-9`}>
+                    <p>{t("MarketInfo.lastPrice")}{" "} {t("currency." + selected?.buy)}:</p>
+                    <span>{showBestPrice()}{" "}{t("currency." + selected?.sell)}</span>
+                </div>
+
+                <div className={`width-86 flex jc-center ai-center my-3`}>
+                    <Icon
+                        iconName="icon-exchange-arrow flex fs-04"
+                        customClass={`cursor-pointer hover-text`}
+                        onClick={()=>reversePair()}
+                    />
+                </div>
+
+                <TextInput
+                    select={true}
+                    placeholder={t('TransactionHistory.coin')}
+                    options={options?.sell.map((o) => {
+                            return {
+                                value: o,
+                                label: <div className={`row jc-start ai-center`}>
+
+                                    <div className={`${classes.avatar}`}
+                                         style={{backgroundImage: `url("${images[o]}")`}}
+                                    />
+                                    <span className={`mr-1`}>{t('currency.' + o)}</span>
+                                </div>
+                            }
+                        }
+                    )}
+                    lead={t("with")}
+                    type="select"
+                    value={{
+                        value: selected?.sell,
+                        label: selected?.sell ? t('currency.' + selected?.sell) : t("PersonalizationForm.placeholder"),
+                    }}
+                    onchange={sellOnChangeHandler}
+                    customClass={`width-90 ${classes.thisInput} my-1`}
+                />
+
+                <div className={`row width-80 jc-between fs-0-9 cursor-pointer`}>
+                    <p>{t("orders.availableAmount")}:{" "}</p>
+                    <span
+                        onClick={fillBuyByWallet}>{new BN(userAccount?.wallets[selected?.sell]?.free || 0).toFormat()}{" "}{t("currency." + selected?.sell)}</span>
+                </div>
+
+                <NumberInput
+                    lead={t("orders.amount")}
+                    after={t("currency." + selected.buy)}
+                    value={order.reqAmount.toFormat()}
+                    maxDecimal={selected.type === "ask" ? selected.pair?.baseAssetPrecision : selected.pair?.quoteAssetPrecision}
+                    onchange={(e) => buyPriceHandler(e.target.value)}
+                    alert={alert.reqAmount}
+                    customClass={`width-90 mb-1 mt-5`}
+                    isAllowed={isAllowed}
+                />
+                <NumberInput
+                    lead={t("orders.totalPrice")}
+                    value={order?.totalPrice?.toFormat(selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision)}
+                    maxDecimal={selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision}
+                    after={t("currency." + selected.sell)}
+                    onchange={(e) => totalPriceHandler(e.target.value)}
+                    alert={alert.totalPrice}
+                    customClass={`width-90 my-1`}
+                    isAllowed={isAllowed}
+                />
+
+                <Button
+                    buttonClass={`${classes.thisButton} ${classes.buyOrder} ${isLoading ? "cursor-not-allowed" : "cursor-pointer"} flex jc-center ai-center mt-4`}
+                    type="submit"
+                    onClick={submit}
+                    disabled={alert.reqAmount || order.reqAmount.isZero() || order.pricePerUnit.isZero() || !isLogin || alert.totalPrice}
+                    buttonTitle={submitButtonTextHandler()}
+                />
+            </div>
         </div>
     );
 };
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
index c8f1414e..0427ec00 100644
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
+++ b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/EasyOrder.module.css
@@ -1,8 +1,12 @@
 .container {
-    min-height: 78vh;
+
     margin: 5vh auto;
 }
 
+.content {
+    min-height: 68vh;
+}
+
 
 .thisInput :global(.lead) {
     width: 30%;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
deleted file mode 100644
index d102e37d..00000000
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.js
+++ /dev/null
@@ -1,448 +0,0 @@
-import React, {useEffect, useState} from 'react';
-import classes from '../../EasyOrder.module.css';
-import {Trans, useTranslation} from "react-i18next";
-import {useDispatch, useSelector} from "react-redux";
-import {useGetUserAccount} from "../../../../../../../../queries/hooks/useGetUserAccount";
-import {BN, parsePriceString} from "../../../../../../../../utils/utils";
-import {toast} from "react-hot-toast";
-import {useOrderBook} from "../../../../../../../../queries";
-import TextInput from "../../../../../../../../components/TextInput/TextInput";
-import NumberInput from "../../../../../../../../components/NumberInput/NumberInput";
-import {createOrder} from "js-api-client";
-import {setLastTransaction} from "../../../../../../../../store/actions/auth";
-import {images} from "../../../../../../../../assets/images";
-import Button from "../../../../../../../../components/Button/Button";
-
-const EasyBuyOrder = () => {
-
-    const {t} = useTranslation();
-    const dispatch = useDispatch();
-    const symbols = useSelector((state) => state.exchange.symbols)
-
-    const {data: userAccount} = useGetUserAccount()
-    const [isLoading, setIsLoading] = useState(false)
-
-    const tradeFee = useSelector((state) => state.auth.tradeFee)
-    const isLogin = useSelector((state) => state.auth.isLogin)
-
-    const [pairConfig, setPairConfig] = useState({
-        "baseAssetPrecision": 0,
-        "quoteAssetPrecision": 0,
-    })
-
-    const [bestBuyPrice, setBestBuyPrice] = useState(new BN(0))
-
-    const [selected, setSelected] = useState({
-        "base": null,
-        "quote": null,
-    })
-    const [options, setOptions] = useState({
-        "base": [],
-        "quote": [],
-    })
-
-    const {data} = useOrderBook(selected?.base + selected?.quote)
-
-    useEffect(() => {
-        if (data?.asks?.length > 0 ) {
-            setBestBuyPrice(new BN (data?.asks[0][0]))
-        }
-
-    }, [data]);
-
-    const quote = userAccount?.wallets[selected?.quote]?.free || 0;
-
-    const [alert, setAlert] = useState({
-        submit: false,
-        reqAmount: null,
-        totalPrice: null,
-    });
-
-    const [order, setOrder] = useState({
-        tradeFee: new BN(0),
-        stopLimit: false,
-        stopMarket: false,
-        stopPrice: new BN(0),
-        reqAmount: new BN(0),
-        pricePerUnit: new BN(0),
-        totalPrice: new BN(0),
-    });
-
-    const currentSymbolHandler = (base , quote) => {
-        const currentSymbol = symbols?.find(s => (s?.baseAsset === base) && (s?.quoteAsset === quote))
-        setPairConfig(currentSymbol)
-    }
-
-    const availableQuote = (baseAsset) => {
-
-        const quoteAssets = [];
-        for (const symbol of symbols) {
-            if(symbol.baseAsset === baseAsset){
-                quoteAssets.push(symbol.quoteAsset)
-            }
-        }
-        return quoteAssets
-    }
-
-    useEffect(() => {
-        const baseAssets = [];
-        for (const symbol of symbols) {
-            if (symbol.symbol.toUpperCase().includes("NLN")) continue
-            if (!baseAssets.includes(symbol.baseAsset)) {
-                baseAssets.push(symbol.baseAsset)
-            }
-        }
-        const quoteOptions = availableQuote(baseAssets[0])
-        setOptions({
-            "base": baseAssets,
-            "quote": quoteOptions,
-        })
-        setSelected({
-            "base": baseAssets[0],
-            "quote": quoteOptions[0],
-        })
-        currentSymbolHandler(baseAssets[0],quoteOptions[0])
-    }, []);
-
-    useEffect(() => {
-        if (alert?.submit) {
-            setAlert({
-                ...alert, submit: false
-            })
-        }
-    }, [order])
-
-    useEffect(() => {
-        setOrder({
-            tradeFee: new BN(0),
-            stopLimit: false,
-            stopMarket: false,
-            stopPrice: new BN(0),
-            reqAmount: new BN(0),
-            pricePerUnit: new BN(0),
-            totalPrice: new BN(0),
-        })
-        setAlert({
-            submit: false,
-            reqAmount: null,
-            totalPrice: null,
-        })
-    }, [selected])
-
-    const currencyValidator = (key, val, rule) => {
-        if (!val.isZero() && val.isLessThan(rule.min)) {
-            return setAlert({
-                ...alert,
-                [key]: (
-                    <Trans
-                        i18nKey="orders.minOrder"
-                        values={{
-                            min: pairConfig?.baseRange?.min?.toString(),
-                            currency: t("currency." + pairConfig?.baseAsset),
-                        }}
-                    />
-                ),
-            });
-        }
-        if (val.isGreaterThan(rule.max)) {
-            return setAlert({
-                ...alert,
-                [key]: (
-                    <Trans
-                        i18nKey="orders.maxOrder"
-                        values={{
-                            max: pairConfig?.baseRange?.max?.toLocaleString(),
-                            currency: t("currency." + pairConfig?.baseAsset),
-                        }}
-                    />
-                ),
-            });
-        }
-        if (!val.mod(rule.step).isZero()) {
-            return setAlert({
-                ...alert,
-                [key]: (<Trans
-                    i18nKey="orders.divisibility"
-                    values={{mod: rule.step.toString()}}
-                />)
-            })
-        }
-        return setAlert({...alert, [key]: null});
-    };
-
-    const buyPriceHandler = (value, key) => {
-        value = parsePriceString(value);
-        switch (key) {
-            case "reqAmount":
-                const reqAmount = new BN(value);
-                currencyValidator("reqAmount", reqAmount, pairConfig?.baseRange);
-                setOrder({
-                    ...order,
-                    reqAmount,
-                    totalPrice: reqAmount.multipliedBy(order?.pricePerUnit).decimalPlaces(pairConfig?.quoteAssetPrecision),
-                    tradeFee: reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
-                });
-                break;
-            case "pricePerUnit":
-                const pricePerUnit = new BN(value);
-                setOrder({
-                    ...order,
-                    pricePerUnit: pricePerUnit,
-                    totalPrice: pricePerUnit.multipliedBy(order.reqAmount).decimalPlaces(pairConfig?.quoteAssetPrecision),
-                    tradeFee: order.reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
-                });
-                break;
-            case "totalPrice":
-                const totalPrice = new BN(value);
-                const req = totalPrice.dividedBy(order.pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision);
-                setOrder({
-                    ...order,
-                    reqAmount: req.isFinite() ? req : new BN(0),
-                    totalPrice,
-                    tradeFee: req.isFinite() ? req.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision) : new BN(0),
-                });
-                currencyValidator("reqAmount", req, pairConfig?.baseRange);
-                break;
-            default:
-        }
-    };
-
-    useEffect(() => {
-        if (order.totalPrice.isGreaterThan(quote)) {
-            return setAlert({
-                ...alert,
-                totalPrice: t('orders.notEnoughBalance')
-            })
-        }
-        return setAlert({
-            ...alert,
-            totalPrice: null
-        })
-    }, [order.totalPrice]);
-
-    useEffect(() => {
-        setOrder((prevState) => ({
-            ...order,
-            tradeFee: prevState.totalPrice.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
-        }));
-    }, [tradeFee]);
-
-    const fillBuyByWallet = () => {
-        if (bestBuyPrice.isEqualTo(0)) return toast.error(t("orders.hasNoOffer"));
-        if (order.pricePerUnit.isEqualTo(0)) {
-            const pricePerUnit = new BN(bestBuyPrice)
-            let totalPrice = new BN(quote);
-            let reqAmount = totalPrice.dividedBy(pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision)
-            if (!reqAmount.mod(pairConfig?.baseRange.step).isZero()) {
-                reqAmount = reqAmount?.minus(reqAmount.mod(pairConfig?.baseRange.step));
-                totalPrice = reqAmount.multipliedBy(pricePerUnit);
-            }
-            setOrder({
-                ...order,
-                reqAmount,
-                pricePerUnit,
-                totalPrice,
-                tradeFee: reqAmount.multipliedBy(tradeFee[pairConfig?.quoteAsset]).decimalPlaces(pairConfig?.baseAssetPrecision),
-            });
-        } else {
-            let totalPrice = new BN(quote);
-            let reqAmount = totalPrice.dividedBy(order.pricePerUnit).decimalPlaces(pairConfig?.baseAssetPrecision)
-            if (!reqAmount.mod(pairConfig?.baseRange.step).isZero()) {
-                reqAmount = reqAmount?.minus(reqAmount.mod(pairConfig?.baseRange.step));
-            }
-            buyPriceHandler(
-                reqAmount.toFormat(),
-                "reqAmount",
-            );
-        }
-    };
-
-    const fillBuyByBestPrice = () => {
-        buyPriceHandler(
-            bestBuyPrice?.toString(),
-            "pricePerUnit",
-        );
-    };
-
-    useEffect(() => {
-        fillBuyByBestPrice()
-    }, [bestBuyPrice]);
-
-
-    const submit = () => {
-        if (!isLogin) {
-            return false
-        }
-        if (isLoading) {
-            return false
-        }
-        setIsLoading(true)
-        createOrder(pairConfig?.symbol, "BUY", order)
-            .then((res) => {
-                setOrder({
-                    tradeFee: new BN(0),
-                    stopLimit: false,
-                    stopMarket: false,
-                    stopPrice: new BN(0),
-                    reqAmount: new BN(0),
-                    pricePerUnit: new BN(0),
-                    totalPrice: new BN(0),
-                })
-                toast.success(<Trans
-                    i18nKey="orders.success"
-                    values={{
-                        base: t("currency." + pairConfig?.baseAsset),
-                        quote: t("currency." + pairConfig?.quoteAsset),
-                        type: t("buy"),
-                        reqAmount: order.reqAmount,
-                        pricePerUnit: order.pricePerUnit,
-                    }}
-                />);
-                dispatch(setLastTransaction(res.data.transactTime))
-            }).catch(() => {
-            toast.error(t("orders.error"));
-            setAlert({
-                ...alert, submit: true
-            })
-        }).finally(() => {
-            setIsLoading(false)
-        })
-    }
-
-    const submitButtonTextHandler = () => {
-        if (isLoading) return <img className={`${classes.thisLoading}`} src={images.linearLoading} alt="linearLoading"/>
-
-        if (isLogin) return t("buy")
-
-        return t("pleaseLogin")
-    }
-
-    const isAllowed = ({floatValue}) => {
-        return floatValue < 10 ** 12;
-    }
-
-    const baseOnChangeHandler = (e) => {
-        const newBase = e.value;
-        const quoteOptions = availableQuote(newBase)
-
-        currentSymbolHandler(newBase, quoteOptions.includes(selected.quote) ? selected.quote : quoteOptions[0])
-
-        setOptions({
-            ...options,
-            "quote": quoteOptions,
-        })
-        setSelected({
-            base: newBase,
-            "quote": quoteOptions.includes(selected.quote) ? selected.quote : quoteOptions[0],
-        })
-    }
-
-
-    return (
-        <div className={`height-100 column jc-between ai-center py-2`}>
-            <TextInput
-                select={true}
-                placeholder={t('TransactionHistory.coin')}
-                options={options?.base.map((o)=>{return {
-                    value: o,
-                    label: <div className={`row jc-start ai-center`}>
-
-                        <div className={`${classes.avatar}`}
-                             style={{backgroundImage: `url("${images[o] }")`}}
-                        />
-                        <span className={`mr-1`}>{t('currency.'+ o)}</span>
-                    </div>
-                    }}
-                )}
-                lead={t("buy")}
-                type="select"
-                value={{
-                    value: selected?.base,
-                    label:  t('currency.'+ selected?.base),
-                }}
-                onchange={baseOnChangeHandler}
-                customClass={`width-90 ${classes.thisInput} mb-1`}
-            />
-
-            <div className={`row width-80 jc-between fs-0-9`}>
-                <p>{t("MarketInfo.lastPrice")}:{" "}</p>
-                <span>{new BN(bestBuyPrice).toFormat()}{" "}{t("currency." + pairConfig?.quoteAsset)}</span>
-            </div>
-
-            <TextInput
-                select={true}
-                placeholder={t('TransactionHistory.coin')}
-                options={options?.quote.map((o)=>{return { value: o,
-                    label: <div className={`row jc-start ai-center`}>
-
-                        <div className={`${classes.avatar}`}
-                             style={{backgroundImage: `url("${images[o] }")`}}
-                        />
-                        <span className={`mr-1`}>{t('currency.'+ o)}</span>
-                    </div>
-                    }}
-                )}
-                lead={t("with")}
-                type="select"
-                value={{
-                    value: selected?.quote,
-                    label:  selected?.quote ? t('currency.'+ selected?.quote) : t("PersonalizationForm.placeholder"),
-                }}
-                onchange={(e) => setSelected({...selected, quote: e.value})}
-                customClass={`width-90 ${classes.thisInput} my-1`}
-            />
-
-            <div className={`row width-80 jc-between fs-0-9 cursor-pointer`} onClick={() => {fillBuyByWallet()}}>
-                <p>{t("orders.availableAmount")}:{" "}</p>
-                <span>{new BN(quote).toFormat()}{" "}{t("currency." + pairConfig?.quoteAsset)}</span>
-            </div>
-
-            <span className={`my-2`}/>
-
-            <NumberInput
-                lead={t("orders.amount")}
-                after={t("currency." + selected.base)}
-                value={order.reqAmount.toFormat()}
-                maxDecimal={pairConfig?.baseAssetPrecision}
-                onchange={(e) => buyPriceHandler(e.target.value, "reqAmount")}
-                alert={alert.reqAmount}
-                customClass={`width-90 my-1`}
-                isAllowed={isAllowed}
-            />
-
-            <NumberInput
-                lead={t("orders.totalPrice")}
-                value={order?.totalPrice?.toFormat()}
-                maxDecimal={pairConfig?.quoteAssetPrecision}
-                after={t("currency." + selected.quote)}
-                onchange={(e) => buyPriceHandler(e.target.value, "totalPrice")}
-                alert={alert.totalPrice}
-                customClass={`width-90 my-1`}
-                isAllowed={isAllowed}
-            />
-
-            <div className="width-80 column jc-start fs-0-9 my-2">
-                <p>
-                    {t("orders.tradeFee")}:{" "}
-                    {order?.tradeFee?.toFormat()}{" "}
-                    {t("currency." + selected.base)}
-                </p>
-                <p>
-                    {t("orders.getAmount")}:{" "}
-                    {order?.reqAmount?.minus(order?.tradeFee).decimalPlaces(pairConfig?.baseAssetPrecision).toFormat()}{" "}
-                    {t("currency." + selected.base)}
-                </p>
-            </div>
-
-            <Button
-                buttonClass={`${classes.thisButton} ${classes.buyOrder} ${isLoading ? "cursor-not-allowed" : "cursor-pointer"} flex jc-center ai-center`}
-                type="submit"
-                onClick={submit}
-                disabled={alert.reqAmount || order.reqAmount.isZero() || order.pricePerUnit.isZero() || !isLogin || alert.totalPrice}
-                buttonTitle={submitButtonTextHandler()}
-            />
-        </div>
-    );
-};
-
-export default EasyBuyOrder;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyBuyOrder/EasyBuyOrder.module.css
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyBuyOrder.module.css
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js
deleted file mode 100644
index 26befb6e..00000000
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasyOrder/EasyOrderNew.js
+++ /dev/null
@@ -1,411 +0,0 @@
-import React, {useEffect, useState} from 'react';
-import classes from '../../EasyOrder.module.css';
-import {Trans, useTranslation} from "react-i18next";
-import {useDispatch, useSelector} from "react-redux";
-import {useGetUserAccount} from "../../../../../../../../queries/hooks/useGetUserAccount";
-import {BN, parsePriceString} from "../../../../../../../../utils/utils";
-import {toast} from "react-hot-toast";
-import {useOrderBook} from "../../../../../../../../queries";
-import TextInput from "../../../../../../../../components/TextInput/TextInput";
-import NumberInput from "../../../../../../../../components/NumberInput/NumberInput";
-import {createOrder} from "js-api-client";
-import {setLastTransaction} from "../../../../../../../../store/actions/auth";
-import {images} from "../../../../../../../../assets/images";
-import Button from "../../../../../../../../components/Button/Button";
-
-const EasyOrderNew = () => {
-
-    const {t} = useTranslation();
-    const dispatch = useDispatch();
-    const {data: userAccount} = useGetUserAccount()
-    const [isLoading, setIsLoading] = useState(false)
-    const isLogin = useSelector((state) => state.auth.isLogin)
-
-    const symbols = useSelector((state) => state.exchange.symbols)
-
-    const [alert, setAlert] = useState({
-        submit: false,
-        reqAmount: null,
-        totalPrice: null,
-    });
-
-    const [order, setOrder] = useState({
-        tradeFee: new BN(0),
-        stopLimit: false,
-        stopMarket: false,
-        stopPrice: new BN(0),
-        reqAmount: new BN(0),
-        pricePerUnit: new BN(0),
-        totalPrice: new BN(0),
-    });
-
-    const handleAvailableAssets = () => {
-        const availableAssets = [];
-        for (const symbol of symbols) {
-            if (!availableAssets.includes(symbol.baseAsset)) availableAssets.push(symbol.baseAsset)
-            if (!availableAssets.includes(symbol.quoteAsset)) availableAssets.push(symbol.quoteAsset)
-        }
-        return availableAssets;
-    }
-
-    const handleAvailableDest = (buy) => {
-        const dest = []
-        for (const symbol of symbols) {
-            if (symbol.baseAsset === buy) dest.push(symbol.quoteAsset)
-            if (symbol.quoteAsset === buy) dest.push(symbol.baseAsset)
-        }
-        return dest
-    }
-
-    const findPair = (buy, sell) => symbols?.find(s => ((s?.baseAsset === buy) && (s?.quoteAsset === sell)) || ((s?.baseAsset === sell) && (s?.quoteAsset === buy)))
-
-    const [selected, setSelected] = useState({
-        buy: symbols[0].baseAsset,
-        sell: symbols[0].quoteAsset,
-        pair: findPair(symbols[0].baseAsset, symbols[0].quoteAsset),
-        type: "ask"
-    })
-
-    const [options, setOptions] = useState({
-            buy: handleAvailableAssets(),
-            sell: handleAvailableDest(handleAvailableAssets()[0]),
-        }
-    )
-
-    const {data: orderBook} = useOrderBook(selected.pair.symbol)
-
-    const bestPriceHandler = () => {
-        let bestPrice = 0;
-        if (orderBook && selected.type === "ask" && orderBook["asks"].length) {
-            bestPrice = orderBook["asks"][0][0]
-        }
-        if (orderBook && selected.type === "bid" && orderBook["bids"].length) {
-            bestPrice = orderBook["bids"][0][0];
-        }
-        setOrder({
-            ...order,
-            pricePerUnit: new BN(bestPrice)
-        })
-    }
-    useEffect(() => {
-        bestPriceHandler()
-    }, [orderBook, selected])
-
-
-    const buyPriceHandler = (value) => {
-        let newAlert = null
-        value = parsePriceString(value);
-        const reqAmount = new BN(value);
-        let range = "baseRange"
-        if (selected.type === "bid") range = "quoteRange"
-        if (reqAmount.isZero() && reqAmount.isLessThan(selected.pair[range].min)) {
-            newAlert = <Trans
-                i18nKey="orders.minOrder"
-                values={{
-                    min: selected.pair[range].min?.toString(),
-                    currency: t("currency." + selected.buy),
-                }}
-            />
-
-        }
-
-        if (reqAmount.isGreaterThan(selected.pair[range].max)) {
-            newAlert = <Trans
-                i18nKey="orders.maxOrder"
-                values={{
-                    max: selected.pair[range].max?.toLocaleString(),
-                    currency: t("currency." + selected.buy),
-                }}
-            />
-        }
-
-        if (!reqAmount.mod(selected.pair[range].step).isZero()) {
-            newAlert = <Trans
-                i18nKey="orders.divisibility"
-                values={{mod: selected.pair[range].step.toString()}}
-            />
-        }
-        setAlert({...alert, reqAmount: newAlert});
-
-        const price = selected.type === "ask" ? reqAmount.multipliedBy(order.pricePerUnit) : reqAmount.multipliedBy(order.pricePerUnit.pow(-1));
-        setOrder({
-            ...order,
-            reqAmount,
-            totalPrice: price,
-        });
-
-    };
-    const totalPriceHandler = (value) => {
-        let newAlert = null
-        value = parsePriceString(value);
-        const totalPrice = new BN(value);
-        let range = "quoteRange"
-        if (selected.type === "bid") range = "baseRange"
-
-        if (totalPrice.isZero() && totalPrice.isLessThan(selected.pair[range].min)) {
-            newAlert = <Trans
-                i18nKey="orders.minOrder"
-                values={{
-                    min: selected.pair[range].min?.toString(),
-                    currency: t("currency." + selected.sell),
-                }}
-            />
-
-        }
-
-        if (totalPrice.isGreaterThan(selected.pair[range].max)) {
-            newAlert = <Trans
-                i18nKey="orders.maxOrder"
-                values={{
-                    max: selected.pair[range].max?.toLocaleString(),
-                    currency: t("currency." + selected.sell),
-                }}
-            />
-        }
-
-        if (!totalPrice.mod(selected.pair[range].step).isZero()) {
-            newAlert = <Trans
-                i18nKey="orders.divisibility"
-                values={{mod: selected.pair[range].step.toString()}}
-            />
-        }
-        setAlert({...alert, totalPrice: newAlert});
-
-        const reqAmount = selected.type === "ask" ? totalPrice.dividedBy(order.pricePerUnit) : totalPrice.dividedBy(order.pricePerUnit.pow(-1));
-        setOrder({
-            ...order,
-            totalPrice: totalPrice,
-            reqAmount
-        });
-    };
-
-    const fillBuyByWallet = () => {
-        if (order.pricePerUnit.isEqualTo(0)) return toast.error(t("orders.hasNoOffer"));
-        let totalPrice = new BN(userAccount?.wallets[selected?.sell]?.free);
-        let reqAmount = totalPrice.dividedBy(order.pricePerUnit)
-        if (!reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step).isZero()) {
-            reqAmount = reqAmount.minus(reqAmount.mod(selected.pair?.[selected.type === "ask" ? "baseRange" : "quoteRange"].step));
-        }
-        console.log(reqAmount.toFormat())
-        buyPriceHandler(
-            reqAmount.toFormat(),
-            "reqAmount",
-        );
-
-    };
-
-    const submit = () => {
-        if (!isLogin) return
-        if (isLoading) return
-
-        setIsLoading(true)
-        const newOrder = {...order}
-        if (selected.type === "bid") {
-            newOrder.reqAmount = order.totalPrice.decimalPlaces(selected.pair?.baseAssetPrecision)
-        }
-        createOrder(selected.pair?.symbol, selected.type === "ask" ? "BUY" : "SELL", newOrder)
-            .then((res) => {
-                setOrder({
-                    tradeFee: new BN(0),
-                    stopLimit: false,
-                    stopMarket: false,
-                    stopPrice: new BN(0),
-                    reqAmount: new BN(0),
-                    pricePerUnit: new BN(0),
-                    totalPrice: new BN(0),
-                })
-                toast.success(<Trans
-                    i18nKey="orders.success"
-                    values={{
-                        base: t("currency." + selected.pair?.baseAsset),
-                        quote: t("currency." + selected.pair?.quoteAsset),
-                        type: t("buy"),
-                        reqAmount: order.reqAmount,
-                        pricePerUnit: order.pricePerUnit,
-                    }}
-                />);
-                dispatch(setLastTransaction(res.data.transactTime))
-            }).catch(() => {
-            toast.error(t("orders.error"));
-            setAlert({
-                ...alert, submit: true
-            })
-        }).finally(() => {
-            setIsLoading(false)
-        })
-    }
-
-    const submitButtonTextHandler = () => {
-        if (isLoading) return <img className={`${classes.thisLoading}`} src={images.linearLoading} alt="linearLoading"/>
-        if (isLogin) return t("buy")
-        return t("pleaseLogin")
-    }
-
-
-    const isAllowed = ({floatValue}) => {
-        return floatValue < 10 ** 12;
-    }
-
-    const buyOnChangeHandler = (e) => {
-        const newBuy = e.value;
-        const sellOptions = handleAvailableDest(newBuy)
-
-        setOptions({
-            ...options,
-            "sell": sellOptions,
-        })
-        const sell = sellOptions.includes(selected.sell) ? selected.sell : sellOptions[0];
-        const pair = findPair(newBuy, sell)
-        setSelected({
-            buy: newBuy,
-            sell,
-            pair,
-            type: newBuy === pair.baseAsset ? "ask" : "bid"
-        })
-        setOrder({
-            tradeFee: new BN(0),
-            stopLimit: false,
-            stopMarket: false,
-            stopPrice: new BN(0),
-            reqAmount: new BN(0),
-            pricePerUnit: new BN(0),
-            totalPrice: new BN(0),
-        })
-    }
-    const sellOnChangeHandler = (e) => {
-        const newSell = e.value;
-        const pair = findPair(selected.buy, newSell)
-        setSelected({
-            ...selected,
-            sell: newSell,
-            pair,
-            type: selected.buy === pair.baseAsset ? "ask" : "bid"
-        })
-        setOrder({
-            tradeFee: new BN(0),
-            stopLimit: false,
-            stopMarket: false,
-            stopPrice: new BN(0),
-            reqAmount: new BN(0),
-            pricePerUnit: new BN(0),
-            totalPrice: new BN(0),
-        })
-    }
-    const showBestPrice = () => {
-        if (order.pricePerUnit.isZero()) return 0
-        if (selected.type === "ask") return order.pricePerUnit.toFormat()
-        return new BN(1).dividedBy(order.pricePerUnit).decimalPlaces(selected.pair?.baseAssetPrecision).toFormat()
-    }
-
-    useEffect(() => {
-        if (order.totalPrice.isGreaterThan(userAccount?.wallets[selected?.sell]?.free)) {
-            return setAlert({
-                ...alert,
-                totalPrice: t('orders.notEnoughBalance')
-            })
-        }
-        return setAlert({
-            ...alert,
-            totalPrice: null
-        })
-    }, [order.totalPrice])
-
-    return (
-        <div className={`height-100 column jc-between ai-center py-2`}>
-            <TextInput
-                select={true}
-                placeholder={t('TransactionHistory.coin')}
-                options={options?.buy.map((o) => {
-                        return {
-                            value: o,
-                            label: <div className={`row jc-start ai-center`}>
-                                <div className={`${classes.avatar}`}
-                                     style={{backgroundImage: `url("${images[o]}")`}}
-                                />
-                                <span className={`mr-1`}>{t('currency.' + o)}</span>
-                            </div>
-                        }
-                    }
-                )}
-                lead={t("buy")}
-                type="select"
-                value={{
-                    value: selected?.buy,
-                    label: t('currency.' + selected?.buy),
-                }}
-                onchange={buyOnChangeHandler}
-                customClass={`width-90 ${classes.thisInput} mb-1`}
-            />
-
-            <div className={`row width-80 jc-between fs-0-9`}>
-                <p>{t("MarketInfo.lastPrice")}:{" "}</p>
-                <span>{showBestPrice()}{" "}{t("currency." + selected?.sell)}</span>
-            </div>
-
-            <TextInput
-                select={true}
-                placeholder={t('TransactionHistory.coin')}
-                options={options?.sell.map((o) => {
-                        return {
-                            value: o,
-                            label: <div className={`row jc-start ai-center`}>
-
-                                <div className={`${classes.avatar}`}
-                                     style={{backgroundImage: `url("${images[o]}")`}}
-                                />
-                                <span className={`mr-1`}>{t('currency.' + o)}</span>
-                            </div>
-                        }
-                    }
-                )}
-                lead={t("with")}
-                type="select"
-                value={{
-                    value: selected?.sell,
-                    label: selected?.sell ? t('currency.' + selected?.sell) : t("PersonalizationForm.placeholder"),
-                }}
-                onchange={sellOnChangeHandler}
-                customClass={`width-90 ${classes.thisInput} my-1`}
-            />
-
-            <div className={`row width-80 jc-between fs-0-9 cursor-pointer`}>
-                <p>{t("orders.availableAmount")}:{" "}</p>
-                <span
-                    onClick={fillBuyByWallet}>{new BN(userAccount?.wallets[selected?.sell]?.free || 0).toFormat()}{" "}{t("currency." + selected?.sell)}</span>
-            </div>
-
-            <span className={`my-2`}/>
-
-            <NumberInput
-                lead={t("orders.amount")}
-                after={t("currency." + selected.buy)}
-                value={order.reqAmount.toFormat()}
-                maxDecimal={selected.type === "ask" ? selected.pair?.baseAssetPrecision : selected.pair?.quoteAssetPrecision}
-                onchange={(e) => buyPriceHandler(e.target.value)}
-                alert={alert.reqAmount}
-                customClass={`width-90 my-1`}
-                isAllowed={isAllowed}
-            />
-            <NumberInput
-                lead={t("orders.totalPrice")}
-                value={order?.totalPrice?.toFormat(selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision)}
-                maxDecimal={selected.type === "ask" ? selected.pair?.quoteAssetPrecision : selected.pair?.baseAssetPrecision}
-                after={t("currency." + selected.sell)}
-                onchange={(e) => totalPriceHandler(e.target.value)}
-                alert={alert.totalPrice}
-                customClass={`width-90 my-1`}
-                isAllowed={isAllowed}
-            />
-
-            <Button
-                buttonClass={`${classes.thisButton} ${classes.buyOrder} ${isLoading ? "cursor-not-allowed" : "cursor-pointer"} flex jc-center ai-center`}
-                type="submit"
-                onClick={submit}
-                disabled={alert.reqAmount || order.reqAmount.isZero() || order.pricePerUnit.isZero() || !isLogin || alert.totalPrice}
-                buttonTitle={submitButtonTextHandler()}
-            />
-        </div>
-    );
-};
-
-export default EasyOrderNew;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
deleted file mode 100644
index 25cc1484..00000000
--- a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import React from 'react';
-import classes from './EasySellOrder.module.css';
-
-const EasySellOrder = () => {
-    return (
-        <div>
-
-        </div>
-    );
-};
-
-export default EasySellOrder;
diff --git a/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css b/src/main/Browser/Pages/EasyTrading/components/EasyOrder/components/EasySellOrder/EasySellOrder.module.css
deleted file mode 100644
index e69de29b..00000000

From d17a06efe3373430d77a711b2ee2d9c2a9ba5c98 Mon Sep 17 00:00:00 2001
From: Hossein <hossein13785ab@gmail.com>
Date: Wed, 1 Nov 2023 17:28:12 +0330
Subject: [PATCH 4/4] #175: Fix translation file

---
 public/assets/locales/en/translation.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/public/assets/locales/en/translation.json b/public/assets/locales/en/translation.json
index 4457b2fb..78e57963 100644
--- a/public/assets/locales/en/translation.json
+++ b/public/assets/locales/en/translation.json
@@ -49,10 +49,10 @@
   "noTx": "There is no transaction!",
   "close": "Close",
   "unit": "Unit",
-  "with": "With",
   "from": "from",
   "row": "Row",
   "until": "until",
+  "with": "With",
   "withPrice": "with price",
   "description": "Description",
   "first": "First",