From 6561e75aa2fb03c77544da3c090ad6ea2883d29a Mon Sep 17 00:00:00 2001 From: Dan Date: Tue, 14 Nov 2017 12:34:23 -0330 Subject: Add old-ui directory --- old-ui/.gitignore | 66 + old-ui/app/account-detail.js | 291 ++ old-ui/app/accounts/import/index.js | 101 + old-ui/app/accounts/import/json.js | 100 + old-ui/app/accounts/import/private-key.js | 67 + old-ui/app/accounts/import/seed.js | 30 + old-ui/app/actions.js | 1128 ++++ old-ui/app/add-token.js | 238 + old-ui/app/app.js | 680 +++ old-ui/app/components/account-dropdowns.js | 320 ++ old-ui/app/components/account-export.js | 132 + old-ui/app/components/account-panel.js | 86 + old-ui/app/components/balance.js | 89 + old-ui/app/components/binary-renderer.js | 46 + old-ui/app/components/bn-as-decimal-input.js | 181 + old-ui/app/components/buy-button-subview.js | 261 + old-ui/app/components/coinbase-form.js | 63 + old-ui/app/components/copyButton.js | 59 + old-ui/app/components/copyable.js | 46 + old-ui/app/components/custom-radio-list.js | 60 + old-ui/app/components/dropdown.js | 98 + old-ui/app/components/editable-label.js | 57 + old-ui/app/components/ens-input.js | 170 + old-ui/app/components/eth-balance.js | 89 + old-ui/app/components/fiat-value.js | 64 + old-ui/app/components/hex-as-decimal-input.js | 154 + old-ui/app/components/identicon.js | 74 + old-ui/app/components/loading.js | 45 + old-ui/app/components/mascot.js | 59 + old-ui/app/components/menu-droppo.js | 132 + old-ui/app/components/mini-account-panel.js | 74 + old-ui/app/components/network.js | 129 + old-ui/app/components/notice.js | 132 + old-ui/app/components/pending-msg-details.js | 50 + old-ui/app/components/pending-msg.js | 70 + .../app/components/pending-personal-msg-details.js | 60 + old-ui/app/components/pending-personal-msg.js | 47 + old-ui/app/components/pending-tx.js | 500 ++ old-ui/app/components/pending-typed-msg-details.js | 59 + old-ui/app/components/pending-typed-msg.js | 46 + old-ui/app/components/qr-code.js | 79 + old-ui/app/components/range-slider.js | 58 + old-ui/app/components/shapeshift-form.js | 308 ++ old-ui/app/components/shift-list-item.js | 204 + old-ui/app/components/tab-bar.js | 37 + old-ui/app/components/template.js | 18 + old-ui/app/components/token-cell.js | 72 + old-ui/app/components/token-list.js | 207 + old-ui/app/components/tooltip.js | 22 + .../app/components/transaction-list-item-icon.js | 68 + old-ui/app/components/transaction-list-item.js | 175 + old-ui/app/components/transaction-list.js | 87 + old-ui/app/components/typed-message-renderer.js | 42 + old-ui/app/conf-tx.js | 235 + old-ui/app/config.js | 220 + old-ui/app/css/debug.css | 21 + old-ui/app/css/fonts.css | 36 + old-ui/app/css/index.css | 707 +++ old-ui/app/css/lib.css | 306 ++ old-ui/app/css/output/index.css | 5385 ++++++++++++++++++++ old-ui/app/css/reset.css | 48 + old-ui/app/css/transitions.css | 42 + old-ui/app/first-time/init-menu.js | 179 + old-ui/app/img/identicon-tardigrade.png | Bin 0 -> 141119 bytes old-ui/app/img/identicon-walrus.png | Bin 0 -> 388973 bytes old-ui/app/info.js | 155 + old-ui/app/infura-conversion.json | 653 +++ old-ui/app/keychains/hd/create-vault-complete.js | 91 + .../app/keychains/hd/recover-seed/confirmation.js | 121 + old-ui/app/keychains/hd/restore-vault.js | 152 + old-ui/app/new-keychain.js | 29 + old-ui/app/reducers.js | 76 + old-ui/app/reducers/app.js | 599 +++ old-ui/app/reducers/identities.js | 15 + old-ui/app/reducers/metamask.js | 166 + old-ui/app/root.js | 23 + old-ui/app/send.js | 293 ++ old-ui/app/settings.js | 59 + old-ui/app/store.js | 21 + old-ui/app/template.js | 30 + old-ui/app/unlock.js | 122 + old-ui/app/util.js | 240 + old-ui/css.js | 30 + old-ui/design/00-metamask-SignIn.jpg | Bin 0 -> 57848 bytes old-ui/design/01-metamask-SelectAcc.jpg | Bin 0 -> 76063 bytes old-ui/design/02-metamask-AccDetails.jpg | Bin 0 -> 75780 bytes .../design/02a-metamask-AccDetails-OverToken.jpg | Bin 0 -> 121847 bytes .../02a-metamask-AccDetails-OverTransaction.jpg | Bin 0 -> 122075 bytes old-ui/design/02a-metamask-AccDetails.jpg | Bin 0 -> 117570 bytes old-ui/design/02b-metamask-AccDetails-Send.jpg | Bin 0 -> 110143 bytes old-ui/design/03-metamask-Qr.jpg | Bin 0 -> 66052 bytes old-ui/design/05-metamask-Menu.jpg | Bin 0 -> 130264 bytes .../chromeStorePics/final_screen_dao_accounts.png | Bin 0 -> 249708 bytes .../chromeStorePics/final_screen_dao_locked.png | Bin 0 -> 220295 bytes .../final_screen_dao_notification.png | Bin 0 -> 214405 bytes .../chromeStorePics/final_screen_wei_account.png | Bin 0 -> 253382 bytes .../final_screen_wei_notification.png | Bin 0 -> 193865 bytes old-ui/design/chromeStorePics/icon-128.png | Bin 0 -> 5770 bytes old-ui/design/chromeStorePics/icon-64.png | Bin 0 -> 3573 bytes old-ui/design/chromeStorePics/metamask_icon.ai | 2383 +++++++++ old-ui/design/chromeStorePics/promo1400560.png | Bin 0 -> 261644 bytes old-ui/design/chromeStorePics/promo440280.png | Bin 0 -> 57471 bytes old-ui/design/chromeStorePics/promo920680.png | Bin 0 -> 206713 bytes .../design/chromeStorePics/screen_dao_accounts.png | Bin 0 -> 517598 bytes .../design/chromeStorePics/screen_dao_locked.png | Bin 0 -> 287108 bytes .../chromeStorePics/screen_dao_notification.png | Bin 0 -> 296498 bytes .../design/chromeStorePics/screen_wei_account.png | Bin 0 -> 653633 bytes .../chromeStorePics/screen_wei_notification.png | Bin 0 -> 402486 bytes old-ui/design/metamask-logo-eyes.png | Bin 0 -> 146076 bytes old-ui/design/wireframes/1st_time_use.png | Bin 0 -> 937556 bytes old-ui/design/wireframes/metamask_wfs_jan_13.pdf | Bin 0 -> 452413 bytes old-ui/design/wireframes/metamask_wfs_jan_13.png | Bin 0 -> 419066 bytes old-ui/design/wireframes/metamask_wfs_jan_18.pdf | Bin 0 -> 612778 bytes old-ui/example.js | 123 + old-ui/index.html | 20 + old-ui/index.js | 58 + old-ui/lib/contract-namer.js | 33 + old-ui/lib/etherscan-prefix-for-network.js | 21 + old-ui/lib/icon-factory.js | 65 + old-ui/lib/lost-accounts-notice.js | 23 + old-ui/lib/persistent-form.js | 61 + old-ui/lib/tx-helper.js | 27 + 122 files changed, 20398 insertions(+) create mode 100644 old-ui/.gitignore create mode 100644 old-ui/app/account-detail.js create mode 100644 old-ui/app/accounts/import/index.js create mode 100644 old-ui/app/accounts/import/json.js create mode 100644 old-ui/app/accounts/import/private-key.js create mode 100644 old-ui/app/accounts/import/seed.js create mode 100644 old-ui/app/actions.js create mode 100644 old-ui/app/add-token.js create mode 100644 old-ui/app/app.js create mode 100644 old-ui/app/components/account-dropdowns.js create mode 100644 old-ui/app/components/account-export.js create mode 100644 old-ui/app/components/account-panel.js create mode 100644 old-ui/app/components/balance.js create mode 100644 old-ui/app/components/binary-renderer.js create mode 100644 old-ui/app/components/bn-as-decimal-input.js create mode 100644 old-ui/app/components/buy-button-subview.js create mode 100644 old-ui/app/components/coinbase-form.js create mode 100644 old-ui/app/components/copyButton.js create mode 100644 old-ui/app/components/copyable.js create mode 100644 old-ui/app/components/custom-radio-list.js create mode 100644 old-ui/app/components/dropdown.js create mode 100644 old-ui/app/components/editable-label.js create mode 100644 old-ui/app/components/ens-input.js create mode 100644 old-ui/app/components/eth-balance.js create mode 100644 old-ui/app/components/fiat-value.js create mode 100644 old-ui/app/components/hex-as-decimal-input.js create mode 100644 old-ui/app/components/identicon.js create mode 100644 old-ui/app/components/loading.js create mode 100644 old-ui/app/components/mascot.js create mode 100644 old-ui/app/components/menu-droppo.js create mode 100644 old-ui/app/components/mini-account-panel.js create mode 100644 old-ui/app/components/network.js create mode 100644 old-ui/app/components/notice.js create mode 100644 old-ui/app/components/pending-msg-details.js create mode 100644 old-ui/app/components/pending-msg.js create mode 100644 old-ui/app/components/pending-personal-msg-details.js create mode 100644 old-ui/app/components/pending-personal-msg.js create mode 100644 old-ui/app/components/pending-tx.js create mode 100644 old-ui/app/components/pending-typed-msg-details.js create mode 100644 old-ui/app/components/pending-typed-msg.js create mode 100644 old-ui/app/components/qr-code.js create mode 100644 old-ui/app/components/range-slider.js create mode 100644 old-ui/app/components/shapeshift-form.js create mode 100644 old-ui/app/components/shift-list-item.js create mode 100644 old-ui/app/components/tab-bar.js create mode 100644 old-ui/app/components/template.js create mode 100644 old-ui/app/components/token-cell.js create mode 100644 old-ui/app/components/token-list.js create mode 100644 old-ui/app/components/tooltip.js create mode 100644 old-ui/app/components/transaction-list-item-icon.js create mode 100644 old-ui/app/components/transaction-list-item.js create mode 100644 old-ui/app/components/transaction-list.js create mode 100644 old-ui/app/components/typed-message-renderer.js create mode 100644 old-ui/app/conf-tx.js create mode 100644 old-ui/app/config.js create mode 100644 old-ui/app/css/debug.css create mode 100644 old-ui/app/css/fonts.css create mode 100644 old-ui/app/css/index.css create mode 100644 old-ui/app/css/lib.css create mode 100644 old-ui/app/css/output/index.css create mode 100644 old-ui/app/css/reset.css create mode 100644 old-ui/app/css/transitions.css create mode 100644 old-ui/app/first-time/init-menu.js create mode 100644 old-ui/app/img/identicon-tardigrade.png create mode 100644 old-ui/app/img/identicon-walrus.png create mode 100644 old-ui/app/info.js create mode 100644 old-ui/app/infura-conversion.json create mode 100644 old-ui/app/keychains/hd/create-vault-complete.js create mode 100644 old-ui/app/keychains/hd/recover-seed/confirmation.js create mode 100644 old-ui/app/keychains/hd/restore-vault.js create mode 100644 old-ui/app/new-keychain.js create mode 100644 old-ui/app/reducers.js create mode 100644 old-ui/app/reducers/app.js create mode 100644 old-ui/app/reducers/identities.js create mode 100644 old-ui/app/reducers/metamask.js create mode 100644 old-ui/app/root.js create mode 100644 old-ui/app/send.js create mode 100644 old-ui/app/settings.js create mode 100644 old-ui/app/store.js create mode 100644 old-ui/app/template.js create mode 100644 old-ui/app/unlock.js create mode 100644 old-ui/app/util.js create mode 100644 old-ui/css.js create mode 100644 old-ui/design/00-metamask-SignIn.jpg create mode 100644 old-ui/design/01-metamask-SelectAcc.jpg create mode 100644 old-ui/design/02-metamask-AccDetails.jpg create mode 100644 old-ui/design/02a-metamask-AccDetails-OverToken.jpg create mode 100644 old-ui/design/02a-metamask-AccDetails-OverTransaction.jpg create mode 100644 old-ui/design/02a-metamask-AccDetails.jpg create mode 100644 old-ui/design/02b-metamask-AccDetails-Send.jpg create mode 100644 old-ui/design/03-metamask-Qr.jpg create mode 100644 old-ui/design/05-metamask-Menu.jpg create mode 100644 old-ui/design/chromeStorePics/final_screen_dao_accounts.png create mode 100644 old-ui/design/chromeStorePics/final_screen_dao_locked.png create mode 100644 old-ui/design/chromeStorePics/final_screen_dao_notification.png create mode 100644 old-ui/design/chromeStorePics/final_screen_wei_account.png create mode 100644 old-ui/design/chromeStorePics/final_screen_wei_notification.png create mode 100644 old-ui/design/chromeStorePics/icon-128.png create mode 100644 old-ui/design/chromeStorePics/icon-64.png create mode 100644 old-ui/design/chromeStorePics/metamask_icon.ai create mode 100644 old-ui/design/chromeStorePics/promo1400560.png create mode 100644 old-ui/design/chromeStorePics/promo440280.png create mode 100644 old-ui/design/chromeStorePics/promo920680.png create mode 100644 old-ui/design/chromeStorePics/screen_dao_accounts.png create mode 100644 old-ui/design/chromeStorePics/screen_dao_locked.png create mode 100644 old-ui/design/chromeStorePics/screen_dao_notification.png create mode 100644 old-ui/design/chromeStorePics/screen_wei_account.png create mode 100644 old-ui/design/chromeStorePics/screen_wei_notification.png create mode 100644 old-ui/design/metamask-logo-eyes.png create mode 100644 old-ui/design/wireframes/1st_time_use.png create mode 100644 old-ui/design/wireframes/metamask_wfs_jan_13.pdf create mode 100644 old-ui/design/wireframes/metamask_wfs_jan_13.png create mode 100644 old-ui/design/wireframes/metamask_wfs_jan_18.pdf create mode 100644 old-ui/example.js create mode 100644 old-ui/index.html create mode 100644 old-ui/index.js create mode 100644 old-ui/lib/contract-namer.js create mode 100644 old-ui/lib/etherscan-prefix-for-network.js create mode 100644 old-ui/lib/icon-factory.js create mode 100644 old-ui/lib/lost-accounts-notice.js create mode 100644 old-ui/lib/persistent-form.js create mode 100644 old-ui/lib/tx-helper.js diff --git a/old-ui/.gitignore b/old-ui/.gitignore new file mode 100644 index 000000000..c6b1254b5 --- /dev/null +++ b/old-ui/.gitignore @@ -0,0 +1,66 @@ + +# Created by https://www.gitignore.io/api/osx,node + +### OSX ### +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + + +### Node ### +# Logs +logs +*.log +npm-debug.log* + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directory +# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git +node_modules + +# Optional npm cache directory +.npm + +# Optional REPL history +.node_repl_history + diff --git a/old-ui/app/account-detail.js b/old-ui/app/account-detail.js new file mode 100644 index 000000000..d4f707e0b --- /dev/null +++ b/old-ui/app/account-detail.js @@ -0,0 +1,291 @@ +const inherits = require('util').inherits +const extend = require('xtend') +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') +const valuesFor = require('./util').valuesFor +const Identicon = require('./components/identicon') +const EthBalance = require('./components/eth-balance') +const TransactionList = require('./components/transaction-list') +const ExportAccountView = require('./components/account-export') +const ethUtil = require('ethereumjs-util') +const EditableLabel = require('./components/editable-label') +const TabBar = require('./components/tab-bar') +const TokenList = require('./components/token-list') +const AccountDropdowns = require('./components/account-dropdowns').AccountDropdowns + +module.exports = connect(mapStateToProps)(AccountDetailScreen) + +function mapStateToProps (state) { + return { + metamask: state.metamask, + identities: state.metamask.identities, + accounts: state.metamask.accounts, + address: state.metamask.selectedAddress, + accountDetail: state.appState.accountDetail, + network: state.metamask.network, + unapprovedMsgs: valuesFor(state.metamask.unapprovedMsgs), + shapeShiftTxList: state.metamask.shapeShiftTxList, + transactions: state.metamask.selectedAddressTxList || [], + conversionRate: state.metamask.conversionRate, + currentCurrency: state.metamask.currentCurrency, + currentAccountTab: state.metamask.currentAccountTab, + tokens: state.metamask.tokens, + computedBalances: state.metamask.computedBalances, + } +} + +inherits(AccountDetailScreen, Component) +function AccountDetailScreen () { + Component.call(this) +} + +AccountDetailScreen.prototype.render = function () { + var props = this.props + var selected = props.address || Object.keys(props.accounts)[0] + var checksumAddress = selected && ethUtil.toChecksumAddress(selected) + var identity = props.identities[selected] + var account = props.accounts[selected] + const { network, conversionRate, currentCurrency } = props + + return ( + + h('.account-detail-section.full-flex-height', [ + + // identicon, label, balance, etc + h('.account-data-subsection', { + style: { + margin: '0 20px', + flex: '1 0 auto', + }, + }, [ + + // header - identicon + nav + h('div', { + style: { + paddingTop: '20px', + display: 'flex', + justifyContent: 'flex-start', + alignItems: 'flex-start', + }, + }, [ + + // large identicon and addresses + h('.identicon-wrapper.select-none', [ + h(Identicon, { + diameter: 62, + address: selected, + }), + ]), + h('flex-column', { + style: { + lineHeight: '10px', + marginLeft: '15px', + width: '100%', + }, + }, [ + h(EditableLabel, { + textValue: identity ? identity.name : '', + state: { + isEditingLabel: false, + }, + saveText: (text) => { + props.dispatch(actions.saveAccountLabel(selected, text)) + }, + }, [ + + // What is shown when not editing + edit text: + h('label.editing-label', [h('.edit-text', 'edit')]), + h( + 'div', + { + style: { + display: 'flex', + justifyContent: 'flex-start', + alignItems: 'center', + }, + }, + [ + h( + 'div.font-medium.color-forest', + { + name: 'edit', + style: { + }, + }, + [ + h('h2', { + style: { + maxWidth: '180px', + overflow: 'hidden', + textOverflow: 'ellipsis', + padding: '5px 0px', + lineHeight: '25px', + }, + }, [ + identity && identity.name, + ]), + ] + ), + h( + AccountDropdowns, + { + style: { + marginRight: '8px', + marginLeft: 'auto', + cursor: 'pointer', + }, + selected, + network, + identities: props.identities, + enableAccountOptions: true, + }, + ), + ] + ), + ]), + h('.flex-row', { + style: { + width: '15em', + justifyContent: 'space-between', + alignItems: 'baseline', + }, + }, [ + + // address + + h('div', { + style: { + overflow: 'hidden', + textOverflow: 'ellipsis', + paddingTop: '3px', + width: '5em', + fontSize: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + marginBottom: '15px', + color: '#AEAEAE', + }, + }, checksumAddress), + ]), + + // account ballence + + ]), + ]), + h('.flex-row', { + style: { + justifyContent: 'space-between', + alignItems: 'flex-start', + }, + }, [ + + h(EthBalance, { + value: account && account.balance, + conversionRate, + currentCurrency, + style: { + lineHeight: '7px', + marginTop: '10px', + }, + }), + + h('.flex-grow'), + + h('button', { + onClick: () => props.dispatch(actions.buyEthView(selected)), + style: { marginRight: '10px' }, + }, 'BUY'), + + h('button', { + onClick: () => props.dispatch(actions.showSendPage()), + style: { + marginBottom: '20px', + marginRight: '8px', + }, + }, 'SEND'), + + ]), + ]), + + // subview (tx history, pk export confirm, buy eth warning) + this.subview(), + + ]) + ) +} + +AccountDetailScreen.prototype.subview = function () { + var subview + try { + subview = this.props.accountDetail.subview + } catch (e) { + subview = null + } + + switch (subview) { + case 'transactions': + return this.tabSections() + case 'export': + var state = extend({key: 'export'}, this.props) + return h(ExportAccountView, state) + default: + return this.tabSections() + } +} + +AccountDetailScreen.prototype.tabSections = function () { + const { currentAccountTab } = this.props + + return h('section.tabSection.full-flex-height.grow-tenx', [ + + h(TabBar, { + tabs: [ + { content: 'Sent', key: 'history' }, + { content: 'Tokens', key: 'tokens' }, + ], + defaultTab: currentAccountTab || 'history', + tabSelected: (key) => { + this.props.dispatch(actions.setCurrentAccountTab(key)) + }, + }), + + this.tabSwitchView(), + ]) +} + +AccountDetailScreen.prototype.tabSwitchView = function () { + const props = this.props + const { address, network } = props + const { currentAccountTab, tokens } = this.props + + switch (currentAccountTab) { + case 'tokens': + return h(TokenList, { + userAddress: address, + network, + tokens, + addToken: () => this.props.dispatch(actions.showAddTokenPage()), + }) + default: + return this.transactionList() + } +} + +AccountDetailScreen.prototype.transactionList = function () { + const {transactions, unapprovedMsgs, address, + network, shapeShiftTxList, conversionRate } = this.props + + return h(TransactionList, { + transactions: transactions.sort((a, b) => b.time - a.time), + network, + unapprovedMsgs, + conversionRate, + address, + shapeShiftTxList, + viewPendingTx: (txId) => { + this.props.dispatch(actions.viewPendingTx(txId)) + }, + }) +} diff --git a/old-ui/app/accounts/import/index.js b/old-ui/app/accounts/import/index.js new file mode 100644 index 000000000..46260c3e7 --- /dev/null +++ b/old-ui/app/accounts/import/index.js @@ -0,0 +1,101 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('../../actions') +import Select from 'react-select' + +// Subviews +const JsonImportView = require('./json.js') +const PrivateKeyImportView = require('./private-key.js') + +const menuItems = [ + 'Private Key', + 'JSON File', +] + +module.exports = connect(mapStateToProps)(AccountImportSubview) + +function mapStateToProps (state) { + return { + menuItems, + } +} + +inherits(AccountImportSubview, Component) +function AccountImportSubview () { + Component.call(this) +} + +AccountImportSubview.prototype.render = function () { + const props = this.props + const state = this.state || {} + const { menuItems } = props + const { type } = state + + return ( + h('div', { + style: { + }, + }, [ + h('.section-title.flex-row.flex-center', [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: (event) => { + props.dispatch(actions.goHome()) + }, + }), + h('h2.page-subtitle', 'Import Accounts'), + ]), + h('div', { + style: { + padding: '10px', + color: 'rgb(174, 174, 174)', + }, + }, [ + + h('h3', { style: { padding: '3px' } }, 'SELECT TYPE'), + + h('style', ` + .has-value.Select--single > .Select-control .Select-value .Select-value-label, .Select-value-label { + color: rgb(174,174,174); + } + `), + + h(Select, { + name: 'import-type-select', + clearable: false, + value: type || menuItems[0], + options: menuItems.map((type) => { + return { + value: type, + label: type, + } + }), + onChange: (opt) => { + props.dispatch(actions.showImportPage()) + this.setState({ type: opt.value }) + }, + }), + ]), + + this.renderImportView(), + ]) + ) +} + +AccountImportSubview.prototype.renderImportView = function () { + const props = this.props + const state = this.state || {} + const { type } = state + const { menuItems } = props + const current = type || menuItems[0] + + switch (current) { + case 'Private Key': + return h(PrivateKeyImportView) + case 'JSON File': + return h(JsonImportView) + default: + return h(JsonImportView) + } +} diff --git a/old-ui/app/accounts/import/json.js b/old-ui/app/accounts/import/json.js new file mode 100644 index 000000000..158a3c923 --- /dev/null +++ b/old-ui/app/accounts/import/json.js @@ -0,0 +1,100 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('../../actions') +const FileInput = require('react-simple-file-input').default + +const HELP_LINK = 'https://github.com/MetaMask/faq/blob/master/README.md#q-i-cant-use-the-import-feature-for-uploading-a-json-file-the-window-keeps-closing-when-i-try-to-select-a-file' + +module.exports = connect(mapStateToProps)(JsonImportSubview) + +function mapStateToProps (state) { + return { + error: state.appState.warning, + } +} + +inherits(JsonImportSubview, Component) +function JsonImportSubview () { + Component.call(this) +} + +JsonImportSubview.prototype.render = function () { + const { error } = this.props + + return ( + h('div', { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + padding: '5px 15px 0px 15px', + }, + }, [ + + h('p', 'Used by a variety of different clients'), + h('a.warning', { href: HELP_LINK, target: '_blank' }, 'File import not working? Click here!'), + + h(FileInput, { + readAs: 'text', + onLoad: this.onLoad.bind(this), + style: { + margin: '20px 0px 12px 20px', + fontSize: '15px', + }, + }), + + h('input.large-input.letter-spacey', { + type: 'password', + placeholder: 'Enter password', + id: 'json-password-box', + onKeyPress: this.createKeyringOnEnter.bind(this), + style: { + width: 260, + marginTop: 12, + }, + }), + + h('button.primary', { + onClick: this.createNewKeychain.bind(this), + style: { + margin: 12, + }, + }, 'Import'), + + error ? h('span.error', error) : null, + ]) + ) +} + +JsonImportSubview.prototype.onLoad = function (event, file) { + this.setState({file: file, fileContents: event.target.result}) +} + +JsonImportSubview.prototype.createKeyringOnEnter = function (event) { + if (event.key === 'Enter') { + event.preventDefault() + this.createNewKeychain() + } +} + +JsonImportSubview.prototype.createNewKeychain = function () { + const state = this.state + const { fileContents } = state + + if (!fileContents) { + const message = 'You must select a file to import.' + return this.props.dispatch(actions.displayWarning(message)) + } + + const passwordInput = document.getElementById('json-password-box') + const password = passwordInput.value + + if (!password) { + const message = 'You must enter a password for the selected file.' + return this.props.dispatch(actions.displayWarning(message)) + } + + this.props.dispatch(actions.importNewAccount('JSON File', [ fileContents, password ])) +} diff --git a/old-ui/app/accounts/import/private-key.js b/old-ui/app/accounts/import/private-key.js new file mode 100644 index 000000000..68ccee58e --- /dev/null +++ b/old-ui/app/accounts/import/private-key.js @@ -0,0 +1,67 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('../../actions') + +module.exports = connect(mapStateToProps)(PrivateKeyImportView) + +function mapStateToProps (state) { + return { + error: state.appState.warning, + } +} + +inherits(PrivateKeyImportView, Component) +function PrivateKeyImportView () { + Component.call(this) +} + +PrivateKeyImportView.prototype.render = function () { + const { error } = this.props + + return ( + h('div', { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + padding: '5px 15px 0px 15px', + }, + }, [ + h('span', 'Paste your private key string here'), + + h('input.large-input.letter-spacey', { + type: 'password', + id: 'private-key-box', + onKeyPress: this.createKeyringOnEnter.bind(this), + style: { + width: 260, + marginTop: 12, + }, + }), + + h('button.primary', { + onClick: this.createNewKeychain.bind(this), + style: { + margin: 12, + }, + }, 'Import'), + + error ? h('span.error', error) : null, + ]) + ) +} + +PrivateKeyImportView.prototype.createKeyringOnEnter = function (event) { + if (event.key === 'Enter') { + event.preventDefault() + this.createNewKeychain() + } +} + +PrivateKeyImportView.prototype.createNewKeychain = function () { + const input = document.getElementById('private-key-box') + const privateKey = input.value + this.props.dispatch(actions.importNewAccount('Private Key', [ privateKey ])) +} diff --git a/old-ui/app/accounts/import/seed.js b/old-ui/app/accounts/import/seed.js new file mode 100644 index 000000000..b4a7c0afa --- /dev/null +++ b/old-ui/app/accounts/import/seed.js @@ -0,0 +1,30 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect + +module.exports = connect(mapStateToProps)(SeedImportSubview) + +function mapStateToProps (state) { + return {} +} + +inherits(SeedImportSubview, Component) +function SeedImportSubview () { + Component.call(this) +} + +SeedImportSubview.prototype.render = function () { + return ( + h('div', { + style: { + }, + }, [ + `Paste your seed phrase here!`, + h('textarea'), + h('br'), + h('button', 'Submit'), + ]) + ) +} + diff --git a/old-ui/app/actions.js b/old-ui/app/actions.js new file mode 100644 index 000000000..d070548fc --- /dev/null +++ b/old-ui/app/actions.js @@ -0,0 +1,1128 @@ +const getBuyEthUrl = require('../../app/scripts/lib/buy-eth-url') + +var actions = { + _setBackgroundConnection: _setBackgroundConnection, + + GO_HOME: 'GO_HOME', + goHome: goHome, + // menu state + getNetworkStatus: 'getNetworkStatus', + // transition state + TRANSITION_FORWARD: 'TRANSITION_FORWARD', + TRANSITION_BACKWARD: 'TRANSITION_BACKWARD', + transitionForward, + transitionBackward, + // remote state + UPDATE_METAMASK_STATE: 'UPDATE_METAMASK_STATE', + updateMetamaskState: updateMetamaskState, + // notices + MARK_NOTICE_READ: 'MARK_NOTICE_READ', + markNoticeRead: markNoticeRead, + SHOW_NOTICE: 'SHOW_NOTICE', + showNotice: showNotice, + CLEAR_NOTICES: 'CLEAR_NOTICES', + clearNotices: clearNotices, + markAccountsFound, + // intialize screen + CREATE_NEW_VAULT_IN_PROGRESS: 'CREATE_NEW_VAULT_IN_PROGRESS', + SHOW_CREATE_VAULT: 'SHOW_CREATE_VAULT', + SHOW_RESTORE_VAULT: 'SHOW_RESTORE_VAULT', + FORGOT_PASSWORD: 'FORGOT_PASSWORD', + forgotPassword: forgotPassword, + SHOW_INIT_MENU: 'SHOW_INIT_MENU', + SHOW_NEW_VAULT_SEED: 'SHOW_NEW_VAULT_SEED', + SHOW_INFO_PAGE: 'SHOW_INFO_PAGE', + SHOW_IMPORT_PAGE: 'SHOW_IMPORT_PAGE', + unlockMetamask: unlockMetamask, + unlockFailed: unlockFailed, + showCreateVault: showCreateVault, + showRestoreVault: showRestoreVault, + showInitializeMenu: showInitializeMenu, + showImportPage, + createNewVaultAndKeychain: createNewVaultAndKeychain, + createNewVaultAndRestore: createNewVaultAndRestore, + createNewVaultInProgress: createNewVaultInProgress, + addNewKeyring, + importNewAccount, + addNewAccount, + NEW_ACCOUNT_SCREEN: 'NEW_ACCOUNT_SCREEN', + navigateToNewAccountScreen, + showNewVaultSeed: showNewVaultSeed, + showInfoPage: showInfoPage, + // seed recovery actions + REVEAL_SEED_CONFIRMATION: 'REVEAL_SEED_CONFIRMATION', + revealSeedConfirmation: revealSeedConfirmation, + requestRevealSeed: requestRevealSeed, + // unlock screen + UNLOCK_IN_PROGRESS: 'UNLOCK_IN_PROGRESS', + UNLOCK_FAILED: 'UNLOCK_FAILED', + UNLOCK_METAMASK: 'UNLOCK_METAMASK', + LOCK_METAMASK: 'LOCK_METAMASK', + tryUnlockMetamask: tryUnlockMetamask, + lockMetamask: lockMetamask, + unlockInProgress: unlockInProgress, + // error handling + displayWarning: displayWarning, + DISPLAY_WARNING: 'DISPLAY_WARNING', + HIDE_WARNING: 'HIDE_WARNING', + hideWarning: hideWarning, + // accounts screen + SET_SELECTED_ACCOUNT: 'SET_SELECTED_ACCOUNT', + SHOW_ACCOUNT_DETAIL: 'SHOW_ACCOUNT_DETAIL', + SHOW_ACCOUNTS_PAGE: 'SHOW_ACCOUNTS_PAGE', + SHOW_CONF_TX_PAGE: 'SHOW_CONF_TX_PAGE', + SHOW_CONF_MSG_PAGE: 'SHOW_CONF_MSG_PAGE', + SET_CURRENT_FIAT: 'SET_CURRENT_FIAT', + setCurrentCurrency: setCurrentCurrency, + setCurrentAccountTab, + // account detail screen + SHOW_SEND_PAGE: 'SHOW_SEND_PAGE', + showSendPage: showSendPage, + ADD_TO_ADDRESS_BOOK: 'ADD_TO_ADDRESS_BOOK', + addToAddressBook: addToAddressBook, + REQUEST_ACCOUNT_EXPORT: 'REQUEST_ACCOUNT_EXPORT', + requestExportAccount: requestExportAccount, + EXPORT_ACCOUNT: 'EXPORT_ACCOUNT', + exportAccount: exportAccount, + SHOW_PRIVATE_KEY: 'SHOW_PRIVATE_KEY', + showPrivateKey: showPrivateKey, + SAVE_ACCOUNT_LABEL: 'SAVE_ACCOUNT_LABEL', + saveAccountLabel: saveAccountLabel, + // tx conf screen + COMPLETED_TX: 'COMPLETED_TX', + TRANSACTION_ERROR: 'TRANSACTION_ERROR', + NEXT_TX: 'NEXT_TX', + PREVIOUS_TX: 'PREV_TX', + signMsg: signMsg, + cancelMsg: cancelMsg, + signPersonalMsg, + cancelPersonalMsg, + signTypedMsg, + cancelTypedMsg, + signTx: signTx, + updateAndApproveTx, + cancelTx: cancelTx, + completedTx: completedTx, + txError: txError, + nextTx: nextTx, + previousTx: previousTx, + cancelAllTx: cancelAllTx, + viewPendingTx: viewPendingTx, + VIEW_PENDING_TX: 'VIEW_PENDING_TX', + // app messages + confirmSeedWords: confirmSeedWords, + showAccountDetail: showAccountDetail, + BACK_TO_ACCOUNT_DETAIL: 'BACK_TO_ACCOUNT_DETAIL', + backToAccountDetail: backToAccountDetail, + showAccountsPage: showAccountsPage, + showConfTxPage: showConfTxPage, + // config screen + SHOW_CONFIG_PAGE: 'SHOW_CONFIG_PAGE', + SET_RPC_TARGET: 'SET_RPC_TARGET', + SET_DEFAULT_RPC_TARGET: 'SET_DEFAULT_RPC_TARGET', + SET_PROVIDER_TYPE: 'SET_PROVIDER_TYPE', + showConfigPage, + SHOW_ADD_TOKEN_PAGE: 'SHOW_ADD_TOKEN_PAGE', + showAddTokenPage, + addToken, + setRpcTarget: setRpcTarget, + setProviderType: setProviderType, + // loading overlay + SHOW_LOADING: 'SHOW_LOADING_INDICATION', + HIDE_LOADING: 'HIDE_LOADING_INDICATION', + showLoadingIndication: showLoadingIndication, + hideLoadingIndication: hideLoadingIndication, + // buy Eth with coinbase + onboardingBuyEthView, + ONBOARDING_BUY_ETH_VIEW: 'ONBOARDING_BUY_ETH_VIEW', + BUY_ETH: 'BUY_ETH', + buyEth: buyEth, + buyEthView: buyEthView, + buyWithShapeShift, + BUY_ETH_VIEW: 'BUY_ETH_VIEW', + COINBASE_SUBVIEW: 'COINBASE_SUBVIEW', + coinBaseSubview: coinBaseSubview, + SHAPESHIFT_SUBVIEW: 'SHAPESHIFT_SUBVIEW', + shapeShiftSubview: shapeShiftSubview, + PAIR_UPDATE: 'PAIR_UPDATE', + pairUpdate: pairUpdate, + coinShiftRquest: coinShiftRquest, + SHOW_SUB_LOADING_INDICATION: 'SHOW_SUB_LOADING_INDICATION', + showSubLoadingIndication: showSubLoadingIndication, + HIDE_SUB_LOADING_INDICATION: 'HIDE_SUB_LOADING_INDICATION', + hideSubLoadingIndication: hideSubLoadingIndication, +// QR STUFF: + SHOW_QR: 'SHOW_QR', + showQrView: showQrView, + reshowQrCode: reshowQrCode, + SHOW_QR_VIEW: 'SHOW_QR_VIEW', +// FORGOT PASSWORD: + BACK_TO_INIT_MENU: 'BACK_TO_INIT_MENU', + goBackToInitView: goBackToInitView, + RECOVERY_IN_PROGRESS: 'RECOVERY_IN_PROGRESS', + BACK_TO_UNLOCK_VIEW: 'BACK_TO_UNLOCK_VIEW', + backToUnlockView: backToUnlockView, + // SHOWING KEYCHAIN + SHOW_NEW_KEYCHAIN: 'SHOW_NEW_KEYCHAIN', + showNewKeychain: showNewKeychain, + + callBackgroundThenUpdate, + forceUpdateMetamaskState, + + // Feature Flags + setFeatureFlag, + updateFeatureFlags, + UPDATE_FEATURE_FLAGS: 'UPDATE_FEATURE_FLAGS', +} + +module.exports = actions + +var background = null +function _setBackgroundConnection (backgroundConnection) { + background = backgroundConnection +} + +function goHome () { + return { + type: actions.GO_HOME, + } +} + +// async actions + +function tryUnlockMetamask (password) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + dispatch(actions.unlockInProgress()) + log.debug(`background.submitPassword`) + background.submitPassword(password, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.unlockFailed(err.message)) + } else { + dispatch(actions.transitionForward()) + forceUpdateMetamaskState(dispatch) + } + }) + } +} + +function transitionForward () { + return { + type: this.TRANSITION_FORWARD, + } +} + +function transitionBackward () { + return { + type: this.TRANSITION_BACKWARD, + } +} + +function confirmSeedWords () { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.clearSeedWordCache`) + return new Promise((resolve, reject) => { + background.clearSeedWordCache((err, account) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.displayWarning(err.message)) + reject(err) + } + + log.info('Seed word cache cleared. ' + account) + dispatch(actions.showAccountsPage()) + resolve(account) + }) + }) + } +} + +function createNewVaultAndRestore (password, seed) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.createNewVaultAndRestore`) + + return new Promise((resolve, reject) => { + background.createNewVaultAndRestore(password, seed, (err) => { + + dispatch(actions.hideLoadingIndication()) + + if (err) { + dispatch(actions.displayWarning(err.message)) + return reject(err) + } + + dispatch(actions.showAccountsPage()) + resolve() + }) + }) + } +} + +function createNewVaultAndKeychain (password) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.createNewVaultAndKeychain`) + + return new Promise((resolve, reject) => { + background.createNewVaultAndKeychain(password, (err) => { + if (err) { + dispatch(actions.displayWarning(err.message)) + return reject(err) + } + log.debug(`background.placeSeedWords`) + background.placeSeedWords((err) => { + if (err) { + dispatch(actions.displayWarning(err.message)) + return reject(err) + } + dispatch(actions.hideLoadingIndication()) + forceUpdateMetamaskState(dispatch) + resolve() + }) + }) + }) + + } +} + +function revealSeedConfirmation () { + return { + type: this.REVEAL_SEED_CONFIRMATION, + } +} + +function requestRevealSeed (password) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.submitPassword`) + background.submitPassword(password, (err) => { + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + log.debug(`background.placeSeedWords`) + background.placeSeedWords((err, result) => { + if (err) return dispatch(actions.displayWarning(err.message)) + dispatch(actions.hideLoadingIndication()) + dispatch(actions.showNewVaultSeed(result)) + }) + }) + } +} + +function addNewKeyring (type, opts) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.addNewKeyring`) + background.addNewKeyring(type, opts, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) return dispatch(actions.displayWarning(err.message)) + dispatch(actions.showAccountsPage()) + }) + } +} + +function importNewAccount (strategy, args) { + return (dispatch) => { + dispatch(actions.showLoadingIndication('This may take a while, be patient.')) + log.debug(`background.importAccountWithStrategy`) + return new Promise((resolve, reject) => { + background.importAccountWithStrategy(strategy, args, (err) => { + if (err) { + dispatch(actions.displayWarning(err.message)) + return reject(err) + } + log.debug(`background.getState`) + background.getState((err, newState) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.displayWarning(err.message)) + return reject(err) + } + dispatch(actions.updateMetamaskState(newState)) + dispatch({ + type: actions.SHOW_ACCOUNT_DETAIL, + value: newState.selectedAddress, + }) + resolve(newState) + }) + }) + }) + } +} + +function navigateToNewAccountScreen () { + return { + type: this.NEW_ACCOUNT_SCREEN, + } +} + +function addNewAccount () { + log.debug(`background.addNewAccount`) + return callBackgroundThenUpdate(background.addNewAccount) +} + +function showInfoPage () { + return { + type: actions.SHOW_INFO_PAGE, + } +} + +function setCurrentCurrency (currencyCode) { + return (dispatch) => { + dispatch(this.showLoadingIndication()) + log.debug(`background.setCurrentCurrency`) + background.setCurrentCurrency(currencyCode, (err, data) => { + dispatch(this.hideLoadingIndication()) + if (err) { + log.error(err.stack) + return dispatch(actions.displayWarning(err.message)) + } + dispatch({ + type: this.SET_CURRENT_FIAT, + value: { + currentCurrency: data.currentCurrency, + conversionRate: data.conversionRate, + conversionDate: data.conversionDate, + }, + }) + }) + } +} + +function signMsg (msgData) { + log.debug('action - signMsg') + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + + log.debug(`actions calling background.signMessage`) + background.signMessage(msgData, (err, newState) => { + log.debug('signMessage called back') + dispatch(actions.updateMetamaskState(newState)) + dispatch(actions.hideLoadingIndication()) + + if (err) log.error(err) + if (err) return dispatch(actions.displayWarning(err.message)) + + dispatch(actions.completedTx(msgData.metamaskId)) + }) + } +} + +function signPersonalMsg (msgData) { + log.debug('action - signPersonalMsg') + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + + log.debug(`actions calling background.signPersonalMessage`) + background.signPersonalMessage(msgData, (err, newState) => { + log.debug('signPersonalMessage called back') + dispatch(actions.updateMetamaskState(newState)) + dispatch(actions.hideLoadingIndication()) + + if (err) log.error(err) + if (err) return dispatch(actions.displayWarning(err.message)) + + dispatch(actions.completedTx(msgData.metamaskId)) + }) + } +} + +function signTypedMsg (msgData) { + log.debug('action - signTypedMsg') + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + + log.debug(`actions calling background.signTypedMessage`) + background.signTypedMessage(msgData, (err, newState) => { + log.debug('signTypedMessage called back') + dispatch(actions.updateMetamaskState(newState)) + dispatch(actions.hideLoadingIndication()) + + if (err) log.error(err) + if (err) return dispatch(actions.displayWarning(err.message)) + + dispatch(actions.completedTx(msgData.metamaskId)) + }) + } +} + +function signTx (txData) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + global.ethQuery.sendTransaction(txData, (err, data) => { + dispatch(actions.hideLoadingIndication()) + if (err) dispatch(actions.displayWarning(err.message)) + dispatch(this.goHome()) + }) + dispatch(actions.showConfTxPage()) + } +} + +function updateAndApproveTx (txData) { + log.info('actions: updateAndApproveTx: ' + JSON.stringify(txData)) + return (dispatch) => { + log.debug(`actions calling background.updateAndApproveTx`) + background.updateAndApproveTransaction(txData, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.txError(err)) + dispatch(actions.goHome()) + return log.error(err.message) + } + dispatch(actions.completedTx(txData.id)) + }) + } +} + +function completedTx (id) { + return { + type: actions.COMPLETED_TX, + value: id, + } +} + +function txError (err) { + return { + type: actions.TRANSACTION_ERROR, + message: err.message, + } +} + +function cancelMsg (msgData) { + log.debug(`background.cancelMessage`) + background.cancelMessage(msgData.id) + return actions.completedTx(msgData.id) +} + +function cancelPersonalMsg (msgData) { + const id = msgData.id + background.cancelPersonalMessage(id) + return actions.completedTx(id) +} + +function cancelTypedMsg (msgData) { + const id = msgData.id + background.cancelTypedMessage(id) + return actions.completedTx(id) +} + +function cancelTx (txData) { + return (dispatch) => { + log.debug(`background.cancelTransaction`) + background.cancelTransaction(txData.id, () => { + dispatch(actions.completedTx(txData.id)) + }) + } +} + +function cancelAllTx (txsData) { + return (dispatch) => { + txsData.forEach((txData, i) => { + background.cancelTransaction(txData.id, () => { + dispatch(actions.completedTx(txData.id)) + i === txsData.length - 1 ? dispatch(actions.goHome()) : null + }) + }) + } +} +// +// initialize screen +// + +function showCreateVault () { + return { + type: actions.SHOW_CREATE_VAULT, + } +} + +function showRestoreVault () { + return { + type: actions.SHOW_RESTORE_VAULT, + } +} + +function forgotPassword () { + return { + type: actions.FORGOT_PASSWORD, + } +} + +function showInitializeMenu () { + return { + type: actions.SHOW_INIT_MENU, + } +} + +function showImportPage () { + return { + type: actions.SHOW_IMPORT_PAGE, + } +} + +function createNewVaultInProgress () { + return { + type: actions.CREATE_NEW_VAULT_IN_PROGRESS, + } +} + +function showNewVaultSeed (seed) { + return { + type: actions.SHOW_NEW_VAULT_SEED, + value: seed, + } +} + +function backToUnlockView () { + return { + type: actions.BACK_TO_UNLOCK_VIEW, + } +} + +function showNewKeychain () { + return { + type: actions.SHOW_NEW_KEYCHAIN, + } +} + +// +// unlock screen +// + +function unlockInProgress () { + return { + type: actions.UNLOCK_IN_PROGRESS, + } +} + +function unlockFailed (message) { + return { + type: actions.UNLOCK_FAILED, + value: message, + } +} + +function unlockMetamask (account) { + return { + type: actions.UNLOCK_METAMASK, + value: account, + } +} + +function updateMetamaskState (newState) { + return { + type: actions.UPDATE_METAMASK_STATE, + value: newState, + } +} + +function lockMetamask () { + log.debug(`background.setLocked`) + return callBackgroundThenUpdate(background.setLocked) +} + +function setCurrentAccountTab (newTabName) { + log.debug(`background.setCurrentAccountTab: ${newTabName}`) + return callBackgroundThenUpdateNoSpinner(background.setCurrentAccountTab, newTabName) +} + +function showAccountDetail (address) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.setSelectedAddress`) + background.setSelectedAddress(address, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + dispatch({ + type: actions.SHOW_ACCOUNT_DETAIL, + value: address, + }) + }) + } +} + +function backToAccountDetail (address) { + return { + type: actions.BACK_TO_ACCOUNT_DETAIL, + value: address, + } +} + +function showAccountsPage () { + return { + type: actions.SHOW_ACCOUNTS_PAGE, + } +} + +function showConfTxPage (transForward = true) { + return { + type: actions.SHOW_CONF_TX_PAGE, + transForward: transForward, + } +} + +function nextTx () { + return { + type: actions.NEXT_TX, + } +} + +function viewPendingTx (txId) { + return { + type: actions.VIEW_PENDING_TX, + value: txId, + } +} + +function previousTx () { + return { + type: actions.PREVIOUS_TX, + } +} + +function showConfigPage (transitionForward = true) { + return { + type: actions.SHOW_CONFIG_PAGE, + value: transitionForward, + } +} + +function showAddTokenPage (transitionForward = true) { + return { + type: actions.SHOW_ADD_TOKEN_PAGE, + value: transitionForward, + } +} + +function addToken (address, symbol, decimals) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + background.addToken(address, symbol, decimals, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + setTimeout(() => { + dispatch(actions.goHome()) + }, 250) + }) + } +} + +function goBackToInitView () { + return { + type: actions.BACK_TO_INIT_MENU, + } +} + +// +// notice +// + +function markNoticeRead (notice) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.markNoticeRead`) + return new Promise((resolve, reject) => { + background.markNoticeRead(notice, (err, notice) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.displayWarning(err)) + return reject(err) + } + if (notice) { + dispatch(actions.showNotice(notice)) + resolve() + } else { + dispatch(actions.clearNotices()) + resolve() + } + }) + }) + } +} + +function showNotice (notice) { + return { + type: actions.SHOW_NOTICE, + value: notice, + } +} + +function clearNotices () { + return { + type: actions.CLEAR_NOTICES, + } +} + +function markAccountsFound () { + log.debug(`background.markAccountsFound`) + return callBackgroundThenUpdate(background.markAccountsFound) +} + +// +// config +// + +function setProviderType (type) { + return (dispatch) => { + log.debug(`background.setProviderType`) + background.setProviderType(type, (err, result) => { + if (err) { + log.error(err) + return dispatch(self.displayWarning('Had a problem changing networks!')) + } + }) + return { + type: actions.SET_PROVIDER_TYPE, + value: type, + } + } +} + +function setRpcTarget (newRpc) { + log.debug(`background.setRpcTarget: ${newRpc}`) + return (dispatch) => { + background.setCustomRpc(newRpc, (err, result) => { + if (err) { + log.error(err) + return dispatch(self.displayWarning('Had a problem changing networks!')) + } + }) + } +} + +// Calls the addressBookController to add a new address. +function addToAddressBook (recipient, nickname) { + log.debug(`background.addToAddressBook`) + return (dispatch) => { + background.setAddressBook(recipient, nickname, (err, result) => { + if (err) { + log.error(err) + return dispatch(self.displayWarning('Address book failed to update')) + } + }) + } +} + +function showLoadingIndication (message) { + return { + type: actions.SHOW_LOADING, + value: message, + } +} + +function hideLoadingIndication () { + return { + type: actions.HIDE_LOADING, + } +} + +function showSubLoadingIndication () { + return { + type: actions.SHOW_SUB_LOADING_INDICATION, + } +} + +function hideSubLoadingIndication () { + return { + type: actions.HIDE_SUB_LOADING_INDICATION, + } +} + +function displayWarning (text) { + return { + type: actions.DISPLAY_WARNING, + value: text, + } +} + +function hideWarning () { + return { + type: actions.HIDE_WARNING, + } +} + +function requestExportAccount () { + return { + type: actions.REQUEST_ACCOUNT_EXPORT, + } +} + +function exportAccount (password, address) { + var self = this + + return function (dispatch) { + dispatch(self.showLoadingIndication()) + + log.debug(`background.submitPassword`) + background.submitPassword(password, function (err) { + if (err) { + log.error('Error in submiting password.') + dispatch(self.hideLoadingIndication()) + return dispatch(self.displayWarning('Incorrect Password.')) + } + log.debug(`background.exportAccount`) + background.exportAccount(address, function (err, result) { + dispatch(self.hideLoadingIndication()) + + if (err) { + log.error(err) + return dispatch(self.displayWarning('Had a problem exporting the account.')) + } + + dispatch(self.showPrivateKey(result)) + }) + }) + } +} + +function showPrivateKey (key) { + return { + type: actions.SHOW_PRIVATE_KEY, + value: key, + } +} + +function saveAccountLabel (account, label) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + log.debug(`background.saveAccountLabel`) + background.saveAccountLabel(account, label, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + dispatch({ + type: actions.SAVE_ACCOUNT_LABEL, + value: { account, label }, + }) + }) + } +} + +function showSendPage () { + return { + type: actions.SHOW_SEND_PAGE, + } +} + +function buyEth (opts) { + return (dispatch) => { + const url = getBuyEthUrl(opts) + global.platform.openWindow({ url }) + dispatch({ + type: actions.BUY_ETH, + }) + } +} + +function onboardingBuyEthView (address) { + return { + type: actions.ONBOARDING_BUY_ETH_VIEW, + value: address, + } +} + +function buyEthView (address) { + return { + type: actions.BUY_ETH_VIEW, + value: address, + } +} + +function coinBaseSubview () { + return { + type: actions.COINBASE_SUBVIEW, + } +} + +function pairUpdate (coin) { + return (dispatch) => { + dispatch(actions.showSubLoadingIndication()) + dispatch(actions.hideWarning()) + shapeShiftRequest('marketinfo', {pair: `${coin.toLowerCase()}_eth`}, (mktResponse) => { + dispatch(actions.hideSubLoadingIndication()) + dispatch({ + type: actions.PAIR_UPDATE, + value: { + marketinfo: mktResponse, + }, + }) + }) + } +} + +function shapeShiftSubview (network) { + var pair = 'btc_eth' + + return (dispatch) => { + dispatch(actions.showSubLoadingIndication()) + shapeShiftRequest('marketinfo', {pair}, (mktResponse) => { + shapeShiftRequest('getcoins', {}, (response) => { + dispatch(actions.hideSubLoadingIndication()) + if (mktResponse.error) return dispatch(actions.displayWarning(mktResponse.error)) + dispatch({ + type: actions.SHAPESHIFT_SUBVIEW, + value: { + marketinfo: mktResponse, + coinOptions: response, + }, + }) + }) + }) + } +} + +function coinShiftRquest (data, marketData) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + shapeShiftRequest('shift', { method: 'POST', data}, (response) => { + dispatch(actions.hideLoadingIndication()) + if (response.error) return dispatch(actions.displayWarning(response.error)) + var message = ` + Deposit your ${response.depositType} to the address bellow:` + log.debug(`background.createShapeShiftTx`) + background.createShapeShiftTx(response.deposit, response.depositType) + dispatch(actions.showQrView(response.deposit, [message].concat(marketData))) + }) + } +} + +function buyWithShapeShift (data) { + return dispatch => new Promise((resolve, reject) => { + shapeShiftRequest('shift', { method: 'POST', data}, (response) => { + if (response.error) { + return reject(response.error) + } + background.createShapeShiftTx(response.deposit, response.depositType) + return resolve(response) + }) + }) +} + +function showQrView (data, message) { + return { + type: actions.SHOW_QR_VIEW, + value: { + message: message, + data: data, + }, + } +} +function reshowQrCode (data, coin) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + shapeShiftRequest('marketinfo', {pair: `${coin.toLowerCase()}_eth`}, (mktResponse) => { + if (mktResponse.error) return dispatch(actions.displayWarning(mktResponse.error)) + + var message = [ + `Deposit your ${coin} to the address bellow:`, + `Deposit Limit: ${mktResponse.limit}`, + `Deposit Minimum:${mktResponse.minimum}`, + ] + + dispatch(actions.hideLoadingIndication()) + return dispatch(actions.showQrView(data, message)) + }) + } +} + +function shapeShiftRequest (query, options, cb) { + var queryResponse, method + !options ? options = {} : null + options.method ? method = options.method : method = 'GET' + + var requestListner = function (request) { + try { + queryResponse = JSON.parse(this.responseText) + cb ? cb(queryResponse) : null + return queryResponse + } catch (e) { + cb ? cb({error: e}) : null + return e + } + } + + var shapShiftReq = new XMLHttpRequest() + shapShiftReq.addEventListener('load', requestListner) + shapShiftReq.open(method, `https://shapeshift.io/${query}/${options.pair ? options.pair : ''}`, true) + + if (options.method === 'POST') { + var jsonObj = JSON.stringify(options.data) + shapShiftReq.setRequestHeader('Content-Type', 'application/json') + return shapShiftReq.send(jsonObj) + } else { + return shapShiftReq.send() + } +} + +function setFeatureFlag (feature, activated) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + return new Promise((resolve, reject) => { + background.setFeatureFlag(feature, activated, (err, updatedFeatureFlags) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + dispatch(actions.displayWarning(err.message)) + reject(err) + } + dispatch(actions.updateFeatureFlags(updatedFeatureFlags)) + resolve(updatedFeatureFlags) + }) + }) + } +} + +function updateFeatureFlags (updatedFeatureFlags) { + return { + type: actions.UPDATE_FEATURE_FLAGS, + value: updatedFeatureFlags, + } +} + +// Call Background Then Update +// +// A function generator for a common pattern wherein: +// We show loading indication. +// We call a background method. +// We hide loading indication. +// If it errored, we show a warning. +// If it didn't, we update the state. +function callBackgroundThenUpdateNoSpinner (method, ...args) { + return (dispatch) => { + method.call(background, ...args, (err) => { + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + forceUpdateMetamaskState(dispatch) + }) + } +} + +function callBackgroundThenUpdate (method, ...args) { + return (dispatch) => { + dispatch(actions.showLoadingIndication()) + method.call(background, ...args, (err) => { + dispatch(actions.hideLoadingIndication()) + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + forceUpdateMetamaskState(dispatch) + }) + } +} + +function forceUpdateMetamaskState (dispatch) { + log.debug(`background.getState`) + background.getState((err, newState) => { + if (err) { + return dispatch(actions.displayWarning(err.message)) + } + dispatch(actions.updateMetamaskState(newState)) + }) +} diff --git a/old-ui/app/add-token.js b/old-ui/app/add-token.js new file mode 100644 index 000000000..9354a4cad --- /dev/null +++ b/old-ui/app/add-token.js @@ -0,0 +1,238 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') +const Tooltip = require('./components/tooltip.js') + + +const ethUtil = require('ethereumjs-util') +const abi = require('human-standard-token-abi') +const Eth = require('ethjs-query') +const EthContract = require('ethjs-contract') + +const emptyAddr = '0x0000000000000000000000000000000000000000' + +module.exports = connect(mapStateToProps)(AddTokenScreen) + +function mapStateToProps (state) { + return { + identities: state.metamask.identities, + } +} + +inherits(AddTokenScreen, Component) +function AddTokenScreen () { + this.state = { + warning: null, + address: null, + symbol: 'TOKEN', + decimals: 18, + } + Component.call(this) +} + +AddTokenScreen.prototype.render = function () { + const state = this.state + const props = this.props + const { warning, symbol, decimals } = state + + return ( + h('.flex-column.flex-grow', [ + + // subtitle and nav + h('.section-title.flex-row.flex-center', [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: (event) => { + props.dispatch(actions.goHome()) + }, + }), + h('h2.page-subtitle', 'Add Token'), + ]), + + h('.error', { + style: { + display: warning ? 'block' : 'none', + padding: '0 20px', + textAlign: 'center', + }, + }, warning), + + // conf view + h('.flex-column.flex-justify-center.flex-grow.select-none', [ + h('.flex-space-around', { + style: { + padding: '20px', + }, + }, [ + + h('div', [ + h(Tooltip, { + position: 'top', + title: 'The contract of the actual token contract. Click for more info.', + }, [ + h('a', { + style: { fontWeight: 'bold', paddingRight: '10px'}, + href: 'https://support.metamask.io/kb/article/24-what-is-a-token-contract-address', + target: '_blank', + }, [ + h('span', 'Token Contract Address '), + h('i.fa.fa-question-circle'), + ]), + ]), + ]), + + h('section.flex-row.flex-center', [ + h('input#token-address', { + name: 'address', + placeholder: 'Token Contract Address', + onChange: this.tokenAddressDidChange.bind(this), + style: { + width: 'inherit', + flex: '1 0 auto', + height: '30px', + margin: '8px', + }, + }), + ]), + + h('div', [ + h('span', { + style: { fontWeight: 'bold', paddingRight: '10px'}, + }, 'Token Symbol'), + ]), + + h('div', { style: {display: 'flex'} }, [ + h('input#token_symbol', { + placeholder: `Like "ETH"`, + value: symbol, + style: { + width: 'inherit', + flex: '1 0 auto', + height: '30px', + margin: '8px', + }, + onChange: (event) => { + var element = event.target + var symbol = element.value + this.setState({ symbol }) + }, + }), + ]), + + h('div', [ + h('span', { + style: { fontWeight: 'bold', paddingRight: '10px'}, + }, 'Decimals of Precision'), + ]), + + h('div', { style: {display: 'flex'} }, [ + h('input#token_decimals', { + value: decimals, + type: 'number', + min: 0, + max: 36, + style: { + width: 'inherit', + flex: '1 0 auto', + height: '30px', + margin: '8px', + }, + onChange: (event) => { + var element = event.target + var decimals = element.value.trim() + this.setState({ decimals }) + }, + }), + ]), + + h('button', { + style: { + alignSelf: 'center', + }, + onClick: (event) => { + const valid = this.validateInputs() + if (!valid) return + + const { address, symbol, decimals } = this.state + this.props.dispatch(actions.addToken(address.trim(), symbol.trim(), decimals)) + }, + }, 'Add'), + ]), + ]), + ]) + ) +} + +AddTokenScreen.prototype.componentWillMount = function () { + if (typeof global.ethereumProvider === 'undefined') return + + this.eth = new Eth(global.ethereumProvider) + this.contract = new EthContract(this.eth) + this.TokenContract = this.contract(abi) +} + +AddTokenScreen.prototype.tokenAddressDidChange = function (event) { + const el = event.target + const address = el.value.trim() + if (ethUtil.isValidAddress(address) && address !== emptyAddr) { + this.setState({ address }) + this.attemptToAutoFillTokenParams(address) + } +} + +AddTokenScreen.prototype.validateInputs = function () { + let msg = '' + const state = this.state + const identitiesList = Object.keys(this.props.identities) + const { address, symbol, decimals } = state + const standardAddress = ethUtil.addHexPrefix(address).toLowerCase() + + const validAddress = ethUtil.isValidAddress(address) + if (!validAddress) { + msg += 'Address is invalid. ' + } + + const validDecimals = decimals >= 0 && decimals < 36 + if (!validDecimals) { + msg += 'Decimals must be at least 0, and not over 36. ' + } + + const symbolLen = symbol.trim().length + const validSymbol = symbolLen > 0 && symbolLen < 10 + if (!validSymbol) { + msg += 'Symbol must be between 0 and 10 characters.' + } + + const ownAddress = identitiesList.includes(standardAddress) + if (ownAddress) { + msg = 'Personal address detected. Input the token contract address.' + } + + const isValid = validAddress && validDecimals && !ownAddress + + if (!isValid) { + this.setState({ + warning: msg, + }) + } else { + this.setState({ warning: null }) + } + + return isValid +} + +AddTokenScreen.prototype.attemptToAutoFillTokenParams = async function (address) { + const contract = this.TokenContract.at(address) + + const results = await Promise.all([ + contract.symbol(), + contract.decimals(), + ]) + + const [ symbol, decimals ] = results + if (symbol && decimals) { + console.log('SETTING SYMBOL AND DECIMALS', { symbol, decimals }) + this.setState({ symbol: symbol[0], decimals: decimals[0].toString() }) + } +} diff --git a/old-ui/app/app.js b/old-ui/app/app.js new file mode 100644 index 000000000..e3f72793c --- /dev/null +++ b/old-ui/app/app.js @@ -0,0 +1,680 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const connect = require('react-redux').connect +const h = require('react-hyperscript') +const actions = require('./actions') +// mascara +const MascaraFirstTime = require('../../mascara/src/app/first-time').default +const MascaraBuyEtherScreen = require('../../mascara/src/app/first-time/buy-ether-screen').default +// init +const InitializeMenuScreen = require('./first-time/init-menu') +const NewKeyChainScreen = require('./new-keychain') +// unlock +const UnlockScreen = require('./unlock') +// accounts +const AccountDetailScreen = require('./account-detail') +const SendTransactionScreen = require('./send') +const ConfirmTxScreen = require('./conf-tx') +// notice +const NoticeScreen = require('./components/notice') +const generateLostAccountsNotice = require('../lib/lost-accounts-notice') +// other views +const ConfigScreen = require('./config') +const AddTokenScreen = require('./add-token') +const Import = require('./accounts/import') +const InfoScreen = require('./info') +const Loading = require('./components/loading') +const SandwichExpando = require('sandwich-expando') +const Dropdown = require('./components/dropdown').Dropdown +const DropdownMenuItem = require('./components/dropdown').DropdownMenuItem +const NetworkIndicator = require('./components/network') +const BuyView = require('./components/buy-button-subview') +const QrView = require('./components/qr-code') +const HDCreateVaultComplete = require('./keychains/hd/create-vault-complete') +const HDRestoreVaultScreen = require('./keychains/hd/restore-vault') +const RevealSeedConfirmation = require('./keychains/hd/recover-seed/confirmation') +const AccountDropdowns = require('./components/account-dropdowns').AccountDropdowns + +module.exports = connect(mapStateToProps)(App) + +inherits(App, Component) +function App () { Component.call(this) } + +function mapStateToProps (state) { + const { + identities, + accounts, + address, + keyrings, + isInitialized, + noActiveNotices, + seedWords, + featureFlags, + } = state.metamask + const selected = address || Object.keys(accounts)[0] + + return { + // state from plugin + isLoading: state.appState.isLoading, + loadingMessage: state.appState.loadingMessage, + noActiveNotices: state.metamask.noActiveNotices, + isInitialized: state.metamask.isInitialized, + isUnlocked: state.metamask.isUnlocked, + currentView: state.appState.currentView, + activeAddress: state.appState.activeAddress, + transForward: state.appState.transForward, + isMascara: state.metamask.isMascara, + isOnboarding: Boolean(!noActiveNotices || seedWords || !isInitialized), + seedWords: state.metamask.seedWords, + unapprovedTxs: state.metamask.unapprovedTxs, + unapprovedMsgs: state.metamask.unapprovedMsgs, + menuOpen: state.appState.menuOpen, + network: state.metamask.network, + provider: state.metamask.provider, + forgottenPassword: state.appState.forgottenPassword, + lastUnreadNotice: state.metamask.lastUnreadNotice, + lostAccounts: state.metamask.lostAccounts, + frequentRpcList: state.metamask.frequentRpcList || [], + featureFlags, + + // state needed to get account dropdown temporarily rendering from app bar + identities, + selected, + keyrings, + } +} + +App.prototype.render = function () { + var props = this.props + const { isLoading, loadingMessage, transForward, network } = props + const isLoadingNetwork = network === 'loading' && props.currentView.name !== 'config' + const loadMessage = loadingMessage || isLoadingNetwork ? + `Connecting to ${this.getNetworkName()}` : null + log.debug('Main ui render function') + + return ( + + h('.flex-column.full-height', { + style: { + // Windows was showing a vertical scroll bar: + overflow: 'hidden', + position: 'relative', + alignItems: 'center', + }, + }, [ + + // app bar + this.renderAppBar(), + this.renderNetworkDropdown(), + this.renderDropdown(), + + this.renderLoadingIndicator({ isLoading, isLoadingNetwork, loadMessage }), + + // panel content + h('.app-primary' + (transForward ? '.from-right' : '.from-left'), { + style: { + width: '100%', + }, + }, [ + this.renderPrimary(), + ]), + ]) + ) +} + +App.prototype.renderAppBar = function () { + if (window.METAMASK_UI_TYPE === 'notification') { + return null + } + + const props = this.props + const state = this.state || {} + const isNetworkMenuOpen = state.isNetworkMenuOpen || false + const {isMascara, isOnboarding} = props + + // Do not render header if user is in mascara onboarding + if (isMascara && isOnboarding) { + return null + } + + // Do not render header if user is in mascara buy ether + if (isMascara && props.currentView.name === 'buyEth') { + return null + } + + return ( + + h('.full-width', { + height: '38px', + }, [ + + h('.app-header.flex-row.flex-space-between', { + style: { + alignItems: 'center', + visibility: props.isUnlocked ? 'visible' : 'none', + background: props.isUnlocked ? 'white' : 'none', + height: '38px', + position: 'relative', + zIndex: 12, + }, + }, [ + + h('div.left-menu-section', { + style: { + display: 'flex', + flexDirection: 'row', + alignItems: 'center', + }, + }, [ + + // mini logo + h('img', { + height: 24, + width: 24, + src: '/images/icon-128.png', + }), + + h(NetworkIndicator, { + network: this.props.network, + provider: this.props.provider, + onClick: (event) => { + event.preventDefault() + event.stopPropagation() + this.setState({ isNetworkMenuOpen: !isNetworkMenuOpen }) + }, + }), + ]), + + props.isUnlocked && h('div', { + style: { + display: 'flex', + flexDirection: 'row', + alignItems: 'center', + }, + }, [ + + props.isUnlocked && h(AccountDropdowns, { + style: {}, + enableAccountsSelector: true, + identities: this.props.identities, + selected: this.props.currentView.context, + network: this.props.network, + keyrings: this.props.keyrings, + }, []), + + // hamburger + props.isUnlocked && h(SandwichExpando, { + className: 'sandwich-expando', + width: 16, + barHeight: 2, + padding: 0, + isOpen: state.isMainMenuOpen, + color: 'rgb(247,146,30)', + onClick: () => { + this.setState({ + isMainMenuOpen: !state.isMainMenuOpen, + }) + }, + }), + ]), + ]), + ]) + ) +} + +App.prototype.renderNetworkDropdown = function () { + const props = this.props + const { provider: { type: providerType, rpcTarget: activeNetwork } } = props + const rpcList = props.frequentRpcList + const state = this.state || {} + const isOpen = state.isNetworkMenuOpen + + return h(Dropdown, { + useCssTransition: true, + isOpen, + onClickOutside: (event) => { + const { classList } = event.target + const isNotToggleElement = [ + classList.contains('menu-icon'), + classList.contains('network-name'), + classList.contains('network-indicator'), + ].filter(bool => bool).length === 0 + // classes from three constituent nodes of the toggle element + + if (isNotToggleElement) { + this.setState({ isNetworkMenuOpen: false }) + } + }, + zIndex: 11, + style: { + position: 'absolute', + left: '2px', + top: '36px', + }, + innerStyle: { + padding: '2px 16px 2px 0px', + }, + }, [ + + h( + DropdownMenuItem, + { + key: 'main', + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => props.dispatch(actions.setProviderType('mainnet')), + style: { + fontSize: '18px', + }, + }, + [ + h('.menu-icon.diamond'), + 'Main Ethereum Network', + providerType === 'mainnet' ? h('.check', '✓') : null, + ] + ), + + h( + DropdownMenuItem, + { + key: 'ropsten', + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => props.dispatch(actions.setProviderType('ropsten')), + style: { + fontSize: '18px', + }, + }, + [ + h('.menu-icon.red-dot'), + 'Ropsten Test Network', + providerType === 'ropsten' ? h('.check', '✓') : null, + ] + ), + + h( + DropdownMenuItem, + { + key: 'kovan', + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => props.dispatch(actions.setProviderType('kovan')), + style: { + fontSize: '18px', + }, + }, + [ + h('.menu-icon.hollow-diamond'), + 'Kovan Test Network', + providerType === 'kovan' ? h('.check', '✓') : null, + ] + ), + + h( + DropdownMenuItem, + { + key: 'rinkeby', + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => props.dispatch(actions.setProviderType('rinkeby')), + style: { + fontSize: '18px', + }, + }, + [ + h('.menu-icon.golden-square'), + 'Rinkeby Test Network', + providerType === 'rinkeby' ? h('.check', '✓') : null, + ] + ), + + h( + DropdownMenuItem, + { + key: 'default', + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => props.dispatch(actions.setProviderType('localhost')), + style: { + fontSize: '18px', + }, + }, + [ + h('i.fa.fa-question-circle.fa-lg.menu-icon'), + 'Localhost 8545', + activeNetwork === 'http://localhost:8545' ? h('.check', '✓') : null, + ] + ), + + this.renderCustomOption(props.provider), + this.renderCommonRpc(rpcList, props.provider), + + h( + DropdownMenuItem, + { + closeMenu: () => this.setState({ isNetworkMenuOpen: !isOpen }), + onClick: () => this.props.dispatch(actions.showConfigPage()), + style: { + fontSize: '18px', + }, + }, + [ + h('i.fa.fa-question-circle.fa-lg.menu-icon'), + 'Custom RPC', + activeNetwork === 'custom' ? h('.check', '✓') : null, + ] + ), + + ]) +} + +App.prototype.renderDropdown = function () { + const state = this.state || {} + const isOpen = state.isMainMenuOpen + + return h(Dropdown, { + useCssTransition: true, + isOpen: isOpen, + zIndex: 11, + onClickOutside: (event) => { + const classList = event.target.classList + const parentClassList = event.target.parentElement.classList + + const isToggleElement = classList.contains('sandwich-expando') || + parentClassList.contains('sandwich-expando') + + if (isOpen && !isToggleElement) { + this.setState({ isMainMenuOpen: false }) + } + }, + style: { + position: 'absolute', + right: '2px', + top: '38px', + }, + innerStyle: {}, + }, [ + h(DropdownMenuItem, { + closeMenu: () => this.setState({ isMainMenuOpen: !isOpen }), + onClick: () => { this.props.dispatch(actions.showConfigPage()) }, + }, 'Settings'), + + h(DropdownMenuItem, { + closeMenu: () => this.setState({ isMainMenuOpen: !isOpen }), + onClick: () => { this.props.dispatch(actions.lockMetamask()) }, + }, 'Lock'), + + h(DropdownMenuItem, { + closeMenu: () => this.setState({ isMainMenuOpen: !isOpen }), + onClick: () => { this.props.dispatch(actions.showInfoPage()) }, + }, 'Info/Help'), + + h(DropdownMenuItem, { + closeMenu: () => this.setState({ isMainMenuOpen: !isOpen }), + onClick: () => { this.props.dispatch(actions.setFeatureFlag('betaUI', true)) }, + }, 'Try Beta!'), + ]) +} + +App.prototype.renderLoadingIndicator = function ({ isLoading, isLoadingNetwork, loadMessage }) { + const { isMascara } = this.props + + return isMascara + ? null + : h(Loading, { + isLoading: isLoading || isLoadingNetwork, + loadingMessage: loadMessage, + }) +} + +App.prototype.renderBackButton = function (style, justArrow = false) { + var props = this.props + return ( + h('.flex-row', { + key: 'leftArrow', + style: style, + onClick: () => props.dispatch(actions.goBackToInitView()), + }, [ + h('i.fa.fa-arrow-left.cursor-pointer'), + justArrow ? null : h('div.cursor-pointer', { + style: { + marginLeft: '3px', + }, + onClick: () => props.dispatch(actions.goBackToInitView()), + }, 'BACK'), + ]) + ) +} + +App.prototype.renderPrimary = function () { + log.debug('rendering primary') + var props = this.props + const {isMascara, isOnboarding} = props + + if (isMascara && isOnboarding) { + return h(MascaraFirstTime) + } + + // notices + if (!props.noActiveNotices) { + log.debug('rendering notice screen for unread notices.') + return h(NoticeScreen, { + notice: props.lastUnreadNotice, + key: 'NoticeScreen', + onConfirm: () => props.dispatch(actions.markNoticeRead(props.lastUnreadNotice)), + }) + } else if (props.lostAccounts && props.lostAccounts.length > 0) { + log.debug('rendering notice screen for lost accounts view.') + return h(NoticeScreen, { + notice: generateLostAccountsNotice(props.lostAccounts), + key: 'LostAccountsNotice', + onConfirm: () => props.dispatch(actions.markAccountsFound()), + }) + } + + if (props.seedWords) { + log.debug('rendering seed words') + return h(HDCreateVaultComplete, {key: 'HDCreateVaultComplete'}) + } + + // show initialize screen + if (!props.isInitialized || props.forgottenPassword) { + // show current view + log.debug('rendering an initialize screen') + switch (props.currentView.name) { + + case 'restoreVault': + log.debug('rendering restore vault screen') + return h(HDRestoreVaultScreen, {key: 'HDRestoreVaultScreen'}) + + default: + log.debug('rendering menu screen') + return h(InitializeMenuScreen, {key: 'menuScreenInit'}) + } + } + + // show unlock screen + if (!props.isUnlocked) { + switch (props.currentView.name) { + + case 'restoreVault': + log.debug('rendering restore vault screen') + return h(HDRestoreVaultScreen, {key: 'HDRestoreVaultScreen'}) + + case 'config': + log.debug('rendering config screen from unlock screen.') + return h(ConfigScreen, {key: 'config'}) + + default: + log.debug('rendering locked screen') + return h(UnlockScreen, {key: 'locked'}) + } + } + + // show current view + switch (props.currentView.name) { + + case 'accountDetail': + log.debug('rendering account detail screen') + return h(AccountDetailScreen, {key: 'account-detail'}) + + case 'sendTransaction': + log.debug('rendering send tx screen') + return h(SendTransactionScreen, {key: 'send-transaction'}) + + case 'newKeychain': + log.debug('rendering new keychain screen') + return h(NewKeyChainScreen, {key: 'new-keychain'}) + + case 'confTx': + log.debug('rendering confirm tx screen') + return h(ConfirmTxScreen, {key: 'confirm-tx'}) + + case 'add-token': + log.debug('rendering add-token screen from unlock screen.') + return h(AddTokenScreen, {key: 'add-token'}) + + case 'config': + log.debug('rendering config screen') + return h(ConfigScreen, {key: 'config'}) + + case 'import-menu': + log.debug('rendering import screen') + return h(Import, {key: 'import-menu'}) + + case 'reveal-seed-conf': + log.debug('rendering reveal seed confirmation screen') + return h(RevealSeedConfirmation, {key: 'reveal-seed-conf'}) + + case 'info': + log.debug('rendering info screen') + return h(InfoScreen, {key: 'info'}) + + case 'buyEth': + log.debug('rendering buy ether screen') + return h(BuyView, {key: 'buyEthView'}) + + case 'onboardingBuyEth': + log.debug('rendering onboarding buy ether screen') + return h(MascaraBuyEtherScreen, {key: 'buyEthView'}) + + case 'qr': + log.debug('rendering show qr screen') + return h('div', { + style: { + position: 'absolute', + height: '100%', + top: '0px', + left: '0px', + }, + }, [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer.color-orange', { + onClick: () => props.dispatch(actions.backToAccountDetail(props.activeAddress)), + style: { + marginLeft: '10px', + marginTop: '50px', + }, + }), + h('div', { + style: { + position: 'absolute', + left: '44px', + width: '285px', + }, + }, [ + h(QrView, {key: 'qr'}), + ]), + ]) + + default: + log.debug('rendering default, account detail screen') + return h(AccountDetailScreen, {key: 'account-detail'}) + } +} + +App.prototype.toggleMetamaskActive = function () { + if (!this.props.isUnlocked) { + // currently inactive: redirect to password box + var passwordBox = document.querySelector('input[type=password]') + if (!passwordBox) return + passwordBox.focus() + } else { + // currently active: deactivate + this.props.dispatch(actions.lockMetamask(false)) + } +} + +App.prototype.renderCustomOption = function (provider) { + const { rpcTarget, type } = provider + const props = this.props + + if (type !== 'rpc') return null + + // Concatenate long URLs + let label = rpcTarget + if (rpcTarget.length > 31) { + label = label.substr(0, 34) + '...' + } + + switch (rpcTarget) { + + case 'http://localhost:8545': + return null + + default: + return h( + DropdownMenuItem, + { + key: rpcTarget, + onClick: () => props.dispatch(actions.setRpcTarget(rpcTarget)), + closeMenu: () => this.setState({ isNetworkMenuOpen: false }), + }, + [ + h('i.fa.fa-question-circle.fa-lg.menu-icon'), + label, + h('.check', '✓'), + ] + ) + } +} + +App.prototype.getNetworkName = function () { + const { provider } = this.props + const providerName = provider.type + + let name + + if (providerName === 'mainnet') { + name = 'Main Ethereum Network' + } else if (providerName === 'ropsten') { + name = 'Ropsten Test Network' + } else if (providerName === 'kovan') { + name = 'Kovan Test Network' + } else if (providerName === 'rinkeby') { + name = 'Rinkeby Test Network' + } else { + name = 'Unknown Private Network' + } + + return name +} + +App.prototype.renderCommonRpc = function (rpcList, provider) { + const props = this.props + const rpcTarget = provider.rpcTarget + + return rpcList.map((rpc) => { + if ((rpc === 'http://localhost:8545') || (rpc === rpcTarget)) { + return null + } else { + return h( + DropdownMenuItem, + { + key: `common${rpc}`, + closeMenu: () => this.setState({ isNetworkMenuOpen: false }), + onClick: () => props.dispatch(actions.setRpcTarget(rpc)), + }, + [ + h('i.fa.fa-question-circle.fa-lg.menu-icon'), + rpc, + rpcTarget === rpc ? h('.check', '✓') : null, + ] + ) + } + }) +} diff --git a/old-ui/app/components/account-dropdowns.js b/old-ui/app/components/account-dropdowns.js new file mode 100644 index 000000000..0c34a5154 --- /dev/null +++ b/old-ui/app/components/account-dropdowns.js @@ -0,0 +1,320 @@ +const Component = require('react').Component +const PropTypes = require('react').PropTypes +const h = require('react-hyperscript') +const actions = require('../actions') +const genAccountLink = require('etherscan-link').createAccountLink +const connect = require('react-redux').connect +const Dropdown = require('./dropdown').Dropdown +const DropdownMenuItem = require('./dropdown').DropdownMenuItem +const Identicon = require('./identicon') +const ethUtil = require('ethereumjs-util') +const copyToClipboard = require('copy-to-clipboard') + +class AccountDropdowns extends Component { + constructor (props) { + super(props) + this.state = { + accountSelectorActive: false, + optionsMenuActive: false, + } + this.accountSelectorToggleClassName = 'accounts-selector' + this.optionsMenuToggleClassName = 'fa-ellipsis-h' + } + + renderAccounts () { + const { identities, selected, keyrings } = this.props + + return Object.keys(identities).map((key, index) => { + const identity = identities[key] + const isSelected = identity.address === selected + + const simpleAddress = identity.address.substring(2).toLowerCase() + + const keyring = keyrings.find((kr) => { + return kr.accounts.includes(simpleAddress) || + kr.accounts.includes(identity.address) + }) + + return h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => { + this.props.actions.showAccountDetail(identity.address) + }, + style: { + marginTop: index === 0 ? '5px' : '', + fontSize: '24px', + }, + }, + [ + h( + Identicon, + { + address: identity.address, + diameter: 32, + style: { + marginLeft: '10px', + }, + }, + ), + this.indicateIfLoose(keyring), + h('span', { + style: { + marginLeft: '20px', + fontSize: '24px', + maxWidth: '145px', + whiteSpace: 'nowrap', + overflow: 'hidden', + textOverflow: 'ellipsis', + }, + }, identity.name || ''), + h('span', { style: { marginLeft: '20px', fontSize: '24px' } }, isSelected ? h('.check', '✓') : null), + ] + ) + }) + } + + indicateIfLoose (keyring) { + try { // Sometimes keyrings aren't loaded yet: + const type = keyring.type + const isLoose = type !== 'HD Key Tree' + return isLoose ? h('.keyring-label', 'LOOSE') : null + } catch (e) { return } + } + + renderAccountSelector () { + const { actions } = this.props + const { accountSelectorActive } = this.state + + return h( + Dropdown, + { + useCssTransition: true, // Hardcoded because account selector is temporarily in app-header + style: { + marginLeft: '-238px', + marginTop: '38px', + minWidth: '180px', + overflowY: 'auto', + maxHeight: '300px', + width: '300px', + }, + innerStyle: { + padding: '8px 25px', + }, + isOpen: accountSelectorActive, + onClickOutside: (event) => { + const { classList } = event.target + const isNotToggleElement = !classList.contains(this.accountSelectorToggleClassName) + if (accountSelectorActive && isNotToggleElement) { + this.setState({ accountSelectorActive: false }) + } + }, + }, + [ + ...this.renderAccounts(), + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => actions.addNewAccount(), + }, + [ + h( + Identicon, + { + style: { + marginLeft: '10px', + }, + diameter: 32, + }, + ), + h('span', { style: { marginLeft: '20px', fontSize: '24px' } }, 'Create Account'), + ], + ), + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => actions.showImportPage(), + }, + [ + h( + Identicon, + { + style: { + marginLeft: '10px', + }, + diameter: 32, + }, + ), + h('span', { + style: { + marginLeft: '20px', + fontSize: '24px', + marginBottom: '5px', + }, + }, 'Import Account'), + ] + ), + ] + ) + } + + renderAccountOptions () { + const { actions } = this.props + const { optionsMenuActive } = this.state + + return h( + Dropdown, + { + style: { + marginLeft: '-215px', + minWidth: '180px', + }, + isOpen: optionsMenuActive, + onClickOutside: () => { + const { classList } = event.target + const isNotToggleElement = !classList.contains(this.optionsMenuToggleClassName) + if (optionsMenuActive && isNotToggleElement) { + this.setState({ optionsMenuActive: false }) + } + }, + }, + [ + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => { + const { selected, network } = this.props + const url = genAccountLink(selected, network) + global.platform.openWindow({ url }) + }, + }, + 'View account on Etherscan', + ), + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => { + const { selected, identities } = this.props + var identity = identities[selected] + actions.showQrView(selected, identity ? identity.name : '') + }, + }, + 'Show QR Code', + ), + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => { + const { selected } = this.props + const checkSumAddress = selected && ethUtil.toChecksumAddress(selected) + copyToClipboard(checkSumAddress) + }, + }, + 'Copy Address to clipboard', + ), + h( + DropdownMenuItem, + { + closeMenu: () => {}, + onClick: () => { + actions.requestAccountExport() + }, + }, + 'Export Private Key', + ), + ] + ) + } + + render () { + const { style, enableAccountsSelector, enableAccountOptions } = this.props + const { optionsMenuActive, accountSelectorActive } = this.state + + return h( + 'span', + { + style: style, + }, + [ + enableAccountsSelector && h( + // 'i.fa.fa-angle-down', + 'div.cursor-pointer.color-orange.accounts-selector', + { + style: { + // fontSize: '1.8em', + background: 'url(images/switch_acc.svg) white center center no-repeat', + height: '25px', + width: '25px', + transform: 'scale(0.75)', + marginRight: '3px', + }, + onClick: (event) => { + event.stopPropagation() + this.setState({ + accountSelectorActive: !accountSelectorActive, + optionsMenuActive: false, + }) + }, + }, + this.renderAccountSelector(), + ), + enableAccountOptions && h( + 'i.fa.fa-ellipsis-h', + { + style: { + marginRight: '0.5em', + fontSize: '1.8em', + }, + onClick: (event) => { + event.stopPropagation() + this.setState({ + accountSelectorActive: false, + optionsMenuActive: !optionsMenuActive, + }) + }, + }, + this.renderAccountOptions() + ), + ] + ) + } +} + +AccountDropdowns.defaultProps = { + enableAccountsSelector: false, + enableAccountOptions: false, +} + +AccountDropdowns.propTypes = { + identities: PropTypes.objectOf(PropTypes.object), + selected: PropTypes.string, + keyrings: PropTypes.array, + actions: PropTypes.objectOf(PropTypes.func), + network: PropTypes.string, + style: PropTypes.object, + enableAccountOptions: PropTypes.bool, + enableAccountsSelector: PropTypes.bool, +} + +const mapDispatchToProps = (dispatch) => { + return { + actions: { + showConfigPage: () => dispatch(actions.showConfigPage()), + requestAccountExport: () => dispatch(actions.requestExportAccount()), + showAccountDetail: (address) => dispatch(actions.showAccountDetail(address)), + addNewAccount: () => dispatch(actions.addNewAccount()), + showImportPage: () => dispatch(actions.showImportPage()), + showQrView: (selected, identity) => dispatch(actions.showQrView(selected, identity)), + }, + } +} + +module.exports = { + AccountDropdowns: connect(null, mapDispatchToProps)(AccountDropdowns), +} diff --git a/old-ui/app/components/account-export.js b/old-ui/app/components/account-export.js new file mode 100644 index 000000000..32b103c86 --- /dev/null +++ b/old-ui/app/components/account-export.js @@ -0,0 +1,132 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const exportAsFile = require('../util').exportAsFile +const copyToClipboard = require('copy-to-clipboard') +const actions = require('../actions') +const ethUtil = require('ethereumjs-util') +const connect = require('react-redux').connect + +module.exports = connect(mapStateToProps)(ExportAccountView) + +inherits(ExportAccountView, Component) +function ExportAccountView () { + Component.call(this) +} + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + } +} + +ExportAccountView.prototype.render = function () { + const state = this.props + const accountDetail = state.accountDetail + const nickname = state.identities[state.address].name + + if (!accountDetail) return h('div') + const accountExport = accountDetail.accountExport + + const notExporting = accountExport === 'none' + const exportRequested = accountExport === 'requested' + const accountExported = accountExport === 'completed' + + if (notExporting) return h('div') + + if (exportRequested) { + const warning = `Export private keys at your own risk.` + return ( + h('div', { + style: { + display: 'inline-block', + textAlign: 'center', + }, + }, + [ + h('div', { + key: 'exporting', + style: { + margin: '0 20px', + }, + }, [ + h('p.error', warning), + h('input#exportAccount.sizing-input', { + type: 'password', + placeholder: 'confirm password', + onKeyPress: this.onExportKeyPress.bind(this), + style: { + position: 'relative', + top: '1.5px', + marginBottom: '7px', + }, + }), + ]), + h('div', { + key: 'buttons', + style: { + margin: '0 20px', + }, + }, + [ + h('button', { + onClick: () => this.onExportKeyPress({ key: 'Enter', preventDefault: () => {} }), + style: { + marginRight: '10px', + }, + }, 'Submit'), + h('button', { + onClick: () => this.props.dispatch(actions.backToAccountDetail(this.props.address)), + }, 'Cancel'), + ]), + (this.props.warning) && ( + h('span.error', { + style: { + margin: '20px', + }, + }, this.props.warning.split('-')) + ), + ]) + ) + } + + if (accountExported) { + const plainKey = ethUtil.stripHexPrefix(accountDetail.privateKey) + + return h('div.privateKey', { + style: { + margin: '0 20px', + }, + }, [ + h('label', 'Your private key (click to copy):'), + h('p.error.cursor-pointer', { + style: { + textOverflow: 'ellipsis', + overflow: 'hidden', + webkitUserSelect: 'text', + maxWidth: '275px', + }, + onClick: function (event) { + copyToClipboard(ethUtil.stripHexPrefix(accountDetail.privateKey)) + }, + }, plainKey), + h('button', { + onClick: () => this.props.dispatch(actions.backToAccountDetail(this.props.address)), + }, 'Done'), + h('button', { + style: { + marginLeft: '10px', + }, + onClick: () => exportAsFile(`MetaMask ${nickname} Private Key`, plainKey), + }, 'Save as File'), + ]) + } +} + +ExportAccountView.prototype.onExportKeyPress = function (event) { + if (event.key !== 'Enter') return + event.preventDefault() + + const input = document.getElementById('exportAccount').value + this.props.dispatch(actions.exportAccount(input, this.props.address)) +} diff --git a/old-ui/app/components/account-panel.js b/old-ui/app/components/account-panel.js new file mode 100644 index 000000000..abaaf8163 --- /dev/null +++ b/old-ui/app/components/account-panel.js @@ -0,0 +1,86 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const Identicon = require('./identicon') +const formatBalance = require('../util').formatBalance +const addressSummary = require('../util').addressSummary + +module.exports = AccountPanel + + +inherits(AccountPanel, Component) +function AccountPanel () { + Component.call(this) +} + +AccountPanel.prototype.render = function () { + var state = this.props + var identity = state.identity || {} + var account = state.account || {} + var isFauceting = state.isFauceting + + var panelState = { + key: `accountPanel${identity.address}`, + identiconKey: identity.address, + identiconLabel: identity.name || '', + attributes: [ + { + key: 'ADDRESS', + value: addressSummary(identity.address), + }, + balanceOrFaucetingIndication(account, isFauceting), + ], + } + + return ( + + h('.identity-panel.flex-row.flex-space-between', { + style: { + flex: '1 0 auto', + cursor: panelState.onClick ? 'pointer' : undefined, + }, + onClick: panelState.onClick, + }, [ + + // account identicon + h('.identicon-wrapper.flex-column.select-none', [ + h(Identicon, { + address: panelState.identiconKey, + imageify: state.imageifyIdenticons, + }), + h('span.font-small', panelState.identiconLabel.substring(0, 7) + '...'), + ]), + + // account address, balance + h('.identity-data.flex-column.flex-justify-center.flex-grow.select-none', [ + + panelState.attributes.map((attr) => { + return h('.flex-row.flex-space-between', { + key: '' + Math.round(Math.random() * 1000000), + }, [ + h('label.font-small.no-select', attr.key), + h('span.font-small', attr.value), + ]) + }), + ]), + + ]) + + ) +} + +function balanceOrFaucetingIndication (account, isFauceting) { + // Temporarily deactivating isFauceting indication + // because it shows fauceting for empty restored accounts. + if (/* isFauceting*/ false) { + return { + key: 'Account is auto-funding.', + value: 'Please wait.', + } + } else { + return { + key: 'BALANCE', + value: formatBalance(account.balance), + } + } +} diff --git a/old-ui/app/components/balance.js b/old-ui/app/components/balance.js new file mode 100644 index 000000000..57ca84564 --- /dev/null +++ b/old-ui/app/components/balance.js @@ -0,0 +1,89 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const formatBalance = require('../util').formatBalance +const generateBalanceObject = require('../util').generateBalanceObject +const Tooltip = require('./tooltip.js') +const FiatValue = require('./fiat-value.js') + +module.exports = EthBalanceComponent + +inherits(EthBalanceComponent, Component) +function EthBalanceComponent () { + Component.call(this) +} + +EthBalanceComponent.prototype.render = function () { + var props = this.props + let { value } = props + var style = props.style + var needsParse = this.props.needsParse !== undefined ? this.props.needsParse : true + value = value ? formatBalance(value, 6, needsParse) : '...' + var width = props.width + + return ( + + h('.ether-balance.ether-balance-amount', { + style: style, + }, [ + h('div', { + style: { + display: 'inline', + width: width, + }, + }, this.renderBalance(value)), + ]) + + ) +} +EthBalanceComponent.prototype.renderBalance = function (value) { + var props = this.props + if (value === 'None') return value + if (value === '...') return value + var balanceObj = generateBalanceObject(value, props.shorten ? 1 : 3) + var balance + var splitBalance = value.split(' ') + var ethNumber = splitBalance[0] + var ethSuffix = splitBalance[1] + const showFiat = 'showFiat' in props ? props.showFiat : true + + if (props.shorten) { + balance = balanceObj.shortBalance + } else { + balance = balanceObj.balance + } + + var label = balanceObj.label + + return ( + h(Tooltip, { + position: 'bottom', + title: `${ethNumber} ${ethSuffix}`, + }, h('div.flex-column', [ + h('.flex-row', { + style: { + alignItems: 'flex-end', + lineHeight: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + }, + }, [ + h('div', { + style: { + width: '100%', + textAlign: 'right', + }, + }, this.props.incoming ? `+${balance}` : balance), + h('div', { + style: { + color: ' #AEAEAE', + fontSize: '12px', + marginLeft: '5px', + }, + }, label), + ]), + + showFiat ? h(FiatValue, { value: props.value }) : null, + ])) + ) +} diff --git a/old-ui/app/components/binary-renderer.js b/old-ui/app/components/binary-renderer.js new file mode 100644 index 000000000..0b6a1f5c2 --- /dev/null +++ b/old-ui/app/components/binary-renderer.js @@ -0,0 +1,46 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const ethUtil = require('ethereumjs-util') +const extend = require('xtend') + +module.exports = BinaryRenderer + +inherits(BinaryRenderer, Component) +function BinaryRenderer () { + Component.call(this) +} + +BinaryRenderer.prototype.render = function () { + const props = this.props + const { value, style } = props + const text = this.hexToText(value) + + const defaultStyle = extend({ + width: '315px', + maxHeight: '210px', + resize: 'none', + border: 'none', + background: 'white', + padding: '3px', + }, style) + + return ( + h('textarea.font-small', { + readOnly: true, + style: defaultStyle, + defaultValue: text, + }) + ) +} + +BinaryRenderer.prototype.hexToText = function (hex) { + try { + const stripped = ethUtil.stripHexPrefix(hex) + const buff = Buffer.from(stripped, 'hex') + return buff.toString('utf8') + } catch (e) { + return hex + } +} + diff --git a/old-ui/app/components/bn-as-decimal-input.js b/old-ui/app/components/bn-as-decimal-input.js new file mode 100644 index 000000000..22e37602e --- /dev/null +++ b/old-ui/app/components/bn-as-decimal-input.js @@ -0,0 +1,181 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const ethUtil = require('ethereumjs-util') +const BN = ethUtil.BN +const extend = require('xtend') + +module.exports = BnAsDecimalInput + +inherits(BnAsDecimalInput, Component) +function BnAsDecimalInput () { + this.state = { invalid: null } + Component.call(this) +} + +/* Bn as Decimal Input + * + * A component for allowing easy, decimal editing + * of a passed in bn string value. + * + * On change, calls back its `onChange` function parameter + * and passes it an updated bn string. + */ + +BnAsDecimalInput.prototype.render = function () { + const props = this.props + const state = this.state + + const { value, scale, precision, onChange, min, max } = props + + const suffix = props.suffix + const style = props.style + const valueString = value.toString(10) + const newMin = min && this.downsize(min.toString(10), scale) + const newMax = max && this.downsize(max.toString(10), scale) + const newValue = this.downsize(valueString, scale) + + return ( + h('.flex-column', [ + h('.flex-row', { + style: { + alignItems: 'flex-end', + lineHeight: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + }, + }, [ + h('input.hex-input', { + type: 'number', + step: 'any', + required: true, + min: newMin, + max: newMax, + style: extend({ + display: 'block', + textAlign: 'right', + backgroundColor: 'transparent', + border: '1px solid #bdbdbd', + + }, style), + value: newValue, + onBlur: (event) => { + this.updateValidity(event) + }, + onChange: (event) => { + this.updateValidity(event) + const value = (event.target.value === '') ? '' : event.target.value + + + const scaledNumber = this.upsize(value, scale, precision) + const precisionBN = new BN(scaledNumber, 10) + onChange(precisionBN, event.target.checkValidity()) + }, + onInvalid: (event) => { + const msg = this.constructWarning() + if (msg === state.invalid) { + return + } + this.setState({ invalid: msg }) + event.preventDefault() + return false + }, + }), + h('div', { + style: { + color: ' #AEAEAE', + fontSize: '12px', + marginLeft: '5px', + marginRight: '6px', + width: '20px', + }, + }, suffix), + ]), + + state.invalid ? h('span.error', { + style: { + position: 'absolute', + right: '0px', + textAlign: 'right', + transform: 'translateY(26px)', + padding: '3px', + background: 'rgba(255,255,255,0.85)', + zIndex: '1', + textTransform: 'capitalize', + border: '2px solid #E20202', + }, + }, state.invalid) : null, + ]) + ) +} + +BnAsDecimalInput.prototype.setValid = function (message) { + this.setState({ invalid: null }) +} + +BnAsDecimalInput.prototype.updateValidity = function (event) { + const target = event.target + const value = this.props.value + const newValue = target.value + + if (value === newValue) { + return + } + + const valid = target.checkValidity() + + if (valid) { + this.setState({ invalid: null }) + } +} + +BnAsDecimalInput.prototype.constructWarning = function () { + const { name, min, max, scale, suffix } = this.props + const newMin = min && this.downsize(min.toString(10), scale) + const newMax = max && this.downsize(max.toString(10), scale) + let message = name ? name + ' ' : '' + + if (min && max) { + message += `must be greater than or equal to ${newMin} ${suffix} and less than or equal to ${newMax} ${suffix}.` + } else if (min) { + message += `must be greater than or equal to ${newMin} ${suffix}.` + } else if (max) { + message += `must be less than or equal to ${newMax} ${suffix}.` + } else { + message += 'Invalid input.' + } + + return message +} + + +BnAsDecimalInput.prototype.downsize = function (number, scale) { + // if there is no scaling, simply return the number + if (scale === 0) { + return Number(number) + } else { + // if the scale is the same as the precision, account for this edge case. + var adjustedNumber = number + while (adjustedNumber.length < scale) { + adjustedNumber = '0' + adjustedNumber + } + return Number(adjustedNumber.slice(0, -scale) + '.' + adjustedNumber.slice(-scale)) + } +} + +BnAsDecimalInput.prototype.upsize = function (number, scale, precision) { + var stringArray = number.toString().split('.') + var decimalLength = stringArray[1] ? stringArray[1].length : 0 + var newString = stringArray[0] + + // If there is scaling and decimal parts exist, integrate them in. + if ((scale !== 0) && (decimalLength !== 0)) { + newString += stringArray[1].slice(0, precision) + } + + // Add 0s to account for the upscaling. + for (var i = decimalLength; i < scale; i++) { + newString += '0' + } + return newString +} diff --git a/old-ui/app/components/buy-button-subview.js b/old-ui/app/components/buy-button-subview.js new file mode 100644 index 000000000..15281171c --- /dev/null +++ b/old-ui/app/components/buy-button-subview.js @@ -0,0 +1,261 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const connect = require('react-redux').connect +const actions = require('../actions') +const CoinbaseForm = require('./coinbase-form') +const ShapeshiftForm = require('./shapeshift-form') +const Loading = require('./loading') +const AccountPanel = require('./account-panel') +const RadioList = require('./custom-radio-list') +const networkNames = require('../../../app/scripts/config.js').networkNames + +module.exports = connect(mapStateToProps)(BuyButtonSubview) + +function mapStateToProps (state) { + return { + identity: state.appState.identity, + account: state.metamask.accounts[state.appState.buyView.buyAddress], + warning: state.appState.warning, + buyView: state.appState.buyView, + network: state.metamask.network, + provider: state.metamask.provider, + context: state.appState.currentView.context, + isSubLoading: state.appState.isSubLoading, + } +} + +inherits(BuyButtonSubview, Component) +function BuyButtonSubview () { + Component.call(this) +} + +BuyButtonSubview.prototype.render = function () { + return ( + h('div', { + style: { + width: '100%', + }, + }, [ + this.headerSubview(), + this.primarySubview(), + ]) + ) +} + +BuyButtonSubview.prototype.headerSubview = function () { + const props = this.props + const isLoading = props.isSubLoading + return ( + + h('.flex-column', { + style: { + alignItems: 'center', + }, + }, [ + + // header bar (back button, label) + h('.flex-row', { + style: { + alignItems: 'center', + justifyContent: 'center', + }, + }, [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer.color-orange', { + onClick: this.backButtonContext.bind(this), + style: { + position: 'absolute', + left: '10px', + }, + }), + h('h2.text-transform-uppercase.flex-center', { + style: { + width: '100vw', + background: 'rgb(235, 235, 235)', + color: 'rgb(174, 174, 174)', + paddingTop: '4px', + paddingBottom: '4px', + }, + }, 'Buy Eth'), + ]), + + // loading indication + h('div', { + style: { + position: 'absolute', + top: '57vh', + left: '49vw', + }, + }, [ + h(Loading, { isLoading }), + ]), + + // account panel + h('div', { + style: { + width: '80%', + }, + }, [ + h(AccountPanel, { + showFullAddress: true, + identity: props.identity, + account: props.account, + }), + ]), + + h('.flex-row', { + style: { + alignItems: 'center', + justifyContent: 'center', + }, + }, [ + h('h3.text-transform-uppercase.flex-center', { + style: { + paddingLeft: '15px', + width: '100vw', + background: 'rgb(235, 235, 235)', + color: 'rgb(174, 174, 174)', + paddingTop: '4px', + paddingBottom: '4px', + }, + }, 'Select Service'), + ]), + + ]) + + ) +} + + +BuyButtonSubview.prototype.primarySubview = function () { + const props = this.props + const network = props.network + + switch (network) { + case 'loading': + return + + case '1': + return this.mainnetSubview() + + // Ropsten, Rinkeby, Kovan + case '3': + case '4': + case '42': + const networkName = networkNames[network] + const label = `${networkName} Test Faucet` + return ( + h('div.flex-column', { + style: { + alignItems: 'center', + margin: '20px 50px', + }, + }, [ + h('button.text-transform-uppercase', { + onClick: () => this.props.dispatch(actions.buyEth({ network })), + style: { + marginTop: '15px', + }, + }, label), + // Kovan only: Dharma loans beta + network === '42' ? ( + h('button.text-transform-uppercase', { + onClick: () => this.navigateTo('https://borrow.dharma.io/'), + style: { + marginTop: '15px', + }, + }, 'Borrow With Dharma (Beta)') + ) : null, + ]) + ) + + default: + return ( + h('h2.error', 'Unknown network ID') + ) + + } +} + +BuyButtonSubview.prototype.mainnetSubview = function () { + const props = this.props + + return ( + + h('.flex-column', { + style: { + alignItems: 'center', + }, + }, [ + + h('.flex-row.selected-exchange', { + style: { + position: 'relative', + right: '35px', + marginTop: '20px', + marginBottom: '20px', + }, + }, [ + h(RadioList, { + defaultFocus: props.buyView.subview, + labels: [ + 'Coinbase', + 'ShapeShift', + ], + subtext: { + 'Coinbase': 'Crypto/FIAT (USA only)', + 'ShapeShift': 'Crypto', + }, + onClick: this.radioHandler.bind(this), + }), + ]), + + h('h3.text-transform-uppercase', { + style: { + paddingLeft: '15px', + fontFamily: 'Montserrat Light', + width: '100vw', + background: 'rgb(235, 235, 235)', + color: 'rgb(174, 174, 174)', + paddingTop: '4px', + paddingBottom: '4px', + }, + }, props.buyView.subview), + + this.formVersionSubview(), + ]) + + ) +} + +BuyButtonSubview.prototype.formVersionSubview = function () { + const network = this.props.network + if (network === '1') { + if (this.props.buyView.formView.coinbase) { + return h(CoinbaseForm, this.props) + } else if (this.props.buyView.formView.shapeshift) { + return h(ShapeshiftForm, this.props) + } + } +} + +BuyButtonSubview.prototype.navigateTo = function (url) { + global.platform.openWindow({ url }) +} + +BuyButtonSubview.prototype.backButtonContext = function () { + if (this.props.context === 'confTx') { + this.props.dispatch(actions.showConfTxPage(false)) + } else { + this.props.dispatch(actions.goHome()) + } +} + +BuyButtonSubview.prototype.radioHandler = function (event) { + switch (event.target.title) { + case 'Coinbase': + return this.props.dispatch(actions.coinBaseSubview()) + case 'ShapeShift': + return this.props.dispatch(actions.shapeShiftSubview(this.props.provider.type)) + } +} diff --git a/old-ui/app/components/coinbase-form.js b/old-ui/app/components/coinbase-form.js new file mode 100644 index 000000000..f44d86045 --- /dev/null +++ b/old-ui/app/components/coinbase-form.js @@ -0,0 +1,63 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const connect = require('react-redux').connect +const actions = require('../actions') + +module.exports = connect(mapStateToProps)(CoinbaseForm) + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + } +} + +inherits(CoinbaseForm, Component) + +function CoinbaseForm () { + Component.call(this) +} + +CoinbaseForm.prototype.render = function () { + var props = this.props + + return h('.flex-column', { + style: { + marginTop: '35px', + padding: '25px', + width: '100%', + }, + }, [ + h('.flex-row', { + style: { + justifyContent: 'space-around', + margin: '33px', + marginTop: '0px', + }, + }, [ + h('button.btn-green', { + onClick: this.toCoinbase.bind(this), + }, 'Continue to Coinbase'), + + h('button.btn-red', { + onClick: () => props.dispatch(actions.backTobuyView(props.accounts.address)), + }, 'Cancel'), + ]), + ]) +} + +CoinbaseForm.prototype.toCoinbase = function () { + const props = this.props + const address = props.buyView.buyAddress + props.dispatch(actions.buyEth({ network: '1', address, amount: 0 })) +} + +CoinbaseForm.prototype.renderLoading = function () { + return h('img', { + style: { + width: '27px', + marginRight: '-27px', + }, + src: 'images/loading.svg', + }) +} diff --git a/old-ui/app/components/copyButton.js b/old-ui/app/components/copyButton.js new file mode 100644 index 000000000..a25d0719c --- /dev/null +++ b/old-ui/app/components/copyButton.js @@ -0,0 +1,59 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const copyToClipboard = require('copy-to-clipboard') + +const Tooltip = require('./tooltip') + +module.exports = CopyButton + +inherits(CopyButton, Component) +function CopyButton () { + Component.call(this) +} + +// As parameters, accepts: +// "value", which is the value to copy (mandatory) +// "title", which is the text to show on hover (optional, defaults to 'Copy') +CopyButton.prototype.render = function () { + const props = this.props + const state = this.state || {} + + const value = props.value + const copied = state.copied + + const message = copied ? 'Copied' : props.title || ' Copy ' + + return h('.copy-button', { + style: { + display: 'flex', + alignItems: 'center', + }, + }, [ + + h(Tooltip, { + title: message, + }, [ + h('i.fa.fa-clipboard.cursor-pointer.color-orange', { + style: { + margin: '5px', + }, + onClick: (event) => { + event.preventDefault() + event.stopPropagation() + copyToClipboard(value) + this.debounceRestore() + }, + }), + ]), + + ]) +} + +CopyButton.prototype.debounceRestore = function () { + this.setState({ copied: true }) + clearTimeout(this.timeout) + this.timeout = setTimeout(() => { + this.setState({ copied: false }) + }, 850) +} diff --git a/old-ui/app/components/copyable.js b/old-ui/app/components/copyable.js new file mode 100644 index 000000000..a4f6f4bc6 --- /dev/null +++ b/old-ui/app/components/copyable.js @@ -0,0 +1,46 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const Tooltip = require('./tooltip') +const copyToClipboard = require('copy-to-clipboard') + +module.exports = Copyable + +inherits(Copyable, Component) +function Copyable () { + Component.call(this) + this.state = { + copied: false, + } +} + +Copyable.prototype.render = function () { + const props = this.props + const state = this.state + const { value, children } = props + const { copied } = state + + return h(Tooltip, { + title: copied ? 'Copied!' : 'Copy', + position: 'bottom', + }, h('span', { + style: { + cursor: 'pointer', + }, + onClick: (event) => { + event.preventDefault() + event.stopPropagation() + copyToClipboard(value) + this.debounceRestore() + }, + }, children)) +} + +Copyable.prototype.debounceRestore = function () { + this.setState({ copied: true }) + clearTimeout(this.timeout) + this.timeout = setTimeout(() => { + this.setState({ copied: false }) + }, 850) +} diff --git a/old-ui/app/components/custom-radio-list.js b/old-ui/app/components/custom-radio-list.js new file mode 100644 index 000000000..a4c525396 --- /dev/null +++ b/old-ui/app/components/custom-radio-list.js @@ -0,0 +1,60 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +module.exports = RadioList + +inherits(RadioList, Component) +function RadioList () { + Component.call(this) +} + +RadioList.prototype.render = function () { + const props = this.props + const activeClass = '.custom-radio-selected' + const inactiveClass = '.custom-radio-inactive' + const { + labels, + defaultFocus, + } = props + + + return ( + h('.flex-row', { + style: { + fontSize: '12px', + }, + }, [ + h('.flex-column.custom-radios', { + style: { + marginRight: '5px', + }, + }, + labels.map((lable, i) => { + let isSelcted = (this.state !== null) + isSelcted = isSelcted ? (this.state.selected === lable) : (defaultFocus === lable) + return h(isSelcted ? activeClass : inactiveClass, { + title: lable, + onClick: (event) => { + this.setState({selected: event.target.title}) + props.onClick(event) + }, + }) + }) + ), + h('.text', {}, + labels.map((lable) => { + if (props.subtext) { + return h('.flex-row', {}, [ + h('.radio-titles', lable), + h('.radio-titles-subtext', `- ${props.subtext[lable]}`), + ]) + } else { + return h('.radio-titles', lable) + } + }) + ), + ]) + ) +} + diff --git a/old-ui/app/components/dropdown.js b/old-ui/app/components/dropdown.js new file mode 100644 index 000000000..cdd864cc3 --- /dev/null +++ b/old-ui/app/components/dropdown.js @@ -0,0 +1,98 @@ +const Component = require('react').Component +const PropTypes = require('react').PropTypes +const h = require('react-hyperscript') +const MenuDroppo = require('./menu-droppo') +const extend = require('xtend') + +const noop = () => {} + +class Dropdown extends Component { + render () { + const { isOpen, onClickOutside, style, innerStyle, children, useCssTransition } = this.props + + const innerStyleDefaults = extend({ + borderRadius: '4px', + padding: '8px 16px', + background: 'rgba(0, 0, 0, 0.8)', + boxShadow: 'rgba(0, 0, 0, 0.15) 0px 2px 2px 2px', + }, innerStyle) + + return h( + MenuDroppo, + { + useCssTransition, + isOpen, + zIndex: 11, + onClickOutside, + style, + innerStyle: innerStyleDefaults, + }, + [ + h( + 'style', + ` + li.dropdown-menu-item:hover { color:rgb(225, 225, 225); } + li.dropdown-menu-item { color: rgb(185, 185, 185); position: relative } + ` + ), + ...children, + ] + ) + } +} + +Dropdown.defaultProps = { + isOpen: false, + onClick: noop, + useCssTransition: false, +} + +Dropdown.propTypes = { + isOpen: PropTypes.bool.isRequired, + onClick: PropTypes.func.isRequired, + children: PropTypes.node, + style: PropTypes.object.isRequired, + onClickOutside: PropTypes.func, + innerStyle: PropTypes.object, + useCssTransition: PropTypes.bool, +} + +class DropdownMenuItem extends Component { + render () { + const { onClick, closeMenu, children, style } = this.props + + return h( + 'li.dropdown-menu-item', + { + onClick: () => { + onClick() + closeMenu() + }, + style: Object.assign({ + listStyle: 'none', + padding: '8px 0px 8px 0px', + fontSize: '18px', + fontStyle: 'normal', + fontFamily: 'Montserrat Regular', + cursor: 'pointer', + display: 'flex', + justifyContent: 'flex-start', + alignItems: 'center', + }, style), + }, + children + ) + } +} + +DropdownMenuItem.propTypes = { + closeMenu: PropTypes.func.isRequired, + onClick: PropTypes.func.isRequired, + children: PropTypes.node, + style: PropTypes.object, +} + +module.exports = { + Dropdown, + DropdownMenuItem, +} diff --git a/old-ui/app/components/editable-label.js b/old-ui/app/components/editable-label.js new file mode 100644 index 000000000..8a5c8954f --- /dev/null +++ b/old-ui/app/components/editable-label.js @@ -0,0 +1,57 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const findDOMNode = require('react-dom').findDOMNode + +module.exports = EditableLabel + +inherits(EditableLabel, Component) +function EditableLabel () { + Component.call(this) +} + +EditableLabel.prototype.render = function () { + const props = this.props + const state = this.state + + if (state && state.isEditingLabel) { + return h('div.editable-label', [ + h('input.sizing-input', { + defaultValue: props.textValue, + maxLength: '20', + onKeyPress: (event) => { + this.saveIfEnter(event) + }, + }), + h('button.editable-button', { + onClick: () => this.saveText(), + }, 'Save'), + ]) + } else { + return h('div.name-label', { + onClick: (event) => { + const nameAttribute = event.target.getAttribute('name') + // checks for class to handle smaller CTA above the account name + const classAttribute = event.target.getAttribute('class') + if (nameAttribute === 'edit' || classAttribute === 'edit-text') { + this.setState({ isEditingLabel: true }) + } + }, + }, this.props.children) + } +} + +EditableLabel.prototype.saveIfEnter = function (event) { + if (event.key === 'Enter') { + this.saveText() + } +} + +EditableLabel.prototype.saveText = function () { + // eslint-disable-next-line react/no-find-dom-node + var container = findDOMNode(this) + var text = container.querySelector('.editable-label input').value + var truncatedText = text.substring(0, 20) + this.props.saveText(truncatedText) + this.setState({ isEditingLabel: false, textLabel: truncatedText }) +} diff --git a/old-ui/app/components/ens-input.js b/old-ui/app/components/ens-input.js new file mode 100644 index 000000000..c85a23514 --- /dev/null +++ b/old-ui/app/components/ens-input.js @@ -0,0 +1,170 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const extend = require('xtend') +const debounce = require('debounce') +const copyToClipboard = require('copy-to-clipboard') +const ENS = require('ethjs-ens') +const networkMap = require('ethjs-ens/lib/network-map.json') +const ensRE = /.+\..+$/ +const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' + + +module.exports = EnsInput + +inherits(EnsInput, Component) +function EnsInput () { + Component.call(this) +} + +EnsInput.prototype.render = function () { + const props = this.props + const opts = extend(props, { + list: 'addresses', + onChange: () => { + const network = this.props.network + const networkHasEnsSupport = getNetworkEnsSupport(network) + if (!networkHasEnsSupport) return + + const recipient = document.querySelector('input[name="address"]').value + if (recipient.match(ensRE) === null) { + return this.setState({ + loadingEns: false, + ensResolution: null, + ensFailure: null, + }) + } + + this.setState({ + loadingEns: true, + }) + this.checkName() + }, + }) + return h('div', { + style: { width: '100%' }, + }, [ + h('input.large-input', opts), + // The address book functionality. + h('datalist#addresses', + [ + // Corresponds to the addresses owned. + Object.keys(props.identities).map((key) => { + const identity = props.identities[key] + return h('option', { + value: identity.address, + label: identity.name, + key: identity.address, + }) + }), + // Corresponds to previously sent-to addresses. + props.addressBook.map((identity) => { + return h('option', { + value: identity.address, + label: identity.name, + key: identity.address, + }) + }), + ]), + this.ensIcon(), + ]) +} + +EnsInput.prototype.componentDidMount = function () { + const network = this.props.network + const networkHasEnsSupport = getNetworkEnsSupport(network) + this.setState({ ensResolution: ZERO_ADDRESS }) + + if (networkHasEnsSupport) { + const provider = global.ethereumProvider + this.ens = new ENS({ provider, network }) + this.checkName = debounce(this.lookupEnsName.bind(this), 200) + } +} + +EnsInput.prototype.lookupEnsName = function () { + const recipient = document.querySelector('input[name="address"]').value + const { ensResolution } = this.state + + log.info(`ENS attempting to resolve name: ${recipient}`) + this.ens.lookup(recipient.trim()) + .then((address) => { + if (address === ZERO_ADDRESS) throw new Error('No address has been set for this name.') + if (address !== ensResolution) { + this.setState({ + loadingEns: false, + ensResolution: address, + nickname: recipient.trim(), + hoverText: address + '\nClick to Copy', + ensFailure: false, + }) + } + }) + .catch((reason) => { + log.error(reason) + return this.setState({ + loadingEns: false, + ensResolution: ZERO_ADDRESS, + ensFailure: true, + hoverText: reason.message, + }) + }) +} + +EnsInput.prototype.componentDidUpdate = function (prevProps, prevState) { + const state = this.state || {} + const ensResolution = state.ensResolution + // If an address is sent without a nickname, meaning not from ENS or from + // the user's own accounts, a default of a one-space string is used. + const nickname = state.nickname || ' ' + if (prevState && ensResolution && this.props.onChange && + ensResolution !== prevState.ensResolution) { + this.props.onChange(ensResolution, nickname) + } +} + +EnsInput.prototype.ensIcon = function (recipient) { + const { hoverText } = this.state || {} + return h('span', { + title: hoverText, + style: { + position: 'absolute', + padding: '9px', + transform: 'translatex(-40px)', + }, + }, this.ensIconContents(recipient)) +} + +EnsInput.prototype.ensIconContents = function (recipient) { + const { loadingEns, ensFailure, ensResolution } = this.state || { ensResolution: ZERO_ADDRESS} + + if (loadingEns) { + return h('img', { + src: 'images/loading.svg', + style: { + width: '30px', + height: '30px', + transform: 'translateY(-6px)', + }, + }) + } + + if (ensFailure) { + return h('i.fa.fa-warning.fa-lg.warning') + } + + if (ensResolution && (ensResolution !== ZERO_ADDRESS)) { + return h('i.fa.fa-check-circle.fa-lg.cursor-pointer', { + style: { color: 'green' }, + onClick: (event) => { + event.preventDefault() + event.stopPropagation() + copyToClipboard(ensResolution) + }, + }) + } +} + +function getNetworkEnsSupport (network) { + return Boolean(networkMap[network]) +} diff --git a/old-ui/app/components/eth-balance.js b/old-ui/app/components/eth-balance.js new file mode 100644 index 000000000..4f538fd31 --- /dev/null +++ b/old-ui/app/components/eth-balance.js @@ -0,0 +1,89 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const formatBalance = require('../util').formatBalance +const generateBalanceObject = require('../util').generateBalanceObject +const Tooltip = require('./tooltip.js') +const FiatValue = require('./fiat-value.js') + +module.exports = EthBalanceComponent + +inherits(EthBalanceComponent, Component) +function EthBalanceComponent () { + Component.call(this) +} + +EthBalanceComponent.prototype.render = function () { + var props = this.props + let { value } = props + const { style, width } = props + var needsParse = this.props.needsParse !== undefined ? this.props.needsParse : true + value = value ? formatBalance(value, 6, needsParse) : '...' + + return ( + + h('.ether-balance.ether-balance-amount', { + style, + }, [ + h('div', { + style: { + display: 'inline', + width, + }, + }, this.renderBalance(value)), + ]) + + ) +} +EthBalanceComponent.prototype.renderBalance = function (value) { + var props = this.props + const { conversionRate, shorten, incoming, currentCurrency } = props + if (value === 'None') return value + if (value === '...') return value + var balanceObj = generateBalanceObject(value, shorten ? 1 : 3) + var balance + var splitBalance = value.split(' ') + var ethNumber = splitBalance[0] + var ethSuffix = splitBalance[1] + const showFiat = 'showFiat' in props ? props.showFiat : true + + if (shorten) { + balance = balanceObj.shortBalance + } else { + balance = balanceObj.balance + } + + var label = balanceObj.label + + return ( + h(Tooltip, { + position: 'bottom', + title: `${ethNumber} ${ethSuffix}`, + }, h('div.flex-column', [ + h('.flex-row', { + style: { + alignItems: 'flex-end', + lineHeight: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + }, + }, [ + h('div', { + style: { + width: '100%', + textAlign: 'right', + }, + }, incoming ? `+${balance}` : balance), + h('div', { + style: { + color: ' #AEAEAE', + fontSize: '12px', + marginLeft: '5px', + }, + }, label), + ]), + + showFiat ? h(FiatValue, { value: props.value, conversionRate, currentCurrency }) : null, + ])) + ) +} diff --git a/old-ui/app/components/fiat-value.js b/old-ui/app/components/fiat-value.js new file mode 100644 index 000000000..d69f41d11 --- /dev/null +++ b/old-ui/app/components/fiat-value.js @@ -0,0 +1,64 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const formatBalance = require('../util').formatBalance + +module.exports = FiatValue + +inherits(FiatValue, Component) +function FiatValue () { + Component.call(this) +} + +FiatValue.prototype.render = function () { + const props = this.props + const { conversionRate, currentCurrency } = props + const renderedCurrency = currentCurrency || '' + + const value = formatBalance(props.value, 6) + + if (value === 'None') return value + var fiatDisplayNumber, fiatTooltipNumber + var splitBalance = value.split(' ') + + if (conversionRate !== 0) { + fiatTooltipNumber = Number(splitBalance[0]) * conversionRate + fiatDisplayNumber = fiatTooltipNumber.toFixed(2) + } else { + fiatDisplayNumber = 'N/A' + fiatTooltipNumber = 'Unknown' + } + + return fiatDisplay(fiatDisplayNumber, renderedCurrency.toUpperCase()) +} + +function fiatDisplay (fiatDisplayNumber, fiatSuffix) { + if (fiatDisplayNumber !== 'N/A') { + return h('.flex-row', { + style: { + alignItems: 'flex-end', + lineHeight: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + }, + }, [ + h('div', { + style: { + width: '100%', + textAlign: 'right', + fontSize: '12px', + color: '#333333', + }, + }, fiatDisplayNumber), + h('div', { + style: { + color: '#AEAEAE', + marginLeft: '5px', + fontSize: '12px', + }, + }, fiatSuffix), + ]) + } else { + return h('div') + } +} diff --git a/old-ui/app/components/hex-as-decimal-input.js b/old-ui/app/components/hex-as-decimal-input.js new file mode 100644 index 000000000..4a71e9585 --- /dev/null +++ b/old-ui/app/components/hex-as-decimal-input.js @@ -0,0 +1,154 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const ethUtil = require('ethereumjs-util') +const BN = ethUtil.BN +const extend = require('xtend') + +module.exports = HexAsDecimalInput + +inherits(HexAsDecimalInput, Component) +function HexAsDecimalInput () { + this.state = { invalid: null } + Component.call(this) +} + +/* Hex as Decimal Input + * + * A component for allowing easy, decimal editing + * of a passed in hex string value. + * + * On change, calls back its `onChange` function parameter + * and passes it an updated hex string. + */ + +HexAsDecimalInput.prototype.render = function () { + const props = this.props + const state = this.state + + const { value, onChange, min, max } = props + + const toEth = props.toEth + const suffix = props.suffix + const decimalValue = decimalize(value, toEth) + const style = props.style + + return ( + h('.flex-column', [ + h('.flex-row', { + style: { + alignItems: 'flex-end', + lineHeight: '13px', + fontFamily: 'Montserrat Light', + textRendering: 'geometricPrecision', + }, + }, [ + h('input.hex-input', { + type: 'number', + required: true, + min: min, + max: max, + style: extend({ + display: 'block', + textAlign: 'right', + backgroundColor: 'transparent', + border: '1px solid #bdbdbd', + + }, style), + value: parseInt(decimalValue), + onBlur: (event) => { + this.updateValidity(event) + }, + onChange: (event) => { + this.updateValidity(event) + const hexString = (event.target.value === '') ? '' : hexify(event.target.value) + onChange(hexString) + }, + onInvalid: (event) => { + const msg = this.constructWarning() + if (msg === state.invalid) { + return + } + this.setState({ invalid: msg }) + event.preventDefault() + return false + }, + }), + h('div', { + style: { + color: ' #AEAEAE', + fontSize: '12px', + marginLeft: '5px', + marginRight: '6px', + width: '20px', + }, + }, suffix), + ]), + + state.invalid ? h('span.error', { + style: { + position: 'absolute', + right: '0px', + textAlign: 'right', + transform: 'translateY(26px)', + padding: '3px', + background: 'rgba(255,255,255,0.85)', + zIndex: '1', + textTransform: 'capitalize', + border: '2px solid #E20202', + }, + }, state.invalid) : null, + ]) + ) +} + +HexAsDecimalInput.prototype.setValid = function (message) { + this.setState({ invalid: null }) +} + +HexAsDecimalInput.prototype.updateValidity = function (event) { + const target = event.target + const value = this.props.value + const newValue = target.value + + if (value === newValue) { + return + } + + const valid = target.checkValidity() + if (valid) { + this.setState({ invalid: null }) + } +} + +HexAsDecimalInput.prototype.constructWarning = function () { + const { name, min, max } = this.props + let message = name ? name + ' ' : '' + + if (min && max) { + message += `must be greater than or equal to ${min} and less than or equal to ${max}.` + } else if (min) { + message += `must be greater than or equal to ${min}.` + } else if (max) { + message += `must be less than or equal to ${max}.` + } else { + message += 'Invalid input.' + } + + return message +} + +function hexify (decimalString) { + const hexBN = new BN(parseInt(decimalString), 10) + return '0x' + hexBN.toString('hex') +} + +function decimalize (input, toEth) { + if (input === '') { + return '' + } else { + const strippedInput = ethUtil.stripHexPrefix(input) + const inputBN = new BN(strippedInput, 'hex') + return inputBN.toString(10) + } +} diff --git a/old-ui/app/components/identicon.js b/old-ui/app/components/identicon.js new file mode 100644 index 000000000..bb476ca7b --- /dev/null +++ b/old-ui/app/components/identicon.js @@ -0,0 +1,74 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const isNode = require('detect-node') +const findDOMNode = require('react-dom').findDOMNode +const jazzicon = require('jazzicon') +const iconFactoryGen = require('../../lib/icon-factory') +const iconFactory = iconFactoryGen(jazzicon) + +module.exports = IdenticonComponent + +inherits(IdenticonComponent, Component) +function IdenticonComponent () { + Component.call(this) + + this.defaultDiameter = 46 +} + +IdenticonComponent.prototype.render = function () { + var props = this.props + var diameter = props.diameter || this.defaultDiameter + return ( + h('div', { + key: 'identicon-' + this.props.address, + style: { + display: 'flex', + alignItems: 'center', + justifyContent: 'center', + height: diameter, + width: diameter, + borderRadius: diameter / 2, + overflow: 'hidden', + }, + }) + ) +} + +IdenticonComponent.prototype.componentDidMount = function () { + var props = this.props + const { address } = props + + if (!address) return + + // eslint-disable-next-line react/no-find-dom-node + var container = findDOMNode(this) + + var diameter = props.diameter || this.defaultDiameter + if (!isNode) { + var img = iconFactory.iconForAddress(address, diameter) + container.appendChild(img) + } +} + +IdenticonComponent.prototype.componentDidUpdate = function () { + var props = this.props + const { address } = props + + if (!address) return + + // eslint-disable-next-line react/no-find-dom-node + var container = findDOMNode(this) + + var children = container.children + for (var i = 0; i < children.length; i++) { + container.removeChild(children[i]) + } + + var diameter = props.diameter || this.defaultDiameter + if (!isNode) { + var img = iconFactory.iconForAddress(address, diameter) + container.appendChild(img) + } +} + diff --git a/old-ui/app/components/loading.js b/old-ui/app/components/loading.js new file mode 100644 index 000000000..163792584 --- /dev/null +++ b/old-ui/app/components/loading.js @@ -0,0 +1,45 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') + + +inherits(LoadingIndicator, Component) +module.exports = LoadingIndicator + +function LoadingIndicator () { + Component.call(this) +} + +LoadingIndicator.prototype.render = function () { + const { isLoading, loadingMessage } = this.props + + return ( + isLoading ? h('.full-flex-height', { + style: { + left: '0px', + zIndex: 10, + position: 'absolute', + flexDirection: 'column', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + height: '100%', + width: '100%', + background: 'rgba(255, 255, 255, 0.8)', + }, + }, [ + h('img', { + src: 'images/loading.svg', + }), + + h('br'), + + showMessageIfAny(loadingMessage), + ]) : null + ) +} + +function showMessageIfAny (loadingMessage) { + if (!loadingMessage) return null + return h('span', loadingMessage) +} diff --git a/old-ui/app/components/mascot.js b/old-ui/app/components/mascot.js new file mode 100644 index 000000000..973ec2cad --- /dev/null +++ b/old-ui/app/components/mascot.js @@ -0,0 +1,59 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const metamaskLogo = require('metamask-logo') +const debounce = require('debounce') + +module.exports = Mascot + +inherits(Mascot, Component) +function Mascot () { + Component.call(this) + this.logo = metamaskLogo({ + followMouse: true, + pxNotRatio: true, + width: 200, + height: 200, + }) + + this.refollowMouse = debounce(this.logo.setFollowMouse.bind(this.logo, true), 1000) + this.unfollowMouse = this.logo.setFollowMouse.bind(this.logo, false) +} + +Mascot.prototype.render = function () { + // this is a bit hacky + // the event emitter is on `this.props` + // and we dont get that until render + this.handleAnimationEvents() + + return h('#metamask-mascot-container', { + style: { zIndex: 0 }, + }) +} + +Mascot.prototype.componentDidMount = function () { + var targetDivId = 'metamask-mascot-container' + var container = document.getElementById(targetDivId) + container.appendChild(this.logo.container) +} + +Mascot.prototype.componentWillUnmount = function () { + this.animations = this.props.animationEventEmitter + this.animations.removeAllListeners() + this.logo.container.remove() + this.logo.stopAnimation() +} + +Mascot.prototype.handleAnimationEvents = function () { + // only setup listeners once + if (this.animations) return + this.animations = this.props.animationEventEmitter + this.animations.on('point', this.lookAt.bind(this)) + this.animations.on('setFollowMouse', this.logo.setFollowMouse.bind(this.logo)) +} + +Mascot.prototype.lookAt = function (target) { + this.unfollowMouse() + this.logo.lookAt(target) + this.refollowMouse() +} diff --git a/old-ui/app/components/menu-droppo.js b/old-ui/app/components/menu-droppo.js new file mode 100644 index 000000000..e6276f3b1 --- /dev/null +++ b/old-ui/app/components/menu-droppo.js @@ -0,0 +1,132 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const findDOMNode = require('react-dom').findDOMNode +const ReactCSSTransitionGroup = require('react-addons-css-transition-group') + +module.exports = MenuDroppoComponent + + +inherits(MenuDroppoComponent, Component) +function MenuDroppoComponent () { + Component.call(this) +} + +MenuDroppoComponent.prototype.render = function () { + const speed = this.props.speed || '300ms' + const useCssTransition = this.props.useCssTransition + const zIndex = ('zIndex' in this.props) ? this.props.zIndex : 0 + + this.manageListeners() + + const style = this.props.style || {} + if (!('position' in style)) { + style.position = 'fixed' + } + style.zIndex = zIndex + + return ( + h('.menu-droppo-container', { + style, + }, [ + h('style', ` + .menu-droppo-enter { + transition: transform ${speed} ease-in-out; + transform: translateY(-200%); + } + + .menu-droppo-enter.menu-droppo-enter-active { + transition: transform ${speed} ease-in-out; + transform: translateY(0%); + } + + .menu-droppo-leave { + transition: transform ${speed} ease-in-out; + transform: translateY(0%); + } + + .menu-droppo-leave.menu-droppo-leave-active { + transition: transform ${speed} ease-in-out; + transform: translateY(-200%); + } + `), + + useCssTransition + ? h(ReactCSSTransitionGroup, { + className: 'css-transition-group', + transitionName: 'menu-droppo', + transitionEnterTimeout: parseInt(speed), + transitionLeaveTimeout: parseInt(speed), + }, this.renderPrimary()) + : this.renderPrimary(), + ]) + ) +} + +MenuDroppoComponent.prototype.renderPrimary = function () { + const isOpen = this.props.isOpen + if (!isOpen) { + return null + } + + const innerStyle = this.props.innerStyle || {} + + return ( + h('.menu-droppo', { + key: 'menu-droppo-drawer', + style: innerStyle, + }, + [ this.props.children ]) + ) +} + +MenuDroppoComponent.prototype.manageListeners = function () { + const isOpen = this.props.isOpen + const onClickOutside = this.props.onClickOutside + + if (isOpen) { + this.outsideClickHandler = onClickOutside + } else if (isOpen) { + this.outsideClickHandler = null + } +} + +MenuDroppoComponent.prototype.componentDidMount = function () { + if (this && document.body) { + this.globalClickHandler = this.globalClickOccurred.bind(this) + document.body.addEventListener('click', this.globalClickHandler) + // eslint-disable-next-line react/no-find-dom-node + var container = findDOMNode(this) + this.container = container + } +} + +MenuDroppoComponent.prototype.componentWillUnmount = function () { + if (this && document.body) { + document.body.removeEventListener('click', this.globalClickHandler) + } +} + +MenuDroppoComponent.prototype.globalClickOccurred = function (event) { + const target = event.target + // eslint-disable-next-line react/no-find-dom-node + const container = findDOMNode(this) + + if (target !== container && + !isDescendant(this.container, event.target) && + this.outsideClickHandler) { + this.outsideClickHandler(event) + } +} + +function isDescendant (parent, child) { + var node = child.parentNode + while (node !== null) { + if (node === parent) { + return true + } + node = node.parentNode + } + + return false +} diff --git a/old-ui/app/components/mini-account-panel.js b/old-ui/app/components/mini-account-panel.js new file mode 100644 index 000000000..c09cf5b7a --- /dev/null +++ b/old-ui/app/components/mini-account-panel.js @@ -0,0 +1,74 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const Identicon = require('./identicon') + +module.exports = AccountPanel + + +inherits(AccountPanel, Component) +function AccountPanel () { + Component.call(this) +} + +AccountPanel.prototype.render = function () { + var props = this.props + var picOrder = props.picOrder || 'left' + const { imageSeed } = props + + return ( + + h('.identity-panel.flex-row.flex-left', { + style: { + cursor: props.onClick ? 'pointer' : undefined, + }, + onClick: props.onClick, + }, [ + + this.genIcon(imageSeed, picOrder), + + h('div.flex-column.flex-justify-center', { + style: { + lineHeight: '15px', + order: 2, + display: 'flex', + alignItems: picOrder === 'left' ? 'flex-begin' : 'flex-end', + }, + }, this.props.children), + ]) + ) +} + +AccountPanel.prototype.genIcon = function (seed, picOrder) { + const props = this.props + + // When there is no seed value, this is a contract creation. + // We then show the contract icon. + if (!seed) { + return h('.identicon-wrapper.flex-column.select-none', { + style: { + order: picOrder === 'left' ? 1 : 3, + }, + }, [ + h('i.fa.fa-file-text-o.fa-lg', { + style: { + fontSize: '42px', + transform: 'translate(0px, -16px)', + }, + }), + ]) + } + + // If there was a seed, we return an identicon for that address. + return h('.identicon-wrapper.flex-column.select-none', { + style: { + order: picOrder === 'left' ? 1 : 3, + }, + }, [ + h(Identicon, { + address: seed, + imageify: props.imageifyIdenticons, + }), + ]) +} + diff --git a/old-ui/app/components/network.js b/old-ui/app/components/network.js new file mode 100644 index 000000000..0dbe37cdd --- /dev/null +++ b/old-ui/app/components/network.js @@ -0,0 +1,129 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +module.exports = Network + +inherits(Network, Component) + +function Network () { + Component.call(this) +} + +Network.prototype.render = function () { + const props = this.props + const networkNumber = props.network + let providerName + try { + providerName = props.provider.type + } catch (e) { + providerName = null + } + let iconName, hoverText + + if (networkNumber === 'loading') { + return h('span.pointer', { + style: { + display: 'flex', + alignItems: 'center', + flexDirection: 'row', + }, + onClick: (event) => this.props.onClick(event), + }, [ + h('img', { + title: 'Attempting to connect to blockchain.', + style: { + width: '27px', + }, + src: 'images/loading.svg', + }), + h('i.fa.fa-caret-down'), + ]) + } else if (providerName === 'mainnet') { + hoverText = 'Main Ethereum Network' + iconName = 'ethereum-network' + } else if (providerName === 'ropsten') { + hoverText = 'Ropsten Test Network' + iconName = 'ropsten-test-network' + } else if (parseInt(networkNumber) === 3) { + hoverText = 'Ropsten Test Network' + iconName = 'ropsten-test-network' + } else if (providerName === 'kovan') { + hoverText = 'Kovan Test Network' + iconName = 'kovan-test-network' + } else if (providerName === 'rinkeby') { + hoverText = 'Rinkeby Test Network' + iconName = 'rinkeby-test-network' + } else { + hoverText = 'Unknown Private Network' + iconName = 'unknown-private-network' + } + + return ( + h('#network_component.pointer', { + title: hoverText, + onClick: (event) => this.props.onClick(event), + }, [ + (function () { + switch (iconName) { + case 'ethereum-network': + return h('.network-indicator', [ + h('.menu-icon.diamond'), + h('.network-name', { + style: { + color: '#039396', + }}, + 'Main Network'), + h('i.fa.fa-caret-down.fa-lg'), + ]) + case 'ropsten-test-network': + return h('.network-indicator', [ + h('.menu-icon.red-dot'), + h('.network-name', { + style: { + color: '#ff6666', + }}, + 'Ropsten Test Net'), + h('i.fa.fa-caret-down.fa-lg'), + ]) + case 'kovan-test-network': + return h('.network-indicator', [ + h('.menu-icon.hollow-diamond'), + h('.network-name', { + style: { + color: '#690496', + }}, + 'Kovan Test Net'), + h('i.fa.fa-caret-down.fa-lg'), + ]) + case 'rinkeby-test-network': + return h('.network-indicator', [ + h('.menu-icon.golden-square'), + h('.network-name', { + style: { + color: '#e7a218', + }}, + 'Rinkeby Test Net'), + h('i.fa.fa-caret-down.fa-lg'), + ]) + default: + return h('.network-indicator', [ + h('i.fa.fa-question-circle.fa-lg', { + style: { + margin: '10px', + color: 'rgb(125, 128, 130)', + }, + }), + + h('.network-name', { + style: { + color: '#AEAEAE', + }}, + 'Private Network'), + h('i.fa.fa-caret-down.fa-lg'), + ]) + } + })(), + ]) + ) +} diff --git a/old-ui/app/components/notice.js b/old-ui/app/components/notice.js new file mode 100644 index 000000000..09d461c7b --- /dev/null +++ b/old-ui/app/components/notice.js @@ -0,0 +1,132 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const ReactMarkdown = require('react-markdown') +const linker = require('extension-link-enabler') +const findDOMNode = require('react-dom').findDOMNode + +module.exports = Notice + +inherits(Notice, Component) +function Notice () { + Component.call(this) +} + +Notice.prototype.render = function () { + const { notice, onConfirm } = this.props + const { title, date, body } = notice + const state = this.state || { disclaimerDisabled: true } + const disabled = state.disclaimerDisabled + + return ( + h('.flex-column.flex-center.flex-grow', { + style: { + width: '100%', + }, + }, [ + h('h3.flex-center.text-transform-uppercase.terms-header', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + width: '100%', + fontSize: '20px', + textAlign: 'center', + padding: 6, + }, + }, [ + title, + ]), + + h('h5.flex-center.text-transform-uppercase.terms-header', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginBottom: 24, + width: '100%', + fontSize: '20px', + textAlign: 'center', + padding: 6, + }, + }, [ + date, + ]), + + h('style', ` + + .markdown { + overflow-x: hidden; + } + + .markdown h1, .markdown h2, .markdown h3 { + margin: 10px 0; + font-weight: bold; + } + + .markdown strong { + font-weight: bold; + } + .markdown em { + font-style: italic; + } + + .markdown p { + margin: 10px 0; + } + + .markdown a { + color: #df6b0e; + } + + `), + + h('div.markdown', { + onScroll: (e) => { + var object = e.currentTarget + if (object.offsetHeight + object.scrollTop + 100 >= object.scrollHeight) { + this.setState({disclaimerDisabled: false}) + } + }, + style: { + background: 'rgb(235, 235, 235)', + height: '310px', + padding: '6px', + width: '90%', + overflowY: 'scroll', + scroll: 'auto', + }, + }, [ + h(ReactMarkdown, { + className: 'notice-box', + source: body, + skipHtml: true, + }), + ]), + + h('button', { + disabled, + onClick: () => { + this.setState({disclaimerDisabled: true}) + onConfirm() + }, + style: { + marginTop: '18px', + }, + }, 'Accept'), + ]) + ) +} + +Notice.prototype.componentDidMount = function () { + // eslint-disable-next-line react/no-find-dom-node + var node = findDOMNode(this) + linker.setupListener(node) + if (document.getElementsByClassName('notice-box')[0].clientHeight < 310) { + this.setState({disclaimerDisabled: false}) + } +} + +Notice.prototype.componentWillUnmount = function () { + // eslint-disable-next-line react/no-find-dom-node + var node = findDOMNode(this) + linker.teardownListener(node) +} diff --git a/old-ui/app/components/pending-msg-details.js b/old-ui/app/components/pending-msg-details.js new file mode 100644 index 000000000..718a22de0 --- /dev/null +++ b/old-ui/app/components/pending-msg-details.js @@ -0,0 +1,50 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const AccountPanel = require('./account-panel') + +module.exports = PendingMsgDetails + +inherits(PendingMsgDetails, Component) +function PendingMsgDetails () { + Component.call(this) +} + +PendingMsgDetails.prototype.render = function () { + var state = this.props + var msgData = state.txData + + var msgParams = msgData.msgParams || {} + var address = msgParams.from || state.selectedAddress + var identity = state.identities[address] || { address: address } + var account = state.accounts[address] || { address: address } + + return ( + h('div', { + key: msgData.id, + style: { + margin: '10px 20px', + }, + }, [ + + // account that will sign + h(AccountPanel, { + showFullAddress: true, + identity: identity, + account: account, + imageifyIdenticons: state.imageifyIdenticons, + }), + + // message data + h('.tx-data.flex-column.flex-justify-center.flex-grow.select-none', [ + h('.flex-column.flex-space-between', [ + h('label.font-small', 'MESSAGE'), + h('span.font-small', msgParams.data), + ]), + ]), + + ]) + ) +} + diff --git a/old-ui/app/components/pending-msg.js b/old-ui/app/components/pending-msg.js new file mode 100644 index 000000000..834719c53 --- /dev/null +++ b/old-ui/app/components/pending-msg.js @@ -0,0 +1,70 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const PendingTxDetails = require('./pending-msg-details') + +module.exports = PendingMsg + +inherits(PendingMsg, Component) +function PendingMsg () { + Component.call(this) +} + +PendingMsg.prototype.render = function () { + var state = this.props + var msgData = state.txData + + return ( + + h('div', { + key: msgData.id, + style: { + maxWidth: '350px', + }, + }, [ + + // header + h('h3', { + style: { + fontWeight: 'bold', + textAlign: 'center', + }, + }, 'Sign Message'), + + h('.error', { + style: { + margin: '10px', + }, + }, [ + `Signing this message can have + dangerous side effects. Only sign messages from + sites you fully trust with your entire account. + This dangerous method will be removed in a future version. `, + h('a', { + href: 'https://medium.com/metamask/the-new-secure-way-to-sign-data-in-your-browser-6af9dd2a1527', + style: { color: 'rgb(247, 134, 28)' }, + onClick: (event) => { + event.preventDefault() + const url = 'https://medium.com/metamask/the-new-secure-way-to-sign-data-in-your-browser-6af9dd2a1527' + global.platform.openWindow({ url }) + }, + }, 'Read more here.'), + ]), + + // message details + h(PendingTxDetails, state), + + // sign + cancel + h('.flex-row.flex-space-around', [ + h('button', { + onClick: state.cancelMessage, + }, 'Cancel'), + h('button', { + onClick: state.signMessage, + }, 'Sign'), + ]), + ]) + + ) +} + diff --git a/old-ui/app/components/pending-personal-msg-details.js b/old-ui/app/components/pending-personal-msg-details.js new file mode 100644 index 000000000..1050513f2 --- /dev/null +++ b/old-ui/app/components/pending-personal-msg-details.js @@ -0,0 +1,60 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const AccountPanel = require('./account-panel') +const BinaryRenderer = require('./binary-renderer') + +module.exports = PendingMsgDetails + +inherits(PendingMsgDetails, Component) +function PendingMsgDetails () { + Component.call(this) +} + +PendingMsgDetails.prototype.render = function () { + var state = this.props + var msgData = state.txData + + var msgParams = msgData.msgParams || {} + var address = msgParams.from || state.selectedAddress + var identity = state.identities[address] || { address: address } + var account = state.accounts[address] || { address: address } + + var { data } = msgParams + + return ( + h('div', { + key: msgData.id, + style: { + margin: '10px 20px', + }, + }, [ + + // account that will sign + h(AccountPanel, { + showFullAddress: true, + identity: identity, + account: account, + imageifyIdenticons: state.imageifyIdenticons, + }), + + // message data + h('div', { + style: { + height: '260px', + }, + }, [ + h('label.font-small', { style: { display: 'block' } }, 'MESSAGE'), + h(BinaryRenderer, { + value: data, + style: { + height: '215px', + }, + }), + ]), + + ]) + ) +} + diff --git a/old-ui/app/components/pending-personal-msg.js b/old-ui/app/components/pending-personal-msg.js new file mode 100644 index 000000000..4542adb28 --- /dev/null +++ b/old-ui/app/components/pending-personal-msg.js @@ -0,0 +1,47 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const PendingTxDetails = require('./pending-personal-msg-details') + +module.exports = PendingMsg + +inherits(PendingMsg, Component) +function PendingMsg () { + Component.call(this) +} + +PendingMsg.prototype.render = function () { + var state = this.props + var msgData = state.txData + + return ( + + h('div', { + key: msgData.id, + }, [ + + // header + h('h3', { + style: { + fontWeight: 'bold', + textAlign: 'center', + }, + }, 'Sign Message'), + + // message details + h(PendingTxDetails, state), + + // sign + cancel + h('.flex-row.flex-space-around', [ + h('button', { + onClick: state.cancelPersonalMessage, + }, 'Cancel'), + h('button', { + onClick: state.signPersonalMessage, + }, 'Sign'), + ]), + ]) + + ) +} + diff --git a/old-ui/app/components/pending-tx.js b/old-ui/app/components/pending-tx.js new file mode 100644 index 000000000..5b1b367c6 --- /dev/null +++ b/old-ui/app/components/pending-tx.js @@ -0,0 +1,500 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const actions = require('../actions') +const clone = require('clone') + +const ethUtil = require('ethereumjs-util') +const BN = ethUtil.BN +const hexToBn = require('../../../app/scripts/lib/hex-to-bn') +const util = require('../util') +const MiniAccountPanel = require('./mini-account-panel') +const Copyable = require('./copyable') +const EthBalance = require('./eth-balance') +const addressSummary = util.addressSummary +const nameForAddress = require('../../lib/contract-namer') +const BNInput = require('./bn-as-decimal-input') + +// corresponds with 0.1 GWEI +const MIN_GAS_PRICE_BN = new BN('100000000') +const MIN_GAS_LIMIT_BN = new BN('21000') + +module.exports = PendingTx +inherits(PendingTx, Component) +function PendingTx () { + Component.call(this) + this.state = { + valid: true, + txData: null, + submitting: false, + } +} + +PendingTx.prototype.render = function () { + const props = this.props + const { currentCurrency, blockGasLimit } = props + + const conversionRate = props.conversionRate + const txMeta = this.gatherTxMeta() + const txParams = txMeta.txParams || {} + + // Account Details + const address = txParams.from || props.selectedAddress + const identity = props.identities[address] || { address: address } + const account = props.accounts[address] + const balance = account ? account.balance : '0x0' + + // recipient check + const isValidAddress = !txParams.to || util.isValidAddress(txParams.to) + + // Gas + const gas = txParams.gas + const gasBn = hexToBn(gas) + const gasLimit = new BN(parseInt(blockGasLimit)) + const safeGasLimitBN = this.bnMultiplyByFraction(gasLimit, 19, 20) + const saferGasLimitBN = this.bnMultiplyByFraction(gasLimit, 18, 20) + const safeGasLimit = safeGasLimitBN.toString(10) + + // Gas Price + const gasPrice = txParams.gasPrice || MIN_GAS_PRICE_BN.toString(16) + const gasPriceBn = hexToBn(gasPrice) + + const txFeeBn = gasBn.mul(gasPriceBn) + const valueBn = hexToBn(txParams.value) + const maxCost = txFeeBn.add(valueBn) + + const dataLength = txParams.data ? (txParams.data.length - 2) / 2 : 0 + + const balanceBn = hexToBn(balance) + const insufficientBalance = balanceBn.lt(maxCost) + const dangerousGasLimit = gasBn.gte(saferGasLimitBN) + const gasLimitSpecified = txMeta.gasLimitSpecified + const buyDisabled = insufficientBalance || !this.state.valid || !isValidAddress || this.state.submitting + const showRejectAll = props.unconfTxListLength > 1 + + this.inputs = [] + + return ( + + h('div', { + key: txMeta.id, + }, [ + + h('form#pending-tx-form', { + onSubmit: this.onSubmit.bind(this), + + }, [ + + // tx info + h('div', [ + + h('.flex-row.flex-center', { + style: { + maxWidth: '100%', + }, + }, [ + + h(MiniAccountPanel, { + imageSeed: address, + picOrder: 'right', + }, [ + h('span.font-small', { + style: { + fontFamily: 'Montserrat Bold, Montserrat, sans-serif', + }, + }, identity.name), + + h(Copyable, { + value: ethUtil.toChecksumAddress(address), + }, [ + h('span.font-small', { + style: { + fontFamily: 'Montserrat Light, Montserrat, sans-serif', + }, + }, addressSummary(address, 6, 4, false)), + ]), + + h('span.font-small', { + style: { + fontFamily: 'Montserrat Light, Montserrat, sans-serif', + }, + }, [ + h(EthBalance, { + value: balance, + conversionRate, + currentCurrency, + inline: true, + labelColor: '#F7861C', + }), + ]), + ]), + + forwardCarrat(), + + this.miniAccountPanelForRecipient(), + ]), + + h('style', ` + .table-box { + margin: 7px 0px 0px 0px; + width: 100%; + } + .table-box .row { + margin: 0px; + background: rgb(236,236,236); + display: flex; + justify-content: space-between; + font-family: Montserrat Light, sans-serif; + font-size: 13px; + padding: 5px 25px; + } + .table-box .row .value { + font-family: Montserrat Regular; + } + `), + + h('.table-box', [ + + // Ether Value + // Currently not customizable, but easily modified + // in the way that gas and gasLimit currently are. + h('.row', [ + h('.cell.label', 'Amount'), + h(EthBalance, { value: txParams.value, currentCurrency, conversionRate }), + ]), + + // Gas Limit (customizable) + h('.cell.row', [ + h('.cell.label', 'Gas Limit'), + h('.cell.value', { + }, [ + h(BNInput, { + name: 'Gas Limit', + value: gasBn, + precision: 0, + scale: 0, + // The hard lower limit for gas. + min: MIN_GAS_LIMIT_BN, + max: safeGasLimit, + suffix: 'UNITS', + style: { + position: 'relative', + top: '5px', + }, + onChange: this.gasLimitChanged.bind(this), + + ref: (hexInput) => { this.inputs.push(hexInput) }, + }), + ]), + ]), + + // Gas Price (customizable) + h('.cell.row', [ + h('.cell.label', 'Gas Price'), + h('.cell.value', { + }, [ + h(BNInput, { + name: 'Gas Price', + value: gasPriceBn, + precision: 9, + scale: 9, + suffix: 'GWEI', + min: MIN_GAS_PRICE_BN, + style: { + position: 'relative', + top: '5px', + }, + onChange: this.gasPriceChanged.bind(this), + ref: (hexInput) => { this.inputs.push(hexInput) }, + }), + ]), + ]), + + // Max Transaction Fee (calculated) + h('.cell.row', [ + h('.cell.label', 'Max Transaction Fee'), + h(EthBalance, { value: txFeeBn.toString(16), currentCurrency, conversionRate }), + ]), + + h('.cell.row', { + style: { + fontFamily: 'Montserrat Regular', + background: 'white', + padding: '10px 25px', + }, + }, [ + h('.cell.label', 'Max Total'), + h('.cell.value', { + style: { + display: 'flex', + alignItems: 'center', + }, + }, [ + h(EthBalance, { + value: maxCost.toString(16), + currentCurrency, + conversionRate, + inline: true, + labelColor: 'black', + fontSize: '16px', + }), + ]), + ]), + + // Data size row: + h('.cell.row', { + style: { + background: '#f7f7f7', + paddingBottom: '0px', + }, + }, [ + h('.cell.label'), + h('.cell.value', { + style: { + fontFamily: 'Montserrat Light', + fontSize: '11px', + }, + }, `Data included: ${dataLength} bytes`), + ]), + ]), // End of Table + + ]), + + h('style', ` + .conf-buttons button { + margin-left: 10px; + text-transform: uppercase; + } + `), + h('.cell.row', { + style: { + textAlign: 'center', + }, + }, [ + txMeta.simulationFails ? + h('.error', { + style: { + fontSize: '0.9em', + }, + }, 'Transaction Error. Exception thrown in contract code.') + : null, + + !isValidAddress ? + h('.error', { + style: { + fontSize: '0.9em', + }, + }, 'Recipient address is invalid. Sending this transaction will result in a loss of ETH.') + : null, + + insufficientBalance ? + h('span.error', { + style: { + fontSize: '0.9em', + }, + }, 'Insufficient balance for transaction') + : null, + + (dangerousGasLimit && !gasLimitSpecified) ? + h('span.error', { + style: { + fontSize: '0.9em', + }, + }, 'Gas limit set dangerously high. Approving this transaction is likely to fail.') + : null, + ]), + + + // send + cancel + h('.flex-row.flex-space-around.conf-buttons', { + style: { + display: 'flex', + justifyContent: 'flex-end', + margin: '14px 25px', + }, + }, [ + h('button', { + onClick: (event) => { + this.resetGasFields() + event.preventDefault() + }, + }, 'Reset'), + + // Accept Button or Buy Button + insufficientBalance ? h('button.btn-green', { onClick: props.buyEth }, 'Buy Ether') : + h('input.confirm.btn-green', { + type: 'submit', + value: 'SUBMIT', + style: { marginLeft: '10px' }, + disabled: buyDisabled, + }), + + h('button.cancel.btn-red', { + onClick: props.cancelTransaction, + }, 'Reject'), + ]), + showRejectAll ? h('.flex-row.flex-space-around.conf-buttons', { + style: { + display: 'flex', + justifyContent: 'flex-end', + margin: '14px 25px', + }, + }, [ + h('button.cancel.btn-red', { + onClick: props.cancelAllTransactions, + }, 'Reject All'), + ]) : null, + ]), + ]) + ) +} + +PendingTx.prototype.miniAccountPanelForRecipient = function () { + const props = this.props + const txData = props.txData + const txParams = txData.txParams || {} + const isContractDeploy = !('to' in txParams) + + // If it's not a contract deploy, send to the account + if (!isContractDeploy) { + return h(MiniAccountPanel, { + imageSeed: txParams.to, + picOrder: 'left', + }, [ + + h('span.font-small', { + style: { + fontFamily: 'Montserrat Bold, Montserrat, sans-serif', + }, + }, nameForAddress(txParams.to, props.identities)), + + h(Copyable, { + value: ethUtil.toChecksumAddress(txParams.to), + }, [ + h('span.font-small', { + style: { + fontFamily: 'Montserrat Light, Montserrat, sans-serif', + }, + }, addressSummary(txParams.to, 6, 4, false)), + ]), + + ]) + } else { + return h(MiniAccountPanel, { + picOrder: 'left', + }, [ + + h('span.font-small', { + style: { + fontFamily: 'Montserrat Bold, Montserrat, sans-serif', + }, + }, 'New Contract'), + + ]) + } +} + +PendingTx.prototype.gasPriceChanged = function (newBN, valid) { + log.info(`Gas price changed to: ${newBN.toString(10)}`) + const txMeta = this.gatherTxMeta() + txMeta.txParams.gasPrice = '0x' + newBN.toString('hex') + this.setState({ + txData: clone(txMeta), + valid, + }) +} + +PendingTx.prototype.gasLimitChanged = function (newBN, valid) { + log.info(`Gas limit changed to ${newBN.toString(10)}`) + const txMeta = this.gatherTxMeta() + txMeta.txParams.gas = '0x' + newBN.toString('hex') + this.setState({ + txData: clone(txMeta), + valid, + }) +} + +PendingTx.prototype.resetGasFields = function () { + log.debug(`pending-tx resetGasFields`) + + this.inputs.forEach((hexInput) => { + if (hexInput) { + hexInput.setValid() + } + }) + + this.setState({ + txData: null, + valid: true, + }) +} + +PendingTx.prototype.onSubmit = function (event) { + event.preventDefault() + const txMeta = this.gatherTxMeta() + const valid = this.checkValidity() + this.setState({ valid, submitting: true }) + if (valid && this.verifyGasParams()) { + this.props.sendTransaction(txMeta, event) + } else { + this.props.dispatch(actions.displayWarning('Invalid Gas Parameters')) + this.setState({ submitting: false }) + } +} + +PendingTx.prototype.checkValidity = function () { + const form = this.getFormEl() + const valid = form.checkValidity() + return valid +} + +PendingTx.prototype.getFormEl = function () { + const form = document.querySelector('form#pending-tx-form') + // Stub out form for unit tests: + if (!form) { + return { checkValidity () { return true } } + } + return form +} + +// After a customizable state value has been updated, +PendingTx.prototype.gatherTxMeta = function () { + log.debug(`pending-tx gatherTxMeta`) + const props = this.props + const state = this.state + const txData = clone(state.txData) || clone(props.txData) + + log.debug(`UI has defaulted to tx meta ${JSON.stringify(txData)}`) + return txData +} + +PendingTx.prototype.verifyGasParams = function () { + // We call this in case the gas has not been modified at all + if (!this.state) { return true } + return ( + this._notZeroOrEmptyString(this.state.gas) && + this._notZeroOrEmptyString(this.state.gasPrice) + ) +} + +PendingTx.prototype._notZeroOrEmptyString = function (obj) { + return obj !== '' && obj !== '0x0' +} + +PendingTx.prototype.bnMultiplyByFraction = function (targetBN, numerator, denominator) { + const numBN = new BN(numerator) + const denomBN = new BN(denominator) + return targetBN.mul(numBN).div(denomBN) +} + +function forwardCarrat () { + return ( + h('img', { + src: 'images/forward-carrat.svg', + style: { + padding: '5px 6px 0px 10px', + height: '37px', + }, + }) + ) +} diff --git a/old-ui/app/components/pending-typed-msg-details.js b/old-ui/app/components/pending-typed-msg-details.js new file mode 100644 index 000000000..b5fd29f71 --- /dev/null +++ b/old-ui/app/components/pending-typed-msg-details.js @@ -0,0 +1,59 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const AccountPanel = require('./account-panel') +const TypedMessageRenderer = require('./typed-message-renderer') + +module.exports = PendingMsgDetails + +inherits(PendingMsgDetails, Component) +function PendingMsgDetails () { + Component.call(this) +} + +PendingMsgDetails.prototype.render = function () { + var state = this.props + var msgData = state.txData + + var msgParams = msgData.msgParams || {} + var address = msgParams.from || state.selectedAddress + var identity = state.identities[address] || { address: address } + var account = state.accounts[address] || { address: address } + + var { data } = msgParams + + return ( + h('div', { + key: msgData.id, + style: { + margin: '10px 20px', + }, + }, [ + + // account that will sign + h(AccountPanel, { + showFullAddress: true, + identity: identity, + account: account, + imageifyIdenticons: state.imageifyIdenticons, + }), + + // message data + h('div', { + style: { + height: '260px', + }, + }, [ + h('label.font-small', { style: { display: 'block' } }, 'YOU ARE SIGNING'), + h(TypedMessageRenderer, { + value: data, + style: { + height: '215px', + }, + }), + ]), + + ]) + ) +} diff --git a/old-ui/app/components/pending-typed-msg.js b/old-ui/app/components/pending-typed-msg.js new file mode 100644 index 000000000..f8926d0a3 --- /dev/null +++ b/old-ui/app/components/pending-typed-msg.js @@ -0,0 +1,46 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const PendingTxDetails = require('./pending-typed-msg-details') + +module.exports = PendingMsg + +inherits(PendingMsg, Component) +function PendingMsg () { + Component.call(this) +} + +PendingMsg.prototype.render = function () { + var state = this.props + var msgData = state.txData + + return ( + + h('div', { + key: msgData.id, + }, [ + + // header + h('h3', { + style: { + fontWeight: 'bold', + textAlign: 'center', + }, + }, 'Sign Message'), + + // message details + h(PendingTxDetails, state), + + // sign + cancel + h('.flex-row.flex-space-around', [ + h('button', { + onClick: state.cancelTypedMessage, + }, 'Cancel'), + h('button', { + onClick: state.signTypedMessage, + }, 'Sign'), + ]), + ]) + + ) +} diff --git a/old-ui/app/components/qr-code.js b/old-ui/app/components/qr-code.js new file mode 100644 index 000000000..06b9aed9b --- /dev/null +++ b/old-ui/app/components/qr-code.js @@ -0,0 +1,79 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const qrCode = require('qrcode-npm').qrcode +const inherits = require('util').inherits +const connect = require('react-redux').connect +const isHexPrefixed = require('ethereumjs-util').isHexPrefixed +const CopyButton = require('./copyButton') + +module.exports = connect(mapStateToProps)(QrCodeView) + +function mapStateToProps (state) { + return { + Qr: state.appState.Qr, + buyView: state.appState.buyView, + warning: state.appState.warning, + } +} + +inherits(QrCodeView, Component) + +function QrCodeView () { + Component.call(this) +} + +QrCodeView.prototype.render = function () { + const props = this.props + const Qr = props.Qr + const address = `${isHexPrefixed(Qr.data) ? 'ethereum:' : ''}${Qr.data}` + const qrImage = qrCode(4, 'M') + qrImage.addData(address) + qrImage.make() + return h('.main-container.flex-column', { + key: 'qr', + style: { + justifyContent: 'center', + paddingBottom: '45px', + paddingLeft: '45px', + paddingRight: '45px', + alignItems: 'center', + }, + }, [ + Array.isArray(Qr.message) ? h('.message-container', this.renderMultiMessage()) : h('.qr-header', Qr.message), + + this.props.warning ? this.props.warning && h('span.error.flex-center', { + style: { + textAlign: 'center', + width: '229px', + height: '82px', + }, + }, + this.props.warning) : null, + + h('#qr-container.flex-column', { + style: { + marginTop: '25px', + marginBottom: '15px', + }, + dangerouslySetInnerHTML: { + __html: qrImage.createTableTag(4), + }, + }), + h('.flex-row', [ + h('h3.ellip-address', { + style: { + width: '247px', + }, + }, Qr.data), + h(CopyButton, { + value: Qr.data, + }), + ]), + ]) +} + +QrCodeView.prototype.renderMultiMessage = function () { + var Qr = this.props.Qr + var multiMessage = Qr.message.map((message) => h('.qr-message', message)) + return multiMessage +} diff --git a/old-ui/app/components/range-slider.js b/old-ui/app/components/range-slider.js new file mode 100644 index 000000000..823f5eb01 --- /dev/null +++ b/old-ui/app/components/range-slider.js @@ -0,0 +1,58 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +module.exports = RangeSlider + +inherits(RangeSlider, Component) +function RangeSlider () { + Component.call(this) +} + +RangeSlider.prototype.render = function () { + const state = this.state || {} + const props = this.props + const onInput = props.onInput || function () {} + const name = props.name + const { + min = 0, + max = 100, + increment = 1, + defaultValue = 50, + mirrorInput = false, + } = this.props.options + const {container, input, range} = props.style + + return ( + h('.flex-row', { + style: container, + }, [ + h('input', { + type: 'range', + name: name, + min: min, + max: max, + step: increment, + style: range, + value: state.value || defaultValue, + onChange: mirrorInput ? this.mirrorInputs.bind(this, event) : onInput, + }), + + // Mirrored input for range + mirrorInput ? h('input.large-input', { + type: 'number', + name: `${name}Mirror`, + min: min, + max: max, + value: state.value || defaultValue, + step: increment, + style: input, + onChange: this.mirrorInputs.bind(this, event), + }) : null, + ]) + ) +} + +RangeSlider.prototype.mirrorInputs = function (event) { + this.setState({value: event.target.value}) +} diff --git a/old-ui/app/components/shapeshift-form.js b/old-ui/app/components/shapeshift-form.js new file mode 100644 index 000000000..c5993e3d3 --- /dev/null +++ b/old-ui/app/components/shapeshift-form.js @@ -0,0 +1,308 @@ +const PersistentForm = require('../../lib/persistent-form') +const h = require('react-hyperscript') +const inherits = require('util').inherits +const connect = require('react-redux').connect +const actions = require('../actions') +const Qr = require('./qr-code') +const isValidAddress = require('../util').isValidAddress +module.exports = connect(mapStateToProps)(ShapeshiftForm) + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + isSubLoading: state.appState.isSubLoading, + qrRequested: state.appState.qrRequested, + } +} + +inherits(ShapeshiftForm, PersistentForm) + +function ShapeshiftForm () { + PersistentForm.call(this) + this.persistentFormParentId = 'shapeshift-buy-form' +} + +ShapeshiftForm.prototype.render = function () { + return this.props.qrRequested ? h(Qr, {key: 'qr'}) : this.renderMain() +} + +ShapeshiftForm.prototype.renderMain = function () { + const marketinfo = this.props.buyView.formView.marketinfo + const coinOptions = this.props.buyView.formView.coinOptions + var coin = marketinfo.pair.split('_')[0].toUpperCase() + + return h('.flex-column', { + style: { + position: 'relative', + padding: '25px', + paddingTop: '5px', + width: '90%', + minHeight: '215px', + alignItems: 'center', + overflowY: 'auto', + }, + }, [ + h('.flex-row', { + style: { + justifyContent: 'center', + alignItems: 'baseline', + height: '42px', + }, + }, [ + h('img', { + src: coinOptions[coin].image, + width: '25px', + height: '25px', + style: { + marginRight: '5px', + }, + }), + + h('.input-container', { + position: 'relative', + }, [ + h('input#fromCoin.buy-inputs.ex-coins', { + type: 'text', + list: 'coinList', + autoFocus: true, + dataset: { + persistentFormId: 'input-coin', + }, + style: { + boxSizing: 'border-box', + }, + onChange: this.handleLiveInput.bind(this), + defaultValue: 'BTC', + }), + + this.renderCoinList(), + + h('i.fa.fa-pencil-square-o.edit-text', { + style: { + fontSize: '12px', + color: '#F7861C', + position: 'absolute', + }, + }), + ]), + + h('.icon-control', { + style: { + position: 'relative', + }, + }, [ + // Not visible on the screen, can't see it on master. + + // h('i.fa.fa-refresh.fa-4.orange', { + // style: { + // bottom: '5px', + // left: '5px', + // color: '#F7861C', + // }, + // onClick: this.updateCoin.bind(this), + // }), + h('i.fa.fa-chevron-right.fa-4.orange', { + style: { + position: 'absolute', + bottom: '35%', + left: '0%', + color: '#F7861C', + }, + onClick: this.updateCoin.bind(this), + }), + ]), + + h('#toCoin.ex-coins', marketinfo.pair.split('_')[1].toUpperCase()), + + h('img', { + src: coinOptions[marketinfo.pair.split('_')[1].toUpperCase()].image, + width: '25px', + height: '25px', + style: { + marginLeft: '5px', + }, + }), + ]), + + h('.flex-column', { + style: { + marginTop: '1%', + alignItems: 'flex-start', + }, + }, [ + this.props.warning ? + this.props.warning && + h('span.error.flex-center', { + style: { + textAlign: 'center', + width: '229px', + height: '82px', + }, + }, this.props.warning) + : this.renderInfo(), + + this.renderRefundAddressForCoin(coin), + ]), + + ]) +} + +ShapeshiftForm.prototype.renderRefundAddressForCoin = function (coin) { + return h(this.activeToggle('.input-container'), { + style: { + marginTop: '1%', + }, + }, [ + + h('div', `${coin} Address:`), + + h('input#fromCoinAddress.buy-inputs', { + type: 'text', + placeholder: `Your ${coin} Refund Address`, + dataset: { + persistentFormId: 'refund-address', + + }, + style: { + boxSizing: 'border-box', + width: '227px', + height: '30px', + padding: ' 5px ', + }, + }), + + h('i.fa.fa-pencil-square-o.edit-text', { + style: { + fontSize: '12px', + color: '#F7861C', + position: 'absolute', + }, + }), + h('div.flex-row', { + style: { + justifyContent: 'flex-start', + }, + }, [ + h('button', { + onClick: this.shift.bind(this), + style: { + marginTop: '1%', + }, + }, + 'Submit'), + ]), + ]) +} + +ShapeshiftForm.prototype.shift = function () { + var props = this.props + var withdrawal = this.props.buyView.buyAddress + var returnAddress = document.getElementById('fromCoinAddress').value + var pair = this.props.buyView.formView.marketinfo.pair + var data = { + 'withdrawal': withdrawal, + 'pair': pair, + 'returnAddress': returnAddress, + // Public api key + 'apiKey': '803d1f5df2ed1b1476e4b9e6bcd089e34d8874595dda6a23b67d93c56ea9cc2445e98a6748b219b2b6ad654d9f075f1f1db139abfa93158c04e825db122c14b6', + } + var message = [ + `Deposit Limit: ${props.buyView.formView.marketinfo.limit}`, + `Deposit Minimum:${props.buyView.formView.marketinfo.minimum}`, + ] + if (isValidAddress(withdrawal)) { + this.props.dispatch(actions.coinShiftRquest(data, message)) + } +} + +ShapeshiftForm.prototype.renderCoinList = function () { + var list = Object.keys(this.props.buyView.formView.coinOptions).map((item) => { + return h('option', { + value: item, + }, item) + }) + + return h('datalist#coinList', { + onClick: (event) => { + event.preventDefault() + }, + }, list) +} + +ShapeshiftForm.prototype.updateCoin = function (event) { + event.preventDefault() + const props = this.props + var coinOptions = this.props.buyView.formView.coinOptions + var coin = document.getElementById('fromCoin').value + + if (!coinOptions[coin.toUpperCase()] || coin.toUpperCase() === 'ETH') { + var message = 'Not a valid coin' + return props.dispatch(actions.displayWarning(message)) + } else { + return props.dispatch(actions.pairUpdate(coin)) + } +} + +ShapeshiftForm.prototype.handleLiveInput = function () { + const props = this.props + var coinOptions = this.props.buyView.formView.coinOptions + var coin = document.getElementById('fromCoin').value + + if (!coinOptions[coin.toUpperCase()] || coin.toUpperCase() === 'ETH') { + return null + } else { + return props.dispatch(actions.pairUpdate(coin)) + } +} + +ShapeshiftForm.prototype.renderInfo = function () { + const marketinfo = this.props.buyView.formView.marketinfo + const coinOptions = this.props.buyView.formView.coinOptions + var coin = marketinfo.pair.split('_')[0].toUpperCase() + + return h('span', { + style: { + }, + }, [ + h('h3.flex-row.text-transform-uppercase', { + style: { + color: '#868686', + paddingTop: '4px', + justifyContent: 'space-around', + textAlign: 'center', + fontSize: '17px', + }, + }, `Market Info for ${marketinfo.pair.replace('_', ' to ').toUpperCase()}:`), + h('.marketinfo', ['Status : ', `${coinOptions[coin].status}`]), + h('.marketinfo', ['Exchange Rate: ', `${marketinfo.rate}`]), + h('.marketinfo', ['Limit: ', `${marketinfo.limit}`]), + h('.marketinfo', ['Minimum : ', `${marketinfo.minimum}`]), + ]) +} + +ShapeshiftForm.prototype.activeToggle = function (elementType) { + if (!this.props.buyView.formView.response || this.props.warning) return elementType + return `${elementType}.inactive` +} + +ShapeshiftForm.prototype.renderLoading = function () { + return h('span', { + style: { + position: 'absolute', + left: '70px', + bottom: '194px', + background: 'transparent', + width: '229px', + height: '82px', + display: 'flex', + justifyContent: 'center', + }, + }, [ + h('img', { + style: { + width: '60px', + }, + src: 'images/loading.svg', + }), + ]) +} diff --git a/old-ui/app/components/shift-list-item.js b/old-ui/app/components/shift-list-item.js new file mode 100644 index 000000000..b555dee84 --- /dev/null +++ b/old-ui/app/components/shift-list-item.js @@ -0,0 +1,204 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const vreme = new (require('vreme'))() +const explorerLink = require('etherscan-link').createExplorerLink +const actions = require('../actions') +const addressSummary = require('../util').addressSummary + +const CopyButton = require('./copyButton') +const EthBalance = require('./eth-balance') +const Tooltip = require('./tooltip') + + +module.exports = connect(mapStateToProps)(ShiftListItem) + +function mapStateToProps (state) { + return { + conversionRate: state.metamask.conversionRate, + currentCurrency: state.metamask.currentCurrency, + } +} + +inherits(ShiftListItem, Component) + +function ShiftListItem () { + Component.call(this) +} + +ShiftListItem.prototype.render = function () { + return ( + h('.transaction-list-item.flex-row', { + style: { + paddingTop: '20px', + paddingBottom: '20px', + justifyContent: 'space-around', + alignItems: 'center', + }, + }, [ + h('div', { + style: { + width: '0px', + position: 'relative', + bottom: '19px', + }, + }, [ + h('img', { + src: 'https://info.shapeshift.io/sites/default/files/logo.png', + style: { + height: '35px', + width: '132px', + position: 'absolute', + clip: 'rect(0px,23px,34px,0px)', + }, + }), + ]), + + this.renderInfo(), + this.renderUtilComponents(), + ]) + ) +} + +function formatDate (date) { + return vreme.format(new Date(date), 'March 16 2014 14:30') +} + +ShiftListItem.prototype.renderUtilComponents = function () { + var props = this.props + const { conversionRate, currentCurrency } = props + + switch (props.response.status) { + case 'no_deposits': + return h('.flex-row', [ + h(CopyButton, { + value: this.props.depositAddress, + }), + h(Tooltip, { + title: 'QR Code', + }, [ + h('i.fa.fa-qrcode.pointer.pop-hover', { + onClick: () => props.dispatch(actions.reshowQrCode(props.depositAddress, props.depositType)), + style: { + margin: '5px', + marginLeft: '23px', + marginRight: '12px', + fontSize: '20px', + color: '#F7861C', + }, + }), + ]), + ]) + case 'received': + return h('.flex-row') + + case 'complete': + return h('.flex-row', [ + h(CopyButton, { + value: this.props.response.transaction, + }), + h(EthBalance, { + value: `${props.response.outgoingCoin}`, + conversionRate, + currentCurrency, + width: '55px', + shorten: true, + needsParse: false, + incoming: true, + style: { + fontSize: '15px', + color: '#01888C', + }, + }), + ]) + + case 'failed': + return '' + default: + return '' + } +} + +ShiftListItem.prototype.renderInfo = function () { + var props = this.props + switch (props.response.status) { + case 'no_deposits': + return h('.flex-column', { + style: { + width: '200px', + overflow: 'hidden', + }, + }, [ + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, `${props.depositType} to ETH via ShapeShift`), + h('div', 'No deposits received'), + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, formatDate(props.time)), + ]) + case 'received': + return h('.flex-column', { + style: { + width: '200px', + overflow: 'hidden', + }, + }, [ + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, `${props.depositType} to ETH via ShapeShift`), + h('div', 'Conversion in progress'), + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, formatDate(props.time)), + ]) + case 'complete': + var url = explorerLink(props.response.transaction, parseInt('1')) + + return h('.flex-column.pointer', { + style: { + width: '200px', + overflow: 'hidden', + }, + onClick: () => global.platform.openWindow({ url }), + }, [ + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, 'From ShapeShift'), + h('div', formatDate(props.time)), + h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + width: '100%', + }, + }, addressSummary(props.response.transaction)), + ]) + + case 'failed': + return h('span.error', '(Failed)') + default: + return '' + } +} diff --git a/old-ui/app/components/tab-bar.js b/old-ui/app/components/tab-bar.js new file mode 100644 index 000000000..bef444a48 --- /dev/null +++ b/old-ui/app/components/tab-bar.js @@ -0,0 +1,37 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +module.exports = TabBar + +inherits(TabBar, Component) +function TabBar () { + Component.call(this) +} + +TabBar.prototype.render = function () { + const props = this.props + const state = this.state || {} + const { tabs = [], defaultTab, tabSelected } = props + const { subview = defaultTab } = state + + return ( + h('.flex-row.space-around.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + paddingTop: '4px', + minHeight: '30px', + }, + }, tabs.map((tab) => { + const { key, content } = tab + return h(subview === key ? '.activeForm' : '.inactiveForm.pointer', { + onClick: () => { + this.setState({ subview: key }) + tabSelected(key) + }, + }, content) + })) + ) +} + diff --git a/old-ui/app/components/template.js b/old-ui/app/components/template.js new file mode 100644 index 000000000..b6ed8eaa0 --- /dev/null +++ b/old-ui/app/components/template.js @@ -0,0 +1,18 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +module.exports = NewComponent + +inherits(NewComponent, Component) +function NewComponent () { + Component.call(this) +} + +NewComponent.prototype.render = function () { + const props = this.props + + return ( + h('span', props.message) + ) +} diff --git a/old-ui/app/components/token-cell.js b/old-ui/app/components/token-cell.js new file mode 100644 index 000000000..19d7139bb --- /dev/null +++ b/old-ui/app/components/token-cell.js @@ -0,0 +1,72 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const Identicon = require('./identicon') +const prefixForNetwork = require('../../lib/etherscan-prefix-for-network') + +module.exports = TokenCell + +inherits(TokenCell, Component) +function TokenCell () { + Component.call(this) +} + +TokenCell.prototype.render = function () { + const props = this.props + const { address, symbol, string, network, userAddress } = props + + return ( + h('li.token-cell', { + style: { cursor: network === '1' ? 'pointer' : 'default' }, + onClick: this.view.bind(this, address, userAddress, network), + }, [ + + h(Identicon, { + diameter: 50, + address, + network, + }), + + h('h3', `${string || 0} ${symbol}`), + + h('span', { style: { flex: '1 0 auto' } }), + + /* + h('button', { + onClick: this.send.bind(this, address), + }, 'SEND'), + */ + + ]) + ) +} + +TokenCell.prototype.send = function (address, event) { + event.preventDefault() + event.stopPropagation() + const url = tokenFactoryFor(address) + if (url) { + navigateTo(url) + } +} + +TokenCell.prototype.view = function (address, userAddress, network, event) { + const url = etherscanLinkFor(address, userAddress, network) + if (url) { + navigateTo(url) + } +} + +function navigateTo (url) { + global.platform.openWindow({ url }) +} + +function etherscanLinkFor (tokenAddress, address, network) { + const prefix = prefixForNetwork(network) + return `https://${prefix}etherscan.io/token/${tokenAddress}?a=${address}` +} + +function tokenFactoryFor (tokenAddress) { + return `https://tokenfactory.surge.sh/#/token/${tokenAddress}` +} + diff --git a/old-ui/app/components/token-list.js b/old-ui/app/components/token-list.js new file mode 100644 index 000000000..998ec901d --- /dev/null +++ b/old-ui/app/components/token-list.js @@ -0,0 +1,207 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const TokenTracker = require('eth-token-tracker') +const TokenCell = require('./token-cell.js') + +module.exports = TokenList + +inherits(TokenList, Component) +function TokenList () { + this.state = { + tokens: [], + isLoading: true, + network: null, + } + Component.call(this) +} + +TokenList.prototype.render = function () { + const state = this.state + const { tokens, isLoading, error } = state + const { userAddress, network } = this.props + + if (isLoading) { + return this.message('Loading') + } + + if (error) { + log.error(error) + return h('.hotFix', { + style: { + padding: '80px', + }, + }, [ + 'We had trouble loading your token balances. You can view them ', + h('span.hotFix', { + style: { + color: 'rgba(247, 134, 28, 1)', + cursor: 'pointer', + }, + onClick: () => { + global.platform.openWindow({ + url: `https://ethplorer.io/address/${userAddress}`, + }) + }, + }, 'here'), + ]) + } + + const tokenViews = tokens.map((tokenData) => { + tokenData.network = network + tokenData.userAddress = userAddress + return h(TokenCell, tokenData) + }) + + return h('.full-flex-height', [ + this.renderTokenStatusBar(), + + h('ol.full-flex-height.flex-column', { + style: { + overflowY: 'auto', + display: 'flex', + flexDirection: 'column', + }, + }, [ + h('style', ` + + li.token-cell { + display: flex; + flex-direction: row; + align-items: center; + padding: 10px; + min-height: 50px; + } + + li.token-cell > h3 { + margin-left: 12px; + } + + li.token-cell:hover { + background: white; + cursor: pointer; + } + + `), + ...tokenViews, + h('.flex-grow'), + ]), + ]) +} + +TokenList.prototype.renderTokenStatusBar = function () { + const { tokens } = this.state + + let msg + if (tokens.length === 1) { + msg = `You own 1 token` + } else if (tokens.length > 1) { + msg = `You own ${tokens.length} tokens` + } else { + msg = `No tokens found` + } + + return h('div', { + style: { + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + minHeight: '70px', + padding: '10px', + }, + }, [ + h('span', msg), + h('button', { + key: 'reveal-account-bar', + onClick: (event) => { + event.preventDefault() + this.props.addToken() + }, + style: { + display: 'flex', + height: '40px', + padding: '10px', + justifyContent: 'center', + alignItems: 'center', + }, + }, [ + 'ADD TOKEN', + ]), + ]) +} + +TokenList.prototype.message = function (body) { + return h('div', { + style: { + display: 'flex', + height: '250px', + alignItems: 'center', + justifyContent: 'center', + padding: '30px', + }, + }, body) +} + +TokenList.prototype.componentDidMount = function () { + this.createFreshTokenTracker() +} + +TokenList.prototype.createFreshTokenTracker = function () { + if (this.tracker) { + // Clean up old trackers when refreshing: + this.tracker.stop() + this.tracker.removeListener('update', this.balanceUpdater) + this.tracker.removeListener('error', this.showError) + } + + if (!global.ethereumProvider) return + const { userAddress } = this.props + this.tracker = new TokenTracker({ + userAddress, + provider: global.ethereumProvider, + tokens: this.props.tokens, + pollingInterval: 8000, + }) + + + // Set up listener instances for cleaning up + this.balanceUpdater = this.updateBalances.bind(this) + this.showError = (error) => { + this.setState({ error, isLoading: false }) + } + this.tracker.on('update', this.balanceUpdater) + this.tracker.on('error', this.showError) + + this.tracker.updateBalances() + .then(() => { + this.updateBalances(this.tracker.serialize()) + }) + .catch((reason) => { + log.error(`Problem updating balances`, reason) + this.setState({ isLoading: false }) + }) +} + +TokenList.prototype.componentWillUpdate = function (nextProps) { + if (nextProps.network === 'loading') return + const oldNet = this.props.network + const newNet = nextProps.network + + if (oldNet && newNet && newNet !== oldNet) { + this.setState({ isLoading: true }) + this.createFreshTokenTracker() + } +} + +TokenList.prototype.updateBalances = function (tokens) { + const heldTokens = tokens.filter(token => { + return token.balance !== '0' && token.string !== '0.000' + }) + this.setState({ tokens: heldTokens, isLoading: false }) +} + +TokenList.prototype.componentWillUnmount = function () { + if (!this.tracker) return + this.tracker.stop() +} + diff --git a/old-ui/app/components/tooltip.js b/old-ui/app/components/tooltip.js new file mode 100644 index 000000000..efab2c497 --- /dev/null +++ b/old-ui/app/components/tooltip.js @@ -0,0 +1,22 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const ReactTooltip = require('react-tooltip-component') + +module.exports = Tooltip + +inherits(Tooltip, Component) +function Tooltip () { + Component.call(this) +} + +Tooltip.prototype.render = function () { + const props = this.props + const { position, title, children } = props + + return h(ReactTooltip, { + position: position || 'left', + title, + fixed: true, + }, children) +} diff --git a/old-ui/app/components/transaction-list-item-icon.js b/old-ui/app/components/transaction-list-item-icon.js new file mode 100644 index 000000000..f442b05af --- /dev/null +++ b/old-ui/app/components/transaction-list-item-icon.js @@ -0,0 +1,68 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const Tooltip = require('./tooltip') + +const Identicon = require('./identicon') + +module.exports = TransactionIcon + +inherits(TransactionIcon, Component) +function TransactionIcon () { + Component.call(this) +} + +TransactionIcon.prototype.render = function () { + const { transaction, txParams, isMsg } = this.props + switch (transaction.status) { + case 'unapproved': + return h(!isMsg ? '.unapproved-tx-icon' : 'i.fa.fa-certificate.fa-lg') + + case 'rejected': + return h('i.fa.fa-exclamation-triangle.fa-lg.warning', { + style: { + width: '24px', + }, + }) + + case 'failed': + return h('i.fa.fa-exclamation-triangle.fa-lg.error', { + style: { + width: '24px', + }, + }) + + case 'submitted': + return h(Tooltip, { + title: 'Pending', + position: 'right', + }, [ + h('i.fa.fa-ellipsis-h', { + style: { + fontSize: '27px', + }, + }), + ]) + } + + if (isMsg) { + return h('i.fa.fa-certificate.fa-lg', { + style: { + width: '24px', + }, + }) + } + + if (txParams.to) { + return h(Identicon, { + diameter: 24, + address: txParams.to || transaction.hash, + }) + } else { + return h('i.fa.fa-file-text-o.fa-lg', { + style: { + width: '24px', + }, + }) + } +} diff --git a/old-ui/app/components/transaction-list-item.js b/old-ui/app/components/transaction-list-item.js new file mode 100644 index 000000000..891d5e227 --- /dev/null +++ b/old-ui/app/components/transaction-list-item.js @@ -0,0 +1,175 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const EthBalance = require('./eth-balance') +const addressSummary = require('../util').addressSummary +const explorerLink = require('etherscan-link').createExplorerLink +const CopyButton = require('./copyButton') +const vreme = new (require('vreme'))() +const Tooltip = require('./tooltip') +const numberToBN = require('number-to-bn') + +const TransactionIcon = require('./transaction-list-item-icon') +const ShiftListItem = require('./shift-list-item') +module.exports = TransactionListItem + +inherits(TransactionListItem, Component) +function TransactionListItem () { + Component.call(this) +} + +TransactionListItem.prototype.render = function () { + const { transaction, network, conversionRate, currentCurrency } = this.props + if (transaction.key === 'shapeshift') { + if (network === '1') return h(ShiftListItem, transaction) + } + var date = formatDate(transaction.time) + + let isLinkable = false + const numericNet = parseInt(network) + isLinkable = numericNet === 1 || numericNet === 3 || numericNet === 4 || numericNet === 42 + + var isMsg = ('msgParams' in transaction) + var isTx = ('txParams' in transaction) + var isPending = transaction.status === 'unapproved' + let txParams + if (isTx) { + txParams = transaction.txParams + } else if (isMsg) { + txParams = transaction.msgParams + } + + const nonce = txParams.nonce ? numberToBN(txParams.nonce).toString(10) : '' + + const isClickable = ('hash' in transaction && isLinkable) || isPending + return ( + h(`.transaction-list-item.flex-row.flex-space-between${isClickable ? '.pointer' : ''}`, { + onClick: (event) => { + if (isPending) { + this.props.showTx(transaction.id) + } + event.stopPropagation() + if (!transaction.hash || !isLinkable) return + var url = explorerLink(transaction.hash, parseInt(network)) + global.platform.openWindow({ url }) + }, + style: { + padding: '20px 0', + }, + }, [ + + h('.identicon-wrapper.flex-column.flex-center.select-none', [ + h(TransactionIcon, { txParams, transaction, isTx, isMsg }), + ]), + + h(Tooltip, { + title: 'Transaction Number', + position: 'right', + }, [ + h('span', { + style: { + display: 'flex', + cursor: 'normal', + flexDirection: 'column', + alignItems: 'center', + justifyContent: 'center', + padding: '10px', + }, + }, nonce), + ]), + + h('.flex-column', {style: {width: '200px', overflow: 'hidden'}}, [ + domainField(txParams), + h('div', date), + recipientField(txParams, transaction, isTx, isMsg), + ]), + + // Places a copy button if tx is successful, else places a placeholder empty div. + transaction.hash ? h(CopyButton, { value: transaction.hash }) : h('div', {style: { display: 'flex', alignItems: 'center', width: '26px' }}), + + isTx ? h(EthBalance, { + value: txParams.value, + conversionRate, + currentCurrency, + width: '55px', + shorten: true, + showFiat: false, + style: {fontSize: '15px'}, + }) : h('.flex-column'), + ]) + ) +} + +function domainField (txParams) { + return h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + overflow: 'hidden', + textOverflow: 'ellipsis', + width: '100%', + }, + }, [ + txParams.origin, + ]) +} + +function recipientField (txParams, transaction, isTx, isMsg) { + let message + + if (isMsg) { + message = 'Signature Requested' + } else if (txParams.to) { + message = addressSummary(txParams.to) + } else { + message = 'Contract Published' + } + + return h('div', { + style: { + fontSize: 'x-small', + color: '#ABA9AA', + }, + }, [ + message, + renderErrorOrWarning(transaction), + ]) +} + +function formatDate (date) { + return vreme.format(new Date(date), 'March 16 2014 14:30') +} + +function renderErrorOrWarning (transaction) { + const { status, err, warning } = transaction + + // show rejected + if (status === 'rejected') { + return h('span.error', ' (Rejected)') + } + + // show error + if (err) { + const message = err.message || '' + return ( + h(Tooltip, { + title: message, + position: 'bottom', + }, [ + h(`span.error`, ` (Failed)`), + ]) + ) + } + + // show warning + if (warning) { + const message = warning.message + return h(Tooltip, { + title: message, + position: 'bottom', + }, [ + h(`span.warning`, ` (Warning)`), + ]) + } +} diff --git a/old-ui/app/components/transaction-list.js b/old-ui/app/components/transaction-list.js new file mode 100644 index 000000000..69b72614c --- /dev/null +++ b/old-ui/app/components/transaction-list.js @@ -0,0 +1,87 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits + +const TransactionListItem = require('./transaction-list-item') + +module.exports = TransactionList + + +inherits(TransactionList, Component) +function TransactionList () { + Component.call(this) +} + +TransactionList.prototype.render = function () { + const { transactions, network, unapprovedMsgs, conversionRate } = this.props + + var shapeShiftTxList + if (network === '1') { + shapeShiftTxList = this.props.shapeShiftTxList + } + const txsToRender = !shapeShiftTxList ? transactions.concat(unapprovedMsgs) : transactions.concat(unapprovedMsgs, shapeShiftTxList) + .sort((a, b) => b.time - a.time) + + return ( + + h('section.transaction-list.full-flex-height', { + style: { + justifyContent: 'center', + }, + }, [ + + h('style', ` + .transaction-list .transaction-list-item:not(:last-of-type) { + border-bottom: 1px solid #D4D4D4; + } + .transaction-list .transaction-list-item .ether-balance-label { + display: block !important; + font-size: small; + } + `), + + h('.tx-list', { + style: { + overflowY: 'auto', + height: '100%', + padding: '0 20px', + textAlign: 'center', + }, + }, [ + + txsToRender.length + ? txsToRender.map((transaction, i) => { + let key + switch (transaction.key) { + case 'shapeshift': + const { depositAddress, time } = transaction + key = `shift-tx-${depositAddress}-${time}-${i}` + break + default: + key = `tx-${transaction.id}-${i}` + } + return h(TransactionListItem, { + transaction, i, network, key, + conversionRate, + showTx: (txId) => { + this.props.viewPendingTx(txId) + }, + }) + }) + : h('.flex-center.full-flex-height', { + style: { + flexDirection: 'column', + justifyContent: 'center', + }, + }, [ + h('p', { + style: { + marginTop: '50px', + }, + }, 'No transaction history.'), + ]), + ]), + ]) + ) +} + diff --git a/old-ui/app/components/typed-message-renderer.js b/old-ui/app/components/typed-message-renderer.js new file mode 100644 index 000000000..d170d63b7 --- /dev/null +++ b/old-ui/app/components/typed-message-renderer.js @@ -0,0 +1,42 @@ +const Component = require('react').Component +const h = require('react-hyperscript') +const inherits = require('util').inherits +const extend = require('xtend') + +module.exports = TypedMessageRenderer + +inherits(TypedMessageRenderer, Component) +function TypedMessageRenderer () { + Component.call(this) +} + +TypedMessageRenderer.prototype.render = function () { + const props = this.props + const { value, style } = props + const text = renderTypedData(value) + + const defaultStyle = extend({ + width: '315px', + maxHeight: '210px', + resize: 'none', + border: 'none', + background: 'white', + padding: '3px', + overflow: 'scroll', + }, style) + + return ( + h('div.font-small', { + style: defaultStyle, + }, text) + ) +} + +function renderTypedData (values) { + return values.map(function (value) { + return h('div', {}, [ + h('strong', {style: {display: 'block', fontWeight: 'bold'}}, String(value.name) + ':'), + h('div', {}, value.value), + ]) + }) +} diff --git a/old-ui/app/conf-tx.js b/old-ui/app/conf-tx.js new file mode 100644 index 000000000..cb1afedfe --- /dev/null +++ b/old-ui/app/conf-tx.js @@ -0,0 +1,235 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') +const NetworkIndicator = require('./components/network') +const txHelper = require('../lib/tx-helper') +const isPopupOrNotification = require('../../app/scripts/lib/is-popup-or-notification') + +const PendingTx = require('./components/pending-tx') +const PendingMsg = require('./components/pending-msg') +const PendingPersonalMsg = require('./components/pending-personal-msg') +const PendingTypedMsg = require('./components/pending-typed-msg') +const Loading = require('./components/loading') + +module.exports = connect(mapStateToProps)(ConfirmTxScreen) + +function mapStateToProps (state) { + return { + identities: state.metamask.identities, + accounts: state.metamask.accounts, + selectedAddress: state.metamask.selectedAddress, + unapprovedTxs: state.metamask.unapprovedTxs, + unapprovedMsgs: state.metamask.unapprovedMsgs, + unapprovedPersonalMsgs: state.metamask.unapprovedPersonalMsgs, + unapprovedTypedMessages: state.metamask.unapprovedTypedMessages, + index: state.appState.currentView.context, + warning: state.appState.warning, + network: state.metamask.network, + provider: state.metamask.provider, + conversionRate: state.metamask.conversionRate, + currentCurrency: state.metamask.currentCurrency, + blockGasLimit: state.metamask.currentBlockGasLimit, + computedBalances: state.metamask.computedBalances, + } +} + +inherits(ConfirmTxScreen, Component) +function ConfirmTxScreen () { + Component.call(this) +} + +ConfirmTxScreen.prototype.render = function () { + const props = this.props + const { network, provider, unapprovedTxs, currentCurrency, computedBalances, + unapprovedMsgs, unapprovedPersonalMsgs, unapprovedTypedMessages, conversionRate, blockGasLimit } = props + + var unconfTxList = txHelper(unapprovedTxs, unapprovedMsgs, unapprovedPersonalMsgs, unapprovedTypedMessages, network) + + var txData = unconfTxList[props.index] || {} + var txParams = txData.params || {} + var isNotification = isPopupOrNotification() === 'notification' + + log.info(`rendering a combined ${unconfTxList.length} unconf msg & txs`) + if (unconfTxList.length === 0) return h(Loading, { isLoading: true }) + + const unconfTxListLength = unconfTxList.length + + return ( + + h('.flex-column.flex-grow', [ + + // subtitle and nav + h('.section-title.flex-row.flex-center', [ + !isNotification ? h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: this.goHome.bind(this), + }) : null, + h('h2.page-subtitle', 'Confirm Transaction'), + isNotification ? h(NetworkIndicator, { + network: network, + provider: provider, + }) : null, + ]), + + h('h3', { + style: { + alignSelf: 'center', + display: unconfTxList.length > 1 ? 'block' : 'none', + }, + }, [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + style: { + display: props.index === 0 ? 'none' : 'inline-block', + }, + onClick: () => props.dispatch(actions.previousTx()), + }), + ` ${props.index + 1} of ${unconfTxList.length} `, + h('i.fa.fa-arrow-right.fa-lg.cursor-pointer', { + style: { + display: props.index + 1 === unconfTxList.length ? 'none' : 'inline-block', + }, + onClick: () => props.dispatch(actions.nextTx()), + }), + ]), + + warningIfExists(props.warning), + + currentTxView({ + // Properties + txData: txData, + key: txData.id, + selectedAddress: props.selectedAddress, + accounts: props.accounts, + identities: props.identities, + conversionRate, + currentCurrency, + blockGasLimit, + unconfTxListLength, + computedBalances, + // Actions + buyEth: this.buyEth.bind(this, txParams.from || props.selectedAddress), + sendTransaction: this.sendTransaction.bind(this), + cancelTransaction: this.cancelTransaction.bind(this, txData), + cancelAllTransactions: this.cancelAllTransactions.bind(this, unconfTxList), + signMessage: this.signMessage.bind(this, txData), + signPersonalMessage: this.signPersonalMessage.bind(this, txData), + signTypedMessage: this.signTypedMessage.bind(this, txData), + cancelMessage: this.cancelMessage.bind(this, txData), + cancelPersonalMessage: this.cancelPersonalMessage.bind(this, txData), + cancelTypedMessage: this.cancelTypedMessage.bind(this, txData), + }), + ]) + ) +} + +function currentTxView (opts) { + log.info('rendering current tx view') + const { txData } = opts + const { txParams, msgParams, type } = txData + + if (txParams) { + log.debug('txParams detected, rendering pending tx') + return h(PendingTx, opts) + } else if (msgParams) { + log.debug('msgParams detected, rendering pending msg') + + if (type === 'eth_sign') { + log.debug('rendering eth_sign message') + return h(PendingMsg, opts) + } else if (type === 'personal_sign') { + log.debug('rendering personal_sign message') + return h(PendingPersonalMsg, opts) + } else if (type === 'eth_signTypedData') { + log.debug('rendering eth_signTypedData message') + return h(PendingTypedMsg, opts) + } + } +} + +ConfirmTxScreen.prototype.buyEth = function (address, event) { + event.preventDefault() + this.props.dispatch(actions.buyEthView(address)) +} + +ConfirmTxScreen.prototype.sendTransaction = function (txData, event) { + this.stopPropagation(event) + this.props.dispatch(actions.updateAndApproveTx(txData)) +} + +ConfirmTxScreen.prototype.cancelTransaction = function (txData, event) { + this.stopPropagation(event) + event.preventDefault() + this.props.dispatch(actions.cancelTx(txData)) +} + +ConfirmTxScreen.prototype.cancelAllTransactions = function (unconfTxList, event) { + this.stopPropagation(event) + event.preventDefault() + this.props.dispatch(actions.cancelAllTx(unconfTxList)) +} + +ConfirmTxScreen.prototype.signMessage = function (msgData, event) { + log.info('conf-tx.js: signing message') + var params = msgData.msgParams + params.metamaskId = msgData.id + this.stopPropagation(event) + this.props.dispatch(actions.signMsg(params)) +} + +ConfirmTxScreen.prototype.stopPropagation = function (event) { + if (event.stopPropagation) { + event.stopPropagation() + } +} + +ConfirmTxScreen.prototype.signPersonalMessage = function (msgData, event) { + log.info('conf-tx.js: signing personal message') + var params = msgData.msgParams + params.metamaskId = msgData.id + this.stopPropagation(event) + this.props.dispatch(actions.signPersonalMsg(params)) +} + +ConfirmTxScreen.prototype.signTypedMessage = function (msgData, event) { + log.info('conf-tx.js: signing typed message') + var params = msgData.msgParams + params.metamaskId = msgData.id + this.stopPropagation(event) + this.props.dispatch(actions.signTypedMsg(params)) +} + +ConfirmTxScreen.prototype.cancelMessage = function (msgData, event) { + log.info('canceling message') + this.stopPropagation(event) + this.props.dispatch(actions.cancelMsg(msgData)) +} + +ConfirmTxScreen.prototype.cancelPersonalMessage = function (msgData, event) { + log.info('canceling personal message') + this.stopPropagation(event) + this.props.dispatch(actions.cancelPersonalMsg(msgData)) +} + +ConfirmTxScreen.prototype.cancelTypedMessage = function (msgData, event) { + log.info('canceling typed message') + this.stopPropagation(event) + this.props.dispatch(actions.cancelTypedMsg(msgData)) +} + +ConfirmTxScreen.prototype.goHome = function (event) { + this.stopPropagation(event) + this.props.dispatch(actions.goHome()) +} + +function warningIfExists (warning) { + if (warning && + // Do not display user rejections on this screen: + warning.indexOf('User denied transaction signature') === -1) { + return h('.error', { + style: { + margin: 'auto', + }, + }, warning) + } +} diff --git a/old-ui/app/config.js b/old-ui/app/config.js new file mode 100644 index 000000000..c14fa1d28 --- /dev/null +++ b/old-ui/app/config.js @@ -0,0 +1,220 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') +const infuraCurrencies = require('./infura-conversion.json').objects.sort((a, b) => { + return a.quote.name.toLocaleLowerCase().localeCompare(b.quote.name.toLocaleLowerCase()) + }) +const validUrl = require('valid-url') +const exportAsFile = require('./util').exportAsFile + + +module.exports = connect(mapStateToProps)(ConfigScreen) + +function mapStateToProps (state) { + return { + metamask: state.metamask, + warning: state.appState.warning, + } +} + +inherits(ConfigScreen, Component) +function ConfigScreen () { + Component.call(this) +} + +ConfigScreen.prototype.render = function () { + var state = this.props + var metamaskState = state.metamask + var warning = state.warning + + return ( + h('.flex-column.flex-grow', [ + + // subtitle and nav + h('.section-title.flex-row.flex-center', [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: (event) => { + state.dispatch(actions.goHome()) + }, + }), + h('h2.page-subtitle', 'Settings'), + ]), + + h('.error', { + style: { + display: warning ? 'block' : 'none', + padding: '0 20px', + textAlign: 'center', + }, + }, warning), + + // conf view + h('.flex-column.flex-justify-center.flex-grow.select-none', [ + h('.flex-space-around', { + style: { + padding: '20px', + }, + }, [ + + currentProviderDisplay(metamaskState), + + h('div', { style: {display: 'flex'} }, [ + h('input#new_rpc', { + placeholder: 'New RPC URL', + style: { + width: 'inherit', + flex: '1 0 auto', + height: '30px', + margin: '8px', + }, + onKeyPress (event) { + if (event.key === 'Enter') { + var element = event.target + var newRpc = element.value + rpcValidation(newRpc, state) + } + }, + }), + h('button', { + style: { + alignSelf: 'center', + }, + onClick (event) { + event.preventDefault() + var element = document.querySelector('input#new_rpc') + var newRpc = element.value + rpcValidation(newRpc, state) + }, + }, 'Save'), + ]), + + h('hr.horizontal-line'), + + currentConversionInformation(metamaskState, state), + + h('hr.horizontal-line'), + + h('div', { + style: { + marginTop: '20px', + }, + }, [ + h('p', { + style: { + fontFamily: 'Montserrat Light', + fontSize: '13px', + }, + }, `State logs contain your public account addresses and sent transactions.`), + h('br'), + h('button', { + style: { + alignSelf: 'center', + }, + onClick (event) { + window.logStateString((err, result) => { + if (err) { + state.dispatch(actions.displayWarning('Error in retrieving state logs.')) + } else { + exportAsFile('MetaMask State Logs', result) + } + }) + }, + }, 'Download State Logs'), + ]), + + h('hr.horizontal-line'), + + h('div', { + style: { + marginTop: '20px', + }, + }, [ + h('button', { + style: { + alignSelf: 'center', + }, + onClick (event) { + event.preventDefault() + state.dispatch(actions.revealSeedConfirmation()) + }, + }, 'Reveal Seed Words'), + ]), + + ]), + ]), + ]) + ) +} + +function rpcValidation (newRpc, state) { + if (validUrl.isWebUri(newRpc)) { + state.dispatch(actions.setRpcTarget(newRpc)) + } else { + var appendedRpc = `http://${newRpc}` + if (validUrl.isWebUri(appendedRpc)) { + state.dispatch(actions.displayWarning('URIs require the appropriate HTTP/HTTPS prefix.')) + } else { + state.dispatch(actions.displayWarning('Invalid RPC URI')) + } + } +} + +function currentConversionInformation (metamaskState, state) { + var currentCurrency = metamaskState.currentCurrency + var conversionDate = metamaskState.conversionDate + return h('div', [ + h('span', {style: { fontWeight: 'bold', paddingRight: '10px'}}, 'Current Conversion'), + h('span', {style: { fontWeight: 'bold', paddingRight: '10px', fontSize: '13px'}}, `Updated ${Date(conversionDate)}`), + h('select#currentCurrency', { + onChange (event) { + event.preventDefault() + var element = document.getElementById('currentCurrency') + var newCurrency = element.value + state.dispatch(actions.setCurrentCurrency(newCurrency)) + }, + defaultValue: currentCurrency, + }, infuraCurrencies.map((currency) => { + return h('option', {key: currency.quote.code, value: currency.quote.code}, `${currency.quote.code.toUpperCase()} - ${currency.quote.name}`) + }) + ), + ]) +} + +function currentProviderDisplay (metamaskState) { + var provider = metamaskState.provider + var title, value + + switch (provider.type) { + + case 'mainnet': + title = 'Current Network' + value = 'Main Ethereum Network' + break + + case 'ropsten': + title = 'Current Network' + value = 'Ropsten Test Network' + break + + case 'kovan': + title = 'Current Network' + value = 'Kovan Test Network' + break + + case 'rinkeby': + title = 'Current Network' + value = 'Rinkeby Test Network' + break + + default: + title = 'Current RPC' + value = metamaskState.provider.rpcTarget + } + + return h('div', [ + h('span', {style: { fontWeight: 'bold', paddingRight: '10px'}}, title), + h('span', value), + ]) +} diff --git a/old-ui/app/css/debug.css b/old-ui/app/css/debug.css new file mode 100644 index 000000000..3e125bcd4 --- /dev/null +++ b/old-ui/app/css/debug.css @@ -0,0 +1,21 @@ +/* +debug / dev +*/ + +#app-content { + border: 2px solid green; +} + +#design-container { + position: absolute; + left: 360px; + top: -42px; + width: calc(100vw - 360px); + height: 100vh; + overflow: scroll; +} + +#design-container img { + width: 2000px; + margin-right: 600px; +} \ No newline at end of file diff --git a/old-ui/app/css/fonts.css b/old-ui/app/css/fonts.css new file mode 100644 index 000000000..3b9f581b9 --- /dev/null +++ b/old-ui/app/css/fonts.css @@ -0,0 +1,36 @@ +@import url(https://fonts.googleapis.com/css?family=Roboto:300,500); +@import url(https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css); + +@font-face { + font-family: 'Montserrat Regular'; + src: url('/fonts/Montserrat/Montserrat-Regular.woff') format('woff'); + src: url('/fonts/Montserrat/Montserrat-Regular.ttf') format('truetype'); + font-weight: normal; + font-style: normal; + font-size: 'small'; + +} + +@font-face { + font-family: 'Montserrat Bold'; + src: url('/fonts/Montserrat/Montserrat-Bold.woff') format('woff'); + src: url('/fonts/Montserrat/Montserrat-Bold.ttf') format('truetype'); + font-weight: normal; + font-style: normal; +} + +@font-face { + font-family: 'Montserrat Light'; + src: url('/fonts/Montserrat/Montserrat-Light.woff') format('woff'); + src: url('/fonts/Montserrat/Montserrat-Light.ttf') format('truetype'); + font-weight: normal; + font-style: normal; +} + +@font-face { + font-family: 'Montserrat UltraLight'; + src: url('/fonts/Montserrat/Montserrat-UltraLight.woff') format('woff'); + src: url('/fonts/Montserrat/Montserrat-UltraLight.ttf') format('truetype'); + font-weight: normal; + font-style: normal; +} diff --git a/old-ui/app/css/index.css b/old-ui/app/css/index.css new file mode 100644 index 000000000..0630c4c12 --- /dev/null +++ b/old-ui/app/css/index.css @@ -0,0 +1,707 @@ +/* +faint orange (textfield shades) #FAF6F0 +light orange (button shades): #F5C26D +dark orange (text): #F5A623 +borders/font/any gray: #4A4A4A +*/ + +/* +application specific styles +*/ + +* { + box-sizing: border-box; +} + +html, body { + font-family: 'Montserrat Regular', Arial; + color: #4D4D4D; + font-weight: 300; + line-height: 1.4em; + background: #F7F7F7; + margin: 0; + padding: 0; +} + +html { + min-height: 500px; +} + +.app-root { + overflow: hidden; + position: relative +} + +.app-primary { + display: flex; +} + +input:focus, textarea:focus { + outline: none; +} + +.full-size { + height: 100%; + width: 100%; +} + +.full-width { + width: 100%; +} + +.full-height { + height: 100%; +} + +.full-flex-height { + display: flex; + flex: 1 1 auto; + flex-direction: column; +} + +#app-content { + overflow-x: hidden; + min-width: 357px; + height: 100%; + display: flex; + flex-direction: column; +} + +button, input[type="submit"] { + font-family: 'Montserrat Bold'; + outline: none; + cursor: pointer; + padding: 8px 12px; + border: none; + color: white; + transform-origin: center center; + transition: transform 50ms ease-in; + /* default orange */ + background: rgba(247, 134, 28, 1); + box-shadow: 0px 3px 6px rgba(247, 134, 28, 0.36); +} + +.btn-green, input[type="submit"].btn-green { + background: rgba(106, 195, 96, 1); + box-shadow: 0px 3px 6px rgba(106, 195, 96, 0.36); +} + +.btn-red { + background: rgba(254, 35, 17, 1); + box-shadow: 0px 3px 6px rgba(254, 35, 17, 0.36); +} + +button[disabled], input[type="submit"][disabled] { + cursor: not-allowed; + background: rgba(197, 197, 197, 1); + box-shadow: 0px 3px 6px rgba(197, 197, 197, 0.36); +} + +button.spaced { + margin: 2px; +} + +button:not([disabled]):hover, input[type="submit"]:not([disabled]):hover { + transform: scale(1.1); +} +button:not([disabled]):active, input[type="submit"]:not([disabled]):active { + transform: scale(0.95); +} + +a { + text-decoration: none; + color: inherit; +} + +a:hover{ + color: #df6b0e; +} + +/* +app +*/ + +.active { + color: #909090; +} + +button.primary { + padding: 8px 12px; + background: #F7861C; + box-shadow: 0px 3px 6px rgba(247, 134, 28, 0.36); + color: white; + font-size: 1.1em; + font-family: 'Montserrat Regular'; + text-transform: uppercase; +} + +button.btn-thin { + border: 1px solid; + border-color: #4D4D4D; + color: #4D4D4D; + background: rgb(255, 174, 41); + border-radius: 4px; + min-width: 200px; + margin: 12px 0; + padding: 6px; + font-size: 13px; +} + +.app-header { + padding: 6px 8px; +} + +.app-header h1 { + font-family: 'Montserrat Regular'; + text-transform: uppercase; + color: #AEAEAE; +} + +h2.page-subtitle { + font-family: 'Montserrat Regular'; + text-transform: uppercase; + color: #AEAEAE; + font-size: 1em; + margin: 12px; +} + +.app-footer { + padding-bottom: 10px; + align-items: center; +} + +.identicon { + height: 46px; + width: 46px; + background-size: cover; + border-radius: 100%; + border: 3px solid gray; +} + +textarea.twelve-word-phrase { + padding: 12px; + width: 300px; + height: 140px; + font-size: 16px; + background: white; + resize: none; +} + +.network-indicator { + display: flex; + align-items: center; + font-size: 0.6em; + +} + +.network-name { + width: 5.2em; + line-height: 9px; + text-rendering: geometricPrecision; +} + +.check { + margin-left: 12px; + color: #F7861C; + flex: 1 0 auto; + display: flex; + justify-content: flex-end; +} +/* +app sections +*/ + +/* initialize */ + +.initialize-screen hr { + width: 60px; + margin: 12px; + border-color: #F7861C; + border-style: solid; +} + +.initialize-screen label { + margin-top: 20px; +} + +.initialize-screen button.create-vault { + margin-top: 40px; +} + +.initialize-screen .warning { + font-size: 14px; + margin: 0 16px; +} + +/* unlock */ +.error { + color: #f7861c; + margin-bottom: 9px; +} + +.warning { + color: #FFAE00; +} + +.lock { + width: 50px; + height: 50px; +} + +.lock.locked { + transform: scale(1.5); + opacity: 0.0; + transition: opacity 400ms ease-in, transform 400ms ease-in; +} +.lock.unlocked { + transform: scale(1); + opacity: 1; + transition: opacity 500ms ease-out, transform 500ms ease-out, background 200ms ease-in; +} + +.lock.locked .lock-top { + transform: scaleX(1) translateX(0); + transition: transform 250ms ease-in; +} +.lock.unlocked .lock-top { + transform: scaleX(-1) translateX(-12px); + transition: transform 250ms ease-in; +} +.lock.unlocked:hover { + border-radius: 4px; + background: #e5e5e5; + border: 1px solid #b1b1b1; +} +.lock.unlocked:active { + background: #c3c3c3; +} + +.section-title .fa-arrow-left { + margin: -2px 8px 0px -8px; +} + +.unlock-screen #metamask-mascot-container { + margin-top: 24px; +} + +.unlock-screen h1 { + margin-top: -28px; + margin-bottom: 42px; +} + +.unlock-screen input[type=password] { + width: 260px; + /*height: 36px; + margin-bottom: 24px; + padding: 8px;*/ +} + +.sizing-input{ + font-size: 14px; + height: 30px; + padding-left: 5px; +} +.editable-label{ + display: flex; +} +/* Webkit */ +.unlock-screen input::-webkit-input-placeholder { + text-align: center; + font-size: 1.2em; +} +/* Firefox 18- */ +.unlock-screen input:-moz-placeholder { + text-align: center; + font-size: 1.2em; +} +/* Firefox 19+ */ +.unlock-screen input::-moz-placeholder { + text-align: center; + font-size: 1.2em; +} +/* IE */ +.unlock-screen input:-ms-input-placeholder { + text-align: center; + font-size: 1.2em; +} + +input.large-input, textarea.large-input { + /*margin-bottom: 24px;*/ + padding: 8px; +} + +input.large-input { + height: 36px; +} + +.letter-spacey { + letter-spacing: 0.1em; +} + + + +/* accounts */ + +.accounts-section { + margin: 0 0px; +} + +.accounts-section .horizontal-line { + margin: 0px 18px; +} + +.accounts-list-option { + height: 120px; +} + +.accounts-list-option .identicon-wrapper { + width: 100px; +} + +.unconftx-link { + margin-top: 24px; + cursor: pointer; +} + +.unconftx-link .fa-arrow-right { + margin: 0px -8px 0px 8px; +} + +/* identity panel */ + +.identity-panel { + font-weight: 500; +} + +.identity-panel .identicon-wrapper { + margin: 4px; + margin-top: 8px; + display: flex; + align-items: center; +} + +.identity-panel .identicon-wrapper span { + margin: 0 auto; +} + +.identity-panel .identity-data { + margin: 8px 8px 8px 18px; +} + +.identity-panel i { + margin-top: 32px; + margin-right: 6px; + color: #B9B9B9; +} + +.identity-panel .arrow-right { + padding-left: 18px; + width: 42px; + min-width: 18px; + height: 100%; +} + +.identity-copy.flex-column { + flex: 0.25 0 auto; + justify-content: center; +} + +/* accounts screen */ + +.identity-section { + +} + +.identity-section .identity-panel { + background: #E9E9E9; + border-bottom: 1px solid #B1B1B1; + cursor: pointer; +} + +.identity-section .identity-panel.selected { + background: white; + color: #F3C83E; +} + +.identity-section .identity-panel.selected .identicon { + border-color: orange; +} + +.identity-section .accounts-list-option:hover, +.identity-section .accounts-list-option.selected { + background:white; +} + +/* account detail screen */ + +.account-detail-section { + display: flex; + flex-wrap: wrap; + overflow-y: auto; + flex-direction: inherit; +} + +.grow-tenx { + flex-grow: 10; +} + +.name-label{ + +} + +.unapproved-tx-icon { + height: 16px; + width: 16px; + background: rgb(47, 174, 244); + border-color: #AEAEAE; + border-radius: 13px; +} + +.edit-text { + height: 100%; + visibility: hidden; +} +.editing-label { + display: flex; + justify-content: flex-start; + margin-left: 50px; + margin-bottom: 2px; + font-size: 11px; + text-rendering: geometricPrecision; + color: #F7861C; +} +.name-label:hover .edit-text { + visibility: visible; +} +/* tx confirm */ + +.unconftx-section input[type=password] { + height: 22px; + padding: 2px; + margin: 12px; + margin-bottom: 24px; + border-radius: 4px; + border: 2px solid #F3C83E; + background: #FAF6F0; +} + +/* Send Screen */ + +.send-screen { + +} + +.send-screen section { + margin: 8px 16px; +} + +.send-screen input { + width: 100%; + font-size: 12px; +} + +/* Ether Balance Widget */ + +.ether-balance-amount { + color: #F7861C; +} + +.ether-balance-label { + color: #ABA9AA; +} + +/* Info screen */ +.info-gray{ + font-family: 'Montserrat Regular'; + text-transform: uppercase; + color: #AEAEAE; +} + +.icon-size{ + width: 20px; +} + +.info{ + font-family: 'Montserrat Regular', Arial; + padding-bottom: 10px; + display: inline-block; + padding-left: 5px; +} + +/* buy eth warning screen */ +.custom-radios { + justify-content: space-around; + align-items: center; +} + + +.custom-radio-selected { + width: 17px; + height: 17px; + border: solid; + border-style: double; + border-radius: 15px; + border-width: 5px; + background: rgba(247, 134, 28, 1); + border-color: #F7F7F7; +} + +.custom-radio-inactive { + width: 14px; + height: 14px; + border: solid; + border-width: 1px; + border-radius: 24px; + border-color: #AEAEAE; +} + +.radio-titles { + color: rgba(247, 134, 28, 1); +} + +.radio-titles-subtext { + +} + +.selected-exchange { + +} + +.buy-radio { + +} + +.eth-warning{ + transition: opacity 400ms ease-in, transform 400ms ease-in; +} + +.buy-subview{ + transition: opacity 400ms ease-in, transform 400ms ease-in; +} + +.input-container:hover .edit-text{ + visibility: visible; +} + +.buy-inputs{ + font-family: 'Montserrat Light'; + font-size: 13px; + height: 20px; + background: transparent; + box-sizing: border-box; + border: solid; + border-color: transparent; + border-width: 0.5px; + border-radius: 2px; + +} +.input-container:hover .buy-inputs{ + box-sizing: inherit; + border: solid; + border-color: #F7861C; + border-width: 0.5px; + border-radius: 2px; +} + +.buy-inputs:focus{ + border: solid; + border-color: #F7861C; + border-width: 0.5px; + border-radius: 2px; +} + +.activeForm { + background: #F7F7F7; + border: none; + border-radius: 8px 8px 0px 0px; + width: 50%; + text-align: center; + padding-bottom: 4px; + +} + +.inactiveForm { + border: none; + border-radius: 8px 8px 0px 0px; + width: 50%; + text-align: center; + padding-bottom: 4px; +} + +.ex-coins { + font-family: 'Montserrat Regular'; + text-transform: uppercase; + text-align: center; + font-size: 33px; + width: 118px; + height: 42px; + padding: 1px; + color: #4D4D4D; +} + +.marketinfo{ + font-family: 'Montserrat light'; + color: #AEAEAE; + font-size: 15px; + line-height: 17px; +} + +#fromCoin::-webkit-calendar-picker-indicator { + display: none; +} + +#coinList { + width: 400px; + height: 500px; + overflow: scroll; +} + +.icon-control .fa-refresh{ + visibility: hidden; +} + +.icon-control:hover .fa-refresh{ + visibility: visible; +} + +.icon-control:hover .fa-chevron-right{ + visibility: hidden; +} + +.inactive { + color: #AEAEAE; +} + +.inactive button{ + background: #AEAEAE; + color: white; +} + +.ellip-address { + overflow: hidden; + text-overflow: ellipsis; + width: 5em; + font-size: 14px; + font-family: "Montserrat Light"; + margin-left: 5px; +} + +.qr-header { + font-size: 25px; + margin-top: 40px; +} + +.qr-message { + font-size: 12px; + color: #F7861C; +} + +div.message-container > div:first-child { + margin-top: 18px; + font-size: 15px; + color: #4D4D4D; +} + +.pop-hover:hover { + transform: scale(1.1); +} diff --git a/old-ui/app/css/lib.css b/old-ui/app/css/lib.css new file mode 100644 index 000000000..f3acbee76 --- /dev/null +++ b/old-ui/app/css/lib.css @@ -0,0 +1,306 @@ +/* color */ + +.color-orange { + color: #F7861C; +} + +.color-forest { + color: #0A5448; +} + +/* lib */ + +.full-width { + width: 100%; +} + +.full-height { + height: 100%; +} + +.flex-column { + display: flex; + flex-direction: column; +} + +.space-between { + justify-content: space-between; +} + +.space-around { + justify-content: space-around; +} + +.flex-column-bottom { + display: flex; + flex-direction: column-reverse; +} + +.flex-row { + display: flex; + flex-direction: row; +} + +.flex-space-between { + justify-content: space-between; +} + +.flex-space-around { + justify-content: space-around; +} + +.flex-right { + display: flex; + flex-direction: row; + justify-content: flex-end; +} + +.flex-left { + display: flex; + flex-direction: row; + justify-content: flex-start; +} + +.flex-fixed { + flex: none; +} + +.flex-basis-auto { + flex-basis: auto; +} + +.flex-grow { + flex: 1 1 auto; +} + +.flex-wrap { + flex-wrap: wrap; +} + +.flex-center { + display: flex; + justify-content: center; + align-items: center; +} + +.flex-justify-center { + justify-content: center; +} + +.flex-align-center { + align-items: center; +} + +.flex-self-end { + align-self: flex-end; +} + +.flex-self-stretch { + align-self: stretch; +} + +.flex-vertical { + flex-direction: column; +} + +.z-bump { + z-index: 1; +} + +.select-none { + cursor: inherit; + -moz-user-select: none; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.pointer { + cursor: pointer; +} +.cursor-pointer { + cursor: pointer; + transform-origin: center center; + transition: transform 50ms ease-in-out; +} +.cursor-pointer:hover { + transform: scale(1.1); +} +.cursor-pointer:active { + transform: scale(0.95); +} + +.cursor-disabled { + cursor: not-allowed; +} + +.margin-bottom-sml { + margin-bottom: 20px; +} + +.margin-bottom-med { + margin-bottom: 40px; +} + +.margin-right-left { + margin: 0 20px; +} + +.bold { + font-weight: bold; +} + +.text-transform-uppercase { + text-transform: uppercase; +} + +.font-small { + font-size: 12px; +} + +.font-medium { + font-size: 1.2em; +} + +hr.horizontal-line { + display: block; + height: 1px; + border: 0; + border-top: 1px solid #ccc; + margin: 1em 0; + padding: 0; +} + +.hover-white:hover { + background: white; +} + +.red-dot { + background: #E91550; + color: white; + border-radius: 10px; +} + +.diamond { + transform: rotate(45deg); + background: #038789; +} + +.hollow-diamond { + transform: rotate(45deg); + border: 3px solid #690496; +} + +.golden-square { + background: #EBB33F; +} + +.pending-dot { + background: red; + left: 14px; + top: 14px; + color: white; + border-radius: 10px; + height: 20px; + min-width: 20px; + position: relative; + display: flex; + align-items: center; + justify-content: center; + padding: 4px; + z-index: 1; +} + +.keyring-label { + z-index: 1; + font-size: 11px; + background: rgba(255,0,0,0.8); + color: white; + bottom: 0px; + left: -8px; + border-radius: 10px; + height: 20px; + min-width: 20px; + position: absolute; + display: flex; + align-items: center; + justify-content: center; + padding: 4px; +} + +.ether-balance { + display: flex; + align-items: center; +} + +.tabSection { + min-width: 350px; +} + +.menu-icon { + display: inline-block; + height: 12px; + min-width: 12px; + margin: 13px; +} + +i.fa.fa-question-circle.fa-lg.menu-icon { + font-size: 18px; +} + +.ether-icon { + background: rgb(0, 163, 68); + border-radius: 20px; +} +.testnet-icon { + background: #2465E1; +} + +.drop-menu-item { + display: flex; + align-items: center; +} + +.invisible { + visibility: hidden; +} + +.one-line-concat { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.critical-error { + text-align: center; + margin-top: 20px; + color: red; +} + +/* + Hacky breakpoint fix for account + tab sections + Resolves issue from @frankiebee in + https://github.com/MetaMask/metamask-extension/pull/1835 + Please remove this when integrating new designs + */ + +@media screen and (min-width: 575px) and (max-width: 800px) { + .account-data-subsection { + flex: 0 0 auto !important; // reset flex + margin-left: 10px !important; // create additional horizontal space + margin-right: 10px !important; + width: 40%; + } + + .tabSection { + flex: 0 0 auto !important; + margin-left: 10px !important; + margin-right: 10px !important; + min-width: 285px; + width: 49%; + } + + .name-label { + width: 80%; + } +} diff --git a/old-ui/app/css/output/index.css b/old-ui/app/css/output/index.css new file mode 100644 index 000000000..84ceb3bd7 --- /dev/null +++ b/old-ui/app/css/output/index.css @@ -0,0 +1,5385 @@ +@charset "UTF-8"; +/* + ITCSS + + http://www.creativebloq.com/web-design/manage-large-css-projects-itcss-101517528 + https://www.xfive.co/blog/itcss-scalable-maintainable-css-architecture/ + */ +/* + Variables + */ +/* + Colors + http://chir.ag/projects/name-that-color + */ +/* + Z-Indicies + */ +/* + Z Indicies - Current + app - 11 + hex/bn as decimal input - 1 - remove? + dropdown - 11 + loading - 10 - higher? + mascot - 0 - remove? + */ +/* + Responsive Breakpoints + */ +@import url("https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900"); +@import url("https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css"); +@font-face { + font-family: 'Montserrat Regular'; + src: url("/fonts/Montserrat/Montserrat-Regular.woff") format("woff"); + src: url("/fonts/Montserrat/Montserrat-Regular.ttf") format("truetype"); + font-weight: 400; + font-style: normal; + font-size: 'small'; } + +@font-face { + font-family: 'Montserrat Bold'; + src: url("/fonts/Montserrat/Montserrat-Bold.woff") format("woff"); + src: url("/fonts/Montserrat/Montserrat-Bold.ttf") format("truetype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'Montserrat Light'; + src: url("/fonts/Montserrat/Montserrat-Light.woff") format("woff"); + src: url("/fonts/Montserrat/Montserrat-Light.ttf") format("truetype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'Montserrat UltraLight'; + src: url("/fonts/Montserrat/Montserrat-UltraLight.woff") format("woff"); + src: url("/fonts/Montserrat/Montserrat-UltraLight.ttf") format("truetype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'DIN OT'; + src: url("/fonts/DIN_OT/DINOT-2.otf") format("opentype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'DIN OT Light'; + src: url("/fonts/DIN_OT/DINOT-2.otf") format("opentype"); + font-weight: 200; + font-style: normal; } + +@font-face { + font-family: 'DIN NEXT'; + src: url("/fonts/DIN NEXT/DIN NEXT W01 Regular.otf") format("opentype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'DIN NEXT Light'; + src: url("/fonts/DIN NEXT/DIN NEXT W10 Light.otf") format("opentype"); + font-weight: 400; + font-style: normal; } + +@font-face { + font-family: 'Lato'; + src: url("/fonts/Lato/Lato-Regular.ttf") format("truetype"); + font-weight: 400; + font-style: normal; } + +/* + Utility Classes + */ +/* color */ +.color-orange { + color: #f7861c; } + +.color-forest { + color: #0a5448; } + +/* lib */ +.full-size { + height: 100%; + width: 100%; } + +.full-width { + width: 100%; } + +.full-flex-height { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + +.full-height { + height: 100%; } + +.flex-column { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + +.space-between { + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; } + +.space-around { + -ms-flex-pack: distribute; + justify-content: space-around; } + +.flex-column-bottom { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: reverse; + -ms-flex-direction: column-reverse; + flex-direction: column-reverse; } + +.flex-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; } + +.flex-space-between { + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; } + +.flex-space-around { + -ms-flex-pack: distribute; + justify-content: space-around; } + +.flex-right { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: end; + -ms-flex-pack: end; + justify-content: flex-end; } + +.flex-left { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; } + +.flex-fixed { + -webkit-box-flex: 0; + -ms-flex: none; + flex: none; } + +.flex-basis-auto { + -ms-flex-preferred-size: auto; + flex-basis: auto; } + +.flex-grow { + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } + +.flex-wrap { + -ms-flex-wrap: wrap; + flex-wrap: wrap; } + +.flex-center { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.flex-justify-center { + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + +.flex-align-center { + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.flex-self-end { + -ms-flex-item-align: end; + align-self: flex-end; } + +.flex-self-stretch { + -ms-flex-item-align: stretch; + align-self: stretch; } + +.flex-vertical { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + +.z-bump { + z-index: 1; } + +.select-none { + cursor: inherit; + -moz-user-select: none; + -webkit-user-select: none; + -ms-user-select: none; + user-select: none; } + +.pointer { + cursor: pointer; } + +.cursor-pointer { + cursor: pointer; + -webkit-transform-origin: center center; + transform-origin: center center; + -webkit-transition: -webkit-transform 50ms ease-in-out; + transition: -webkit-transform 50ms ease-in-out; + transition: transform 50ms ease-in-out; + transition: transform 50ms ease-in-out, -webkit-transform 50ms ease-in-out; } + +.cursor-pointer:hover { + -webkit-transform: scale(1.1); + transform: scale(1.1); } + +.cursor-pointer:active { + -webkit-transform: scale(0.95); + transform: scale(0.95); } + +.cursor-disabled { + cursor: not-allowed; } + +.margin-bottom-sml { + margin-bottom: 20px; } + +.margin-bottom-med { + margin-bottom: 40px; } + +.margin-right-left { + margin: 0 20px; } + +.bold { + font-weight: 700; } + +.text-transform-uppercase { + text-transform: uppercase; } + +.font-small { + font-size: 12px; } + +.font-medium { + font-size: 1.2em; } + +hr.horizontal-line { + display: block; + height: 1px; + border: 0; + border-top: 1px solid #ccc; + margin: 1em 0; + padding: 0; } + +.hover-white:hover { + background: #fff; } + +.red-dot { + background: #e91550; + color: #fff; + border-radius: 10px; } + +.diamond { + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + background: #038789; } + +.hollow-diamond { + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + border: 3px solid #690496; } + +.golden-square { + background: #ebb33f; } + +.pending-dot { + background: #f00; + left: 14px; + top: 14px; + color: #fff; + border-radius: 10px; + height: 20px; + min-width: 20px; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + padding: 4px; + z-index: 1; } + +.keyring-label { + z-index: 1; + font-size: 8px; + line-height: 8px; + background: rgba(255, 255, 255, 0.4); + color: #fff; + border-radius: 10px; + padding: 4px; + text-align: center; + height: 15px; } + +.ether-balance { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.tabSection { + min-width: 350px; } + +.menu-icon { + display: inline-block; + height: 12px; + min-width: 12px; + margin: 13px; } + +.ether-icon { + background: #00a344; + border-radius: 20px; } + +.testnet-icon { + background: #2465e1; } + +.drop-menu-item { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.invisible { + visibility: hidden; } + +.one-line-concat { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; } + +.critical-error { + text-align: center; + margin-top: 20px; + color: #f00; } + +/* + Misc + */ +.letter-spacey { + letter-spacing: .1em; } + +.active { + color: #909090; } + +.check { + margin-left: 7px; + color: #f7861c; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: end; + -ms-flex-pack: end; + justify-content: flex-end; } + +/* + Generic + */ +/* http://meyerweb.com/eric/tools/css/reset/ + v2.0 | 20110126 + License: none (public domain) +*/ +html, +body, +div, +span, +applet, +object, +iframe, +h1, +h2, +h3, +h4, +h5, +h6, +p, +blockquote, +pre, +a, +abbr, +acronym, +address, +big, +cite, +code, +del, +dfn, +em, +img, +ins, +kbd, +q, +s, +samp, +small, +strike, +strong, +sub, +sup, +tt, +var, +b, +u, +i, +center, +dl, +dt, +dd, +ol, +ul, +li, +fieldset, +form, +label, +legend, +table, +caption, +tbody, +tfoot, +thead, +tr, +th, +td, +article, +aside, +canvas, +details, +embed, +figure, +figcaption, +footer, +header, +hgroup, +menu, +nav, +output, +ruby, +section, +summary, +time, +mark, +audio, +video { + margin: 0; + padding: 0; + border: 0; + font-size: 100%; + /* stylelint-disable */ + font: inherit; + /* stylelint-enable */ + vertical-align: baseline; } + +/* HTML5 display-role reset for older browsers */ +/* stylelint-disable */ +article, +aside, +details, +figcaption, +figure, +footer, +header, +hgroup, +menu, +nav, +section { + display: block; } + +body { + line-height: 1; } + +ol, +ul { + list-style: none; } + +blockquote, +q { + quotes: none; } + +blockquote:before, +blockquote:after, +q:before, +q:after { + content: ''; + content: none; } + +table { + border-collapse: collapse; + border-spacing: 0; } + +button { + border-style: none; + cursor: pointer; } + +/* stylelint-enable */ +* { + -webkit-box-sizing: border-box; + box-sizing: border-box; } + +html, +body { + font-family: Roboto, Arial; + color: #4d4d4d; + font-weight: 300; + line-height: 1.4em; + background: #f7f7f7; + width: 100%; + height: 100%; + margin: 0; + padding: 0; } + +html { + min-height: 500px; } + +.app-root { + overflow: hidden; + position: relative; } + +.app-primary { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + +input:focus, +textarea:focus { + outline: none; } + +/* stylelint-disable */ +#app-content { + overflow-x: hidden; + height: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + @media screen and (max-width: 575px) { + #app-content { + background-color: #fff; } } + +/* stylelint-enable */ +a { + text-decoration: none; + color: inherit; } + +a:hover { + color: #df6b0e; } + +input.large-input, +textarea.large-input { + padding: 8px; } + +input.large-input { + height: 36px; } + +/* + Buttons + */ +.btn-green { + background-color: #02c9b1; } + +button.btn-clear { + background: #fff; + border: 1px solid; } + +button[disabled], +input[type="submit"][disabled] { + cursor: not-allowed; + opacity: .5; } + +button.primary { + padding: 8px 12px; + background: #f7861c; + -webkit-box-shadow: 0 3px 6px rgba(247, 134, 28, 0.36); + box-shadow: 0 3px 6px rgba(247, 134, 28, 0.36); + color: #fff; + font-size: 1.1em; + font-family: Roboto; + text-transform: uppercase; } + +.btn-light { + padding: 8px 12px; + -webkit-box-shadow: 0 3px 6px rgba(247, 134, 28, 0.36); + box-shadow: 0 3px 6px rgba(247, 134, 28, 0.36); + color: #585d67; + font-size: 1.1em; + font-family: Roboto; + text-transform: uppercase; + text-align: center; + line-height: 20px; + border-radius: 2px; + border: 1px solid #979797; + opacity: .5; } + +button.btn-thin { + border: 1px solid; + border-color: #4d4d4d; + color: #4d4d4d; + background: #ffae29; + border-radius: 4px; + min-width: 200px; + margin: 12px 0; + padding: 6px; + font-size: 13px; } + +.btn-secondary { + border: 1px solid #979797; + border-radius: 2px; + background-color: #fff; + font-size: 16px; + line-height: 24px; + padding: 16px 42px; } + .btn-secondary[disabled] { + background-color: #fff !important; + opacity: .5; } + +.btn-tertiary { + border: 1px solid transparent; + border-radius: 2px; + background-color: transparent; + font-size: 16px; + line-height: 24px; + padding: 16px 42px; } + +.app-header { + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + visibility: visible; + background: #efefef; + position: relative; + z-index: 12; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; } + @media screen and (max-width: 575px) { + .app-header { + padding: 12px; + width: 100%; + -webkit-box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.08); + box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.08); + z-index: 26; } } + @media screen and (min-width: 576px) { + .app-header { + height: 75px; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + .app-header::after { + content: ''; + position: absolute; + width: 100%; + height: 32px; + background: #efefef; + bottom: -32px; } } + .app-header .metafox-icon { + cursor: pointer; } + +.app-header-contents { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + width: 100%; + height: 6.9vh; } + @media screen and (max-width: 575px) { + .app-header-contents { + height: 100%; } } + @media screen and (min-width: 576px) { + .app-header-contents { + width: 85vw; } } + @media screen and (min-width: 769px) { + .app-header-contents { + width: 80vw; } } + @media screen and (min-width: 1281px) { + .app-header-contents { + width: 65vw; } } + +.app-header h1 { + font-family: Roboto; + text-transform: uppercase; + font-weight: 400; + color: #22232c; + line-height: 29px; } + @media screen and (max-width: 575px) { + .app-header h1 { + display: none; } } + +h2.page-subtitle { + text-transform: uppercase; + color: #aeaeae; + font-size: 1em; + margin: 12px; } + +.network-component-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.left-menu-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + cursor: pointer; } + +.header__right-actions { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .header__right-actions .identicon { + cursor: pointer; } + +.app-footer { + padding-bottom: 10px; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.network-component--disabled { + cursor: default; } + .network-component--disabled .fa-caret-down { + opacity: 0; } + +.network-component.pointer { + border: 1px solid #22232c; + border-radius: 82px; + padding: 6px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .network-component.pointer.ethereum-network { + border-color: #038789; } + .network-component.pointer.ethereum-network .menu-icon-circle div { + background-color: rgba(3, 135, 137, 0.7) !important; } + .network-component.pointer.ropsten-test-network { + border-color: #e91550; } + .network-component.pointer.ropsten-test-network .menu-icon-circle div { + background-color: rgba(233, 21, 80, 0.7) !important; } + .network-component.pointer.kovan-test-network { + border-color: #690496; } + .network-component.pointer.kovan-test-network .menu-icon-circle div { + background-color: rgba(105, 4, 150, 0.7) !important; } + .network-component.pointer.rinkeby-test-network { + border-color: #ebb33f; } + .network-component.pointer.rinkeby-test-network .menu-icon-circle div { + background-color: rgba(235, 179, 63, 0.7) !important; } + +.dropdown-menu-item .menu-icon-circle, +.dropdown-menu-item .menu-icon-circle--active { + margin: 0 14px; } + +.network-indicator { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-size: .6em; } + .network-indicator .fa-caret-down { + line-height: 15px; + font-size: 12px; + padding: 0 4px; } + +.network-name { + line-height: 15px; + padding: 0 4px; + font-family: Roboto; + font-size: 12px; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; } + +.network-droppo { + right: 2px; } + @media screen and (min-width: 576px) { + .network-droppo { + right: calc(((100% - 85vw) / 2) + 2px); } } + @media screen and (min-width: 769px) { + .network-droppo { + right: calc(((100% - 80vw) / 2) + 2px); } } + @media screen and (min-width: 1281px) { + .network-droppo { + right: calc(((100% - 65vw) / 2) + 2px); } } + +.network-name-item { + font-weight: 100; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + color: #9b9b9b; } + +.network-check, +.network-check__transparent { + color: #fff; + margin-left: 7px; } + +.network-check__transparent { + opacity: 0; + width: 16px; + margin: 0; } + +.menu-icon-circle, +.menu-icon-circle--active { + background: none; + border-radius: 22px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + border: 1px solid transparent; + margin: 0 4px; } + +.menu-icon-circle--active { + border: 1px solid #fff; + background: rgba(100, 100, 100, 0.4); } + +.menu-icon-circle div, +.menu-icon-circle--active div { + height: 12px; + width: 12px; + border-radius: 17px; } + +.menu-icon-circle--active div { + opacity: 1; } + +.network-dropdown-header { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + width: 100%; } + +.network-dropdown-divider { + width: 100%; + height: 1px; + margin: 10px 0; + background-color: #5d5d5d; } + +.network-dropdown-title { + height: 25px; + width: 75px; + color: #fff; + font-family: Roboto; + font-size: 18px; + line-height: 25px; + text-align: center; } + +.network-dropdown-content { + height: 36px; + width: 265px; + color: #9b9b9b; + font-family: Roboto; + font-size: 14px; + line-height: 18px; } + +.modal > div:focus { + outline: none !important; } + +.buy-modal-content { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + text-align: center; + font-family: Roboto; + padding: 0 16px; } + +.buy-modal-content-option { + cursor: pointer; + color: #5B5D67; } + +.qr-ellip-address, .ellip-address { + width: 247px; + border: none; + font-family: Roboto; + font-size: 14px; } + +@media screen and (max-width: 575px) { + .buy-modal-content-title-wrapper { + -ms-flex-pack: distribute; + justify-content: space-around; + width: 100%; + height: 100px; } + .buy-modal-content-title { + font-size: 26px; + margin-top: 15px; } + .buy-modal-content-options { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + padding: 5% 33%; } + .buy-modal-content-footer { + text-transform: uppercase; + width: 100%; + height: 50px; } + div.buy-modal-content-option { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + width: 80vw; + height: 15vh; + margin: 10px; + text-align: center; + border-radius: 6px; + border: 1px solid #000; + padding: 0% 7%; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + div.buy-modal-content-option div.buy-modal-content-option-title { + font-size: 20px; } + div.buy-modal-content-option div.buy-modal-content-option-subtitle { + font-size: 16px; } } + +@media screen and (min-width: 576px) { + .buy-modal-content-title-wrapper { + -ms-flex-pack: distribute; + justify-content: space-around; + width: 100%; + height: 110px; } + .buy-modal-content-title { + font-size: 26px; + margin-top: 15px; } + .buy-modal-content-footer { + text-transform: uppercase; + width: 100%; + height: 50px; } + .buy-modal-content-options { + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + margin: 20px 0 60px; } + div.buy-modal-content-option { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + width: 20vw; + height: 120px; + text-align: center; + border-radius: 6px; + border: 1px solid #000; + margin: 0 8px; + padding: 18px 0; } + div.buy-modal-content-option div.buy-modal-content-option-title { + font-size: 20px; + margin-bottom: 12px; } } + @media screen and (min-width: 576px) and (max-width: 679px) { + div.buy-modal-content-option div.buy-modal-content-option-title { + font-size: 14px; } } + @media screen and (min-width: 576px) and (min-width: 1281px) { + div.buy-modal-content-option div.buy-modal-content-option-title { + font-size: 20px; } } + +@media screen and (min-width: 576px) { + div.buy-modal-content-option div.buy-modal-content-option-subtitle { + font-size: 16px; + padding: 0 10px; + height: 25%; } } + @media screen and (min-width: 576px) and (max-width: 679px) { + div.buy-modal-content-option div.buy-modal-content-option-subtitle { + font-size: 10px; + padding: 0 10px; + margin-bottom: 5px; + line-height: 15px; } } + @media screen and (min-width: 576px) and (min-width: 680px) { + div.buy-modal-content-option div.buy-modal-content-option-subtitle { + font-size: 14px; + padding: 0 4px; + margin-bottom: 2px; } } + @media screen and (min-width: 576px) and (min-width: 1281px) { + div.buy-modal-content-option div.buy-modal-content-option-subtitle { + font-size: 16px; + padding: 0; } } + +@media screen and (min-width: 576px) { + div.buy-modal-content-option div.buy-modal-content-footer { + margin-top: 8vh; } } + +.edit-account-name-modal-content { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + position: relative; } + +.edit-account-name-modal-cancel { + position: absolute; + top: 12px; + right: 20px; + font-size: 25px; } + +.edit-account-name-modal-title { + margin: 15px; } + +.edit-account-name-modal-save-button { + width: 33%; + height: 45px; + margin: 15px; + font-weight: 700; + margin-top: 25px; } + +.edit-account-name-modal-input { + width: 90%; + height: 50px; + text-align: left; + margin: 10px; + padding: 10px; + font-size: 18px; } + +.account-modal-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + position: relative; + padding: 5px 0 31px 0; + border: 1px solid #cdcdcd; + border-radius: 4px; + font-family: Roboto; } + .account-modal-container button { + cursor: pointer; } + +.account-modal-back { + color: #9b9b9b; + position: absolute; + top: 13px; + left: 17px; + cursor: pointer; } + .account-modal-back__text { + margin-top: 2px; + font-family: Roboto; + font-size: 14px; + line-height: 18px; } + +.account-modal-close::after { + content: '\00D7'; + font-size: 40px; + color: #9b9b9b; + position: absolute; + top: 10px; + right: 12px; + cursor: pointer; } + +.account-modal-container .identicon { + position: relative; + left: 0; + right: 0; + margin: 0 auto; + top: -32px; + margin-bottom: -32px; } + +.account-modal-container .qr-header { + margin-top: 9px; + font-size: 20px; } + +.account-modal-container .qr-wrapper { + margin-top: 5px; } + +.account-modal-container .ellip-address-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + border: 1px solid #dedede; + padding: 5px 10px; + font-family: Roboto; + margin-top: 7px; + width: 286px; } + +.account-modal-container .btn-clear { + min-height: 28px; + font-size: 14px; + border-color: #2f9ae0; + color: #2f9ae0; + border-radius: 2px; + -ms-flex-preferred-size: 100%; + flex-basis: 100%; + width: 75%; + margin-top: 17px; + padding: 10px 22px; + height: 44px; + width: 235px; + font-family: Roboto; } + +.account-modal-divider { + width: 100%; + height: 1px; + margin: 19px 0 8px 0; + background-color: #dedede; } + +.account-modal-container .account-name { + margin-top: 9px; + font-size: 20px; } + +.account-modal-container .modal-body-title { + margin-top: 16px; + margin-bottom: 16px; + font-size: 18px; } + +.account-modal__name { + margin-top: 9px; + font-size: 20px; } + +.private-key-password { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + +.private-key-password-label, .private-key-password-error { + color: #5d5d5d; + font-size: 14px; + line-height: 18px; + margin-bottom: 10px; } + +.private-key-password-error { + color: #e91550; + margin-bottom: 0; } + +.private-key-password-input { + padding: 10px 0 13px 17px; + font-size: 16px; + line-height: 21px; + width: 291px; + height: 44px; } + +.private-key-password::-webkit-input-placeholder { + color: #9b9b9b; + font-family: Roboto; } + +.private-key-password-warning { + border-radius: 8px; + background-color: #FFF6F6; + font-size: 12px; + font-weight: 500; + line-height: 15px; + color: #e91550; + width: 292px; + padding: 9px 15px; + margin-top: 18px; + font-family: Roboto; } + +.export-private-key-buttons { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + .export-private-key-buttons .btn-clear { + width: 141px; + height: 54px; } + .export-private-key-buttons .btn-cancel { + margin-right: 15px; + border-color: #9b9b9b; + color: #5d5d5d; } + +.private-key-password-display-wrapper { + height: 80px; + width: 291px; + border: 1px solid #cdcdcd; + border-radius: 2px; } + +.private-key-password-display-textarea { + color: #e91550; + font-family: Roboto; + font-size: 16px; + line-height: 21px; + border: none; + height: 75px; + width: 100%; + overflow: hidden; + resize: none; + padding: 9px 13px 8px; + text-transform: uppercase; + font-weight: 300; } + +.new-account-modal-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + position: relative; + border: 1px solid #dedede; + -webkit-box-shadow: 0 0 2px 2px #dedede; + box-shadow: 0 0 2px 2px #dedede; + font-family: Roboto; } + +.new-account-modal-header { + background: #f6f6f6; + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + padding: 30px; + font-size: 22px; + color: #1b344d; + height: 79px; } + +.modal-close-x::after { + content: '\00D7'; + font-size: 2em; + color: #9b9b9b; + position: absolute; + top: 25px; + right: 17.5px; + font-family: sans-serif; + cursor: pointer; } + +.new-account-modal-content { + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + margin-top: 15px; + font-size: 17px; + color: #1b344d; } + +.new-account-modal-content.after-input { + margin-top: 15px; + line-height: 25px; } + +.new-account-input-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + width: 100%; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + padding-bottom: 2px; + margin-top: 13px; } + +.new-account-input { + padding: 15px; + padding-bottom: 20px; + border-radius: 8px; + border: 1px solid #dedede; + width: 100%; + font-size: 1em; + color: #9b9b9b; + font-family: Roboto; + font-size: 17px; + margin: 0 60px; } + +.new-account-input::-webkit-input-placeholder { + color: #9b9b9b; } + +.new-account-input:-moz-placeholder { + color: #9b9b9b; + opacity: 1; } + +.new-account-input::-moz-placeholder { + color: #9b9b9b; + opacity: 1; } + +.new-account-input:-ms-input-placeholder { + color: #9b9b9b; } + +.new-account-input::-ms-input-placeholder { + color: #9b9b9b; } + +.new-account-modal-content.button { + margin-top: 22px; + margin-bottom: 30px; + width: 113px; + height: 44px; } + +.new-account-modal-wrapper .btn-clear { + font-size: 14px; + font-weight: 700; + background: #fff; + border: 1px solid; + border-radius: 2px; + color: #4d4d4d; + -webkit-box-flex: 1; + -ms-flex: 1; + flex: 1; } + +.hide-token-confirmation { + min-height: 250.72px; + width: 374.49px; + border-radius: 4px; + background-color: #FFFFFF; + -webkit-box-shadow: 0 1px 7px 0 rgba(0, 0, 0, 0.5); + box-shadow: 0 1px 7px 0 rgba(0, 0, 0, 0.5); } + .hide-token-confirmation__container { + padding: 24px 27px 21px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .hide-token-confirmation__identicon { + margin-bottom: 10px; } + .hide-token-confirmation__symbol { + color: #4d4d4d; + font-family: Roboto; + font-size: 16px; + line-height: 24px; + text-align: center; + margin-bottom: 7.5px; } + .hide-token-confirmation__title { + height: 30px; + width: 271.28px; + color: #4d4d4d; + font-family: Roboto; + font-size: 22px; + line-height: 30px; + text-align: center; + margin-bottom: 10.5px; } + .hide-token-confirmation__copy { + height: 41px; + width: 318px; + color: #5d5d5d; + font-family: Roboto; + font-size: 14px; + line-height: 18px; + text-align: center; } + .hide-token-confirmation__buttons { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + margin-top: 15px; + width: 100%; } + .hide-token-confirmation__buttons button { + height: 44px; + width: 113px; + border: 1px solid #5d5d5d; + border-radius: 2px; + color: #4d4d4d; + font-family: Roboto; + font-size: 14px; + line-height: 20px; + text-align: center; + margin-left: 4px; + margin-right: 4px; } + +/* + NewUI Container Elements + */ +.main-container { + z-index: 18; + font-family: Roboto; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -ms-flex-wrap: wrap; + flex-wrap: wrap; + -webkit-box-align: stretch; + -ms-flex-align: stretch; + align-items: stretch; } + +.main-container::-webkit-scrollbar { + display: none; } + +.tx-view { + -webkit-box-flex: 63.5; + -ms-flex: 63.5 0 66.5%; + flex: 63.5 0 66.5%; + background: #fff; } + @media screen and (max-width: 575px) { + .tx-view .identicon-wrapper { + display: none; } + .tx-view .account-name { + display: none; } } + +.wallet-view { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-flex: 33.5; + -ms-flex: 33.5 1 33.5%; + flex: 33.5 1 33.5%; + width: 0; + background: #f6f6f6; + z-index: 200; + position: relative; } + @media screen and (min-width: 576px) { + .wallet-view { + overflow-y: scroll; + overflow-x: hidden; } } + .wallet-view .wallet-view-account-details { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .wallet-view__name-container { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + cursor: pointer; + width: 100%; } + .wallet-view__keyring-label { + height: 40px; + color: #9b9b9b; + font-family: Roboto; + font-size: 10px; + line-height: 40px; + text-align: right; + padding: 0 20px; } + .wallet-view__details-button { + color: #2f9ae0; + font-size: 10px; + line-height: 13px; + text-align: center; + border: 1px solid #2f9ae0; + border-radius: 10.5px; + background-color: transparent; + margin: 0 auto; + padding: 4px 12px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .wallet-view__address { + border-radius: 3px; + background-color: #dedede; + color: #5d5d5d; + font-size: 14px; + line-height: 12px; + padding: 4px 12px; + margin: 24px auto; + font-weight: 300; + cursor: pointer; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + @media screen and (max-width: 575px) { + .wallet-view__sidebar-close::after { + content: '\00D7'; + font-size: 40px; + color: #4d4d4d; + position: absolute; + top: 12px; + left: 12px; + cursor: pointer; } } + .wallet-view__add-token-button { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + color: #9b9b9b; + font-size: 14px; + line-height: 19px; + text-align: center; + margin: 36px auto; + border: 1px solid #9b9b9b; + border-radius: 2px; + font-weight: 300; + background: none; + padding: 9px 30px; } + +@media screen and (min-width: 576px) { + .wallet-view::-webkit-scrollbar { + display: none; } } + +.wallet-view-title-wrapper { + -webkit-box-flex: 0; + -ms-flex: 0 0 25px; + flex: 0 0 25px; } + +.wallet-view-title { + margin-left: 15px; + font-size: 16px; } + @media screen and (max-width: 575px) { + .wallet-view-title { + display: none; } } + +.wallet-view.sidebar { + -webkit-box-flex: 1; + -ms-flex: 1 0 230px; + flex: 1 0 230px; + background: #fafafa; + z-index: 26; + position: fixed; + top: 56px; + left: 0; + right: 0; + bottom: 0; + opacity: 1; + visibility: visible; + will-change: transform; + overflow-y: auto; + -webkit-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 4px; + box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 4px; + width: 85%; + height: calc(100% - 56px); } + +.sidebar-overlay { + z-index: 25; + position: fixed; + height: 100%; + width: 100%; + left: 0; + right: 0; + bottom: 0; + opacity: 1; + visibility: visible; + background-color: rgba(0, 0, 0, 0.3); } + +@media screen and (min-width: 576px) { + .lap-visible { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + .phone-visible { + display: none; } + .main-container { + width: 85%; + height: 90vh; + -webkit-box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); } } + +@media screen and (min-width: 769px) { + .main-container { + width: 80%; + height: 82vh; + -webkit-box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); } } + +@media screen and (min-width: 1281px) { + .main-container { + width: 65%; + height: 82vh; + -webkit-box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 0 7px 0 rgba(0, 0, 0, 0.08); } } + +@media screen and (max-width: 575px) { + .lap-visible { + display: none; } + .phone-visible { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + .main-container { + height: 100%; + width: 100%; + overflow-y: auto; + background-color: #fff; } + button.btn-clear { + width: 93px; + height: 50px; + font-size: .7em; + background: #fff; + border: 1px solid; } } + +.account-name { + font-size: 24px; + font-weight: 200; + line-height: 20px; + color: #5d5d5d; + margin-top: 8px; + margin-bottom: 24px; + white-space: nowrap; + text-overflow: ellipsis; + overflow: hidden; + width: 100%; + padding: 0 8px; + text-align: center; } + +.account-options-menu { + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + margin: 5% 7% 0%; } + +.fiat-amount { + text-transform: uppercase; } + +.token-balance__amount { + padding-right: 6px; } + +.account-dropdown-name { + font-family: Roboto; } + +.account-dropdown-balance { + color: #9b9b9b; + line-height: 19px; } + +.account-dropdown-edit-button { + color: #9b9b9b; + font-family: Roboto; } + .account-dropdown-edit-button:hover { + color: #fff; } + +.account-list-item__top-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + margin-top: 10px; + margin-left: 8px; + position: relative; } + +.account-list-item__account-balances { + height: auto; + border: none; + background-color: transparent; + color: #9b9b9b; + margin-left: 34px; + margin-top: 4px; + position: relative; } + +.account-list-item__account-name { + font-size: 16px; + margin-left: 8px; } + +.account-list-item__icon { + position: absolute; + right: 12px; + top: 1px; } + +.account-list-item__account-primary-balance, .account-list-item__account-secondary-balance { + font-family: Roboto; + line-height: 16px; + font-size: 12px; + font-weight: 300; } + +.account-list-item__account-primary-balance { + color: #5d5d5d; + border: none; + outline: 0 !important; } + +.account-list-item__account-secondary-balance { + color: #9b9b9b; } + +.account-list-item__account-address { + margin-left: 35px; + width: 80%; + overflow: hidden; + text-overflow: ellipsis; } + +.account-list-item__dropdown:hover { + background: rgba(222, 222, 222, 0.2); + cursor: pointer; } + .account-list-item__dropdown:hover input { + background: rgba(222, 222, 222, 0.1); } + +.send-screen-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + z-index: 25; + font-family: Roboto; } + @media screen and (max-width: 575px) { + .send-screen-wrapper { + width: 100%; + overflow-y: auto; } } + .send-screen-wrapper section { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.send-screen-card { + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + padding: 46px 40.5px 26px; + position: relative; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + width: 498px; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; } + @media screen and (max-width: 575px) { + .send-screen-card { + top: 0; + width: 100%; + -webkit-box-shadow: none; + box-shadow: none; + padding: 12px; } } + +/* Send Screen */ +.send-screen section { + margin: 4px 16px; } + +.send-screen input { + width: 100%; + font-size: 12px; } + +.send-eth-icon { + border-radius: 50%; + width: 70px; + height: 70px; + border: 1px solid #dedede; + -webkit-box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.2); + box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.2); + position: absolute; + top: -35px; + z-index: 25; + padding: 4px; + background-color: #fff; } + @media screen and (max-width: 575px) { + .send-eth-icon { + position: relative; + top: 0; } } + +.send-screen-input-wrapper { + width: 95%; + position: relative; } + .send-screen-input-wrapper .fa-bolt { + padding-right: 4px; } + .send-screen-input-wrapper .large-input { + border: 1px solid #9b9b9b; + border-radius: 4px; + margin: 4px 0 20px; + font-size: 16px; + line-height: 22.4px; + font-family: Roboto; } + .send-screen-input-wrapper .send-screen-gas-input { + border: 1px solid transparent; } + .send-screen-input-wrapper__error-message { + display: none; } + .send-screen-input-wrapper--error input, + .send-screen-input-wrapper--error .send-screen-gas-input { + border-color: #f00 !important; } + .send-screen-input-wrapper--error .send-screen-input-wrapper__error-message { + display: block; + position: absolute; + bottom: 4px; + font-size: 12px; + line-height: 12px; + left: 8px; + color: #f00; } + .send-screen-input-wrapper .send-screen-input-wrapper__error-message { + display: block; + position: absolute; + bottom: 4px; + font-size: 12px; + line-height: 12px; + left: 8px; + color: #f00; } + +.send-screen-input { + width: 100%; } + +.send-screen-gas-input { + width: 100%; + height: 41px; + border-radius: 3px; + background-color: #f3f3f3; + border-width: 0; + border-style: none; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + padding-left: 10px; + padding-right: 12px; + font-size: 16px; + color: #5d5d5d; } + +.send-screen-amount-labels { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; } + +.send-screen-gas-labels { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; } + +.currency-toggle__item { + color: #2f9ae0; + cursor: pointer; } + .currency-toggle__item--selected { + color: #000; + cursor: default; } + +.send-screen-gas-input-customize { + color: #2f9ae0; + font-size: 12px; + cursor: pointer; } + +.gas-tooltip-close-area { + position: fixed; + top: 0; + left: 0; + z-index: 1000; + width: 100%; + height: 100%; } + +.customize-gas-tooltip-container { + position: absolute; + bottom: 50px; + width: 237px; + height: 307px; + background-color: #fff; + opacity: 1; + -webkit-box-shadow: #dedede 0 0 5px; + box-shadow: #dedede 0 0 5px; + z-index: 1050; + padding: 13px 19px; + font-size: 16px; + border-radius: 4px; + font-family: "Lato"; + font-weight: 500; } + +.gas-tooltip-arrow { + height: 25px; + width: 25px; + z-index: 1200; + background: #fff; + position: absolute; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + left: 107px; + top: 294px; + -webkit-box-shadow: 2px 2px 2px #dedede; + box-shadow: 2px 2px 2px #dedede; } + +.customize-gas-tooltip-container input[type="number"]::-webkit-inner-spin-button { + -webkit-appearance: none; + display: none; } + +.customize-gas-tooltip-container input[type="number"]:hover::-webkit-inner-spin-button { + -webkit-appearance: none; + display: none; } + +.customize-gas-tooltip { + position: relative; } + +.gas-tooltip { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + +.gas-tooltip-label { + font-size: 16px; + color: #4d4d4d; } + +.gas-tooltip-header { + padding-bottom: 12px; } + +.gas-tooltip-input-label { + margin-bottom: 5px; } + +.gas-tooltip-input-label i { + color: #aeaeae; + margin-left: 6px; } + +.customize-gas-input { + width: 178px; + height: 28px; + border: 1px solid #dedede; + font-size: 16px; + color: #1b344d; + padding-left: 8px; } + +.customize-gas-input-wrapper { + position: relative; } + +.gas-tooltip-input-detail { + position: absolute; + top: 4px; + right: 26px; + font-size: 12px; + color: #aeaeae; } + +.gas-tooltip-input-arrows { + position: absolute; + top: 0; + right: 4px; + width: 17px; + height: 28px; + border: 1px solid #dadada; + border-left: 0; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + color: #9b9b9b; + font-size: .8em; + padding: 1px 4px; + cursor: pointer; } + +.token-gas__amount { + display: inline-block; + margin-right: 4px; } + +.token-gas__symbol { + display: inline-block; } + +.send-screen__title { + color: #5d5d5d; + font-size: 18px; + line-height: 29px; } + +.send-screen__subtitle { + margin: 10px 0 20px; + font-size: 14px; + line-height: 24px; } + +.send-screen__send-button, .send-screen__cancel-button { + width: 163px; + text-align: center; } + +.send-screen__send-button__disabled { + opacity: .5; + cursor: auto; } + +.send-token { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + z-index: 25; + font-family: Roboto; } + .send-token__content { + width: 498px; + height: 605px; + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + padding: 46px 40.5px 26px; + position: relative; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; } + @media screen and (max-width: 575px) { + .send-token__content { + top: 0; + width: 100%; + -webkit-box-shadow: none; + box-shadow: none; + padding: 12px; } } + .send-token .identicon { + position: absolute; + top: -35px; + z-index: 25; } + @media screen and (max-width: 575px) { + .send-token .identicon { + position: relative; + top: 0; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } } + .send-token__title { + color: #5d5d5d; + font-size: 18px; + line-height: 29px; } + .send-token__description, .send-token__balance-text, .send-token__token-symbol { + margin-top: 10px; + font-size: 14px; + line-height: 24px; + text-align: center; } + .send-token__token-balance { + font-size: 40px; + line-height: 40px; + margin-top: 13px; } + .send-token__token-balance .token-balance__amount { + padding-right: 12px; } + .send-token__button-group { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + @media screen and (max-width: 575px) { + .send-token__button-group { + margin-top: 24px; } } + .send-token__button-group button { + width: 163px; } + +.confirm-send-token__hero-amount-wrapper { + width: 100%; } + +.send-v2__container { + width: 380px; + border-radius: 8px; + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + z-index: 25; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-family: Roboto; + position: relative; } + @media screen and (max-width: 575px) { + .send-v2__container { + width: 100%; + top: 0; + -webkit-box-shadow: none; + box-shadow: none; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } } + +.send-v2__send-header-icon-container { + z-index: 25; } + @media screen and (max-width: 575px) { + .send-v2__send-header-icon-container { + position: relative; + top: 0; } } + +.send-v2__send-header-icon { + border-radius: 50%; + width: 48px; + height: 48px; + border: 1px solid #dedede; + z-index: 25; + padding: 4px; + background-color: #fff; } + +.send-v2__send-arrow-icon { + color: #f28930; + -webkit-transform: rotate(-45deg); + transform: rotate(-45deg); + position: absolute; + top: -2px; + left: 0; + font-size: 1.12em; } + +.send-v2__arrow-background { + background-color: #fff; + height: 14px; + width: 14px; + position: absolute; + top: 52px; + left: 199px; + border-radius: 50%; + z-index: 100; } + @media screen and (max-width: 575px) { + .send-v2__arrow-background { + top: 36px; } } + +.send-v2__header { + height: 88px; + width: 380px; + background-color: #e9edf0; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + @media screen and (max-width: 575px) { + .send-v2__header { + height: 59px; + width: 100vw; } } + +.send-v2__header-tip { + height: 25px; + width: 25px; + background: #e9edf0; + position: absolute; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + left: 178px; + top: 75px; } + @media screen and (max-width: 575px) { + .send-v2__header-tip { + top: 46px; + left: 0; + right: 0; + margin: 0 auto; } } + +.send-v2__title { + color: #5d5d5d; + font-size: 22px; + line-height: 29px; + text-align: center; + margin-top: 25px; } + +.send-v2__copy { + color: #808080; + font-size: 14px; + font-weight: 300; + line-height: 19px; + text-align: center; + margin-top: 10px; + width: 287px; } + +.send-v2__error { + font-size: 12px; + line-height: 12px; + left: 8px; + color: #f00; } + +.send-v2__error-border { + color: #f00; } + +.send-v2__form { + margin: 13px 0; + width: 100%; } + @media screen and (max-width: 575px) { + .send-v2__form { + padding: 13px 0; + margin: 0; + height: 0; + overflow-y: auto; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } } + +.send-v2__form-header, .send-v2__form-header-copy { + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.send-v2__form-row { + margin: 14.5px 18px 0px; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row; + flex-flow: row; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; } + +.send-v2__form-field { + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } + +.send-v2__form-label { + color: #5d5d5d; + font-family: Roboto; + font-size: 16px; + line-height: 22px; + width: 88px; } + +.send-v2__from-dropdown { + height: 73px; + width: 100%; + border: 1px solid #dedede; + border-radius: 4px; + background-color: #fff; + font-family: Roboto; + line-height: 16px; + font-size: 12px; + color: #4d4d4d; + position: relative; } + .send-v2__from-dropdown__close-area { + position: fixed; + top: 0; + left: 0; + z-index: 1000; + width: 100%; + height: 100%; } + .send-v2__from-dropdown__list { + z-index: 1050; + position: absolute; + height: 220px; + width: 100%; + border: 1px solid #d2d8dd; + border-radius: 4px; + background-color: #fff; + -webkit-box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + margin-top: 11px; + margin-left: -1px; + overflow-y: scroll; } + +.send-v2__to-autocomplete { + position: relative; } + .send-v2__to-autocomplete__down-caret { + position: absolute; + top: 18px; + right: 12px; } + +.send-v2__to-autocomplete__input, .send-v2__memo-text-area__input { + height: 54px; + width: 100%; + border: 1px solid #dedede; + border-radius: 4px; + background-color: #fff; + color: #9b9b9b; + padding: 10px; + font-family: Roboto; + font-size: 16px; + line-height: 21px; + font-weight: 300; } + +.send-v2__amount-max { + color: #2f9ae0; + font-family: Roboto; + font-size: 12px; + left: 8px; + border: none; + cursor: pointer; } + +.send-v2__gas-fee-display { + width: 100%; } + +.send-v2__sliders-icon-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + height: 24px; + width: 24px; + border: 1px solid #2f9ae0; + border-radius: 4px; + background-color: #fff; + padding: 5px; + position: absolute; + right: 15px; + top: 14px; + cursor: pointer; } + +.send-v2__sliders-icon { + color: #2f9ae0; } + +.send-v2__memo-text-area__input { + padding: 6px 10px; } + +.send-v2__footer { + height: 92px; + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: space-evenly; + -ms-flex-pack: space-evenly; + justify-content: space-evenly; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + border-top: 1px solid #dedede; + background: #fff; + padding: 0 12px; } + +.send-v2__next-btn, .send-v2__cancel-btn, .send-v2__next-btn__disabled { + width: 163px; + text-align: center; + height: 55px; + border-radius: 2px; + background-color: #fff; + font-family: Roboto; + font-size: 16px; + font-weight: 300; + line-height: 21px; + border: 1px solid; + margin: 0 4px; } + +.send-v2__next-btn, .send-v2__next-btn__disabled { + color: #2f9ae0; + border-color: #2f9ae0; } + +.send-v2__next-btn__disabled { + opacity: .5; + cursor: auto; } + +.send-v2__cancel-btn { + color: #9b9b9b; + border-color: #9b9b9b; } + +.send-v2__customize-gas { + border: 1px solid #D8D8D8; + border-radius: 4px; + background-color: #FFFFFF; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.14); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.14); + font-family: Roboto; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; } + @media screen and (max-width: 575px) { + .send-v2__customize-gas { + width: 100vw; + height: 100vh; } } + .send-v2__customize-gas__header { + height: 52px; + border-bottom: 1px solid #dedede; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + font-size: 22px; } + @media screen and (max-width: 575px) { + .send-v2__customize-gas__header { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } } + .send-v2__customize-gas__title { + margin-left: 19.25px; } + .send-v2__customize-gas__close::after { + content: '\00D7'; + font-size: 1.8em; + color: #9b9b9b; + font-family: sans-serif; + cursor: pointer; + margin-right: 19.25px; } + .send-v2__customize-gas__content { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + height: 100%; } + .send-v2__customize-gas__body { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + margin-bottom: 24px; } + @media screen and (max-width: 575px) { + .send-v2__customize-gas__body { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } } + .send-v2__customize-gas__footer { + height: 75px; + border-top: 1px solid #dedede; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + font-size: 22px; + position: relative; } + @media screen and (max-width: 575px) { + .send-v2__customize-gas__footer { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } } + .send-v2__customize-gas__buttons { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + width: 181.75px; + margin-right: 21.25px; } + .send-v2__customize-gas__revert, .send-v2__customize-gas__cancel, .send-v2__customize-gas__save, .send-v2__customize-gas__save__error { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + cursor: pointer; } + .send-v2__customize-gas__revert { + color: #aeaeae; + font-size: 16px; + margin-left: 21.25px; } + .send-v2__customize-gas__cancel, .send-v2__customize-gas__save, .send-v2__customize-gas__save__error { + height: 34.64px; + width: 85.74px; + border: 1px solid #9b9b9b; + border-radius: 2px; + font-family: 'DIN OT'; + font-size: 12px; + color: #9b9b9b; } + .send-v2__customize-gas__save__error { + opacity: 0.5; + cursor: auto; } + .send-v2__customize-gas__error-message { + display: block; + position: absolute; + top: 4px; + right: 4px; + font-size: 12px; + line-height: 12px; + color: #f00; } + +.send-v2__gas-modal-card { + width: 360px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; + -webkit-box-align: start; + -ms-flex-align: start; + align-items: flex-start; + padding-left: 20px; } + .send-v2__gas-modal-card__title { + height: 26px; + color: #4d4d4d; + font-family: Roboto; + font-size: 20px; + font-weight: 300; + line-height: 26px; + margin-top: 17px; } + .send-v2__gas-modal-card__copy { + height: 38px; + width: 314px; + color: #4d4d4d; + font-family: Roboto; + font-size: 14px; + line-height: 19px; + margin-top: 17px; } + .send-v2__gas-modal-card .customize-gas-input-wrapper { + margin-top: 17px; } + .send-v2__gas-modal-card .customize-gas-input { + height: 54px; + width: 315px; + border: 1px solid #d2d8dd; + background-color: #fff; + padding-left: 15px; } + .send-v2__gas-modal-card .gas-tooltip-input-arrows { + width: 32px; + height: 54px; + border-left: 1px solid #dadada; + font-size: 18px; + color: #4d4d4d; + right: 0px; + padding: 1px 4px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -ms-flex-pack: distribute; + justify-content: space-around; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .send-v2__gas-modal-card input[type="number"]::-webkit-inner-spin-button { + -webkit-appearance: none; + display: none; } + .send-v2__gas-modal-card input[type="number"]:hover::-webkit-inner-spin-button { + -webkit-appearance: none; + display: none; } + +.confirm-screen-container { + position: relative; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-family: Roboto; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + border-radius: 8px; } + @media screen and (max-width: 575px) { + .confirm-screen-container { + width: 100%; } } + +@media screen and (max-width: 575px) { + .notification .confirm-screen-wrapper { + height: calc(100vh - 85px); } } + +.confirm-screen-wrapper { + height: 100%; + width: 380px; + background-color: #fff; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + z-index: 25; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-family: Roboto; + position: relative; + overflow-y: auto; + overflow-x: hidden; + border-top-left-radius: 8px; + border-top-right-radius: 8px; } + @media screen and (max-width: 575px) { + .confirm-screen-wrapper { + width: 100%; + overflow-x: hidden; + overflow-y: auto; + top: 0; + -webkit-box-shadow: none; + box-shadow: none; + height: calc(100vh - 58px - 85px); + border-top-left-radius: 0; + border-top-right-radius: 0; } } + +.confirm-screen-wrapper > .confirm-screen-total-box { + margin-left: 10px; + margin-right: 10px; } + +.confirm-screen-wrapper > .confirm-memo-wrapper { + margin: 0; } + +.confirm-screen-header { + height: 88px; + background-color: #e9edf0; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-size: 22px; + line-height: 29px; + width: 100%; + padding: 25px 0; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + @media screen and (max-width: 575px) { + .confirm-screen-header { + font-size: 20px; } } + +.confirm-screen-header-tip { + height: 25px; + width: 25px; + background: #e9edf0; + position: absolute; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + top: 71px; + left: 0; + right: 0; + margin: 0 auto; } + +.confirm-screen-title { + line-height: 27px; } + @media screen and (max-width: 575px) { + .confirm-screen-title { + margin-left: 22px; + margin-right: 8px; } } + +.confirm-screen-back-button { + background: transparent; + border: 1px solid #2f9ae0; + left: 24px; + position: absolute; + text-align: center; + color: #2f9ae0; + padding: 6px 13px 7px 12px; + border-radius: 2px; + height: 30px; + width: 54px; } + @media screen and (max-width: 575px) { + .confirm-screen-back-button { + margin-right: 12px; } } + +.confirm-screen-account-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.confirm-screen-account-name { + margin-top: 12px; + font-size: 14px; + line-height: 19px; + color: #5d5d5d; + text-align: center; } + +.confirm-screen-row-info { + font-size: 16px; + line-height: 21px; } + +.confirm-screen-account-number { + font-size: 10px; + line-height: 16px; + color: #9b9b9b; + text-align: center; + height: 16px; } + +.confirm-send-ether i.fa-arrow-right, +.confirm-send-token i.fa-arrow-right { + -ms-flex-item-align: start; + align-self: start; + margin: 24px 14px 0 !important; } + +.confirm-screen-identicons { + margin-top: 24px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .confirm-screen-identicons i.fa-arrow-right { + -ms-flex-item-align: start; + align-self: start; + margin: 42px 14px 0; } + .confirm-screen-identicons i.fa-file-text-o { + font-size: 60px; + margin: 16px 8px 0 8px; + text-align: center; } + +.confirm-screen-sending-to-message { + text-align: center; + font-size: 16px; + margin-top: 30px; + font-family: 'DIN NEXT Light'; } + +.confirm-screen-send-amount { + color: #5d5d5d; + margin-top: 12px; + text-align: center; + font-size: 40px; + font-weight: 300; + line-height: 53px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.confirm-screen-send-amount-currency { + font-size: 20px; + line-height: 20px; + text-align: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.confirm-memo-wrapper { + min-height: 24px; + width: 100%; + border-bottom: 1px solid #dedede; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.confirm-screen-send-memo { + color: #5d5d5d; + font-size: 16px; + line-height: 19px; + font-weight: 400; } + +.confirm-screen-label { + font-size: 18px; + line-height: 40px; + color: #5d5d5d; + text-align: left; } + +section .confirm-screen-account-name, +section .confirm-screen-account-number, +.confirm-screen-row-info, +.confirm-screen-row-detail { + text-align: left; } + +.confirm-screen-rows { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + width: 100%; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.confirm-screen-section-column { + -webkit-box-flex: .5; + -ms-flex: .5; + flex: .5; } + +.confirm-screen-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + border-bottom: 1px solid #dedede; + width: 100%; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + padding: 12px; + padding-left: 35px; + font-size: 16px; + line-height: 22px; + font-weight: 300; } + +.confirm-screen-row-detail { + font-size: 12px; + line-height: 16px; + color: #9b9b9b; } + +.confirm-screen-total-box { + background-color: #f6f6f6; + padding: 20px; + padding-left: 35px; + border-bottom: 1px solid #dedede; } + .confirm-screen-total-box .confirm-screen-label { + line-height: 18px; } + .confirm-screen-total-box .confirm-screen-row-detail { + color: #5d5d5d; } + .confirm-screen-total-box__subtitle { + font-size: 12px; + line-height: 22px; } + .confirm-screen-total-box .confirm-screen-row-info { + font-size: 16px; + font-weight: 500; + line-height: 21px; } + +.confirm-screen-confirm-button { + height: 62px; + border-radius: 2px; + background-color: #02c9b1; + font-size: 16px; + color: #fff; + text-align: center; + font-family: Roboto; + padding-top: 15px; + padding-bottom: 15px; + border-width: 0; + -webkit-box-shadow: none; + box-shadow: none; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + font-weight: 300; + margin: 0 8px; } + +.btn-light.confirm-screen-cancel-button { + height: 62px; + background: none; + border: none; + opacity: 1; + font-family: Roboto; + border-width: 0; + padding-top: 15px; + padding-bottom: 15px; + font-size: 16px; + line-height: 32px; + -webkit-box-shadow: none; + box-shadow: none; + cursor: pointer; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + font-weight: 300; + margin: 0 8px; } + +#pending-tx-form { + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + background-color: #fff; + padding: 12px 18px; + border-bottom-left-radius: 8px; + border-bottom-right-radius: 8px; + width: 100%; } + @media screen and (max-width: 575px) { + #pending-tx-form { + border-top: 1px solid #dedede; + border-bottom-left-radius: 0; + border-bottom-right-radius: 0; } } + +.loading-overlay { + left: 0px; + z-index: 50; + position: absolute; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + width: 100%; + background: rgba(255, 255, 255, 0.8); } + @media screen and (max-width: 575px) { + .loading-overlay { + margin-top: 56px; + height: calc(100% - 56px); } } + @media screen and (min-width: 576px) { + .loading-overlay { + margin-top: 75px; + height: calc(100% - 75px); } } + +@media screen and (max-width: 575px) { + .hero-balance { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + margin: .3em .9em 0; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } } + +@media screen and (min-width: 576px) { + .hero-balance { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + margin: 2.8em 2.37em .8em; } } + +.hero-balance .balance-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + margin: 0; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + @media screen and (max-width: 575px) { + .hero-balance .balance-container { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } } + @media screen and (min-width: 576px) { + .hero-balance .balance-container { + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-flex: 3; + -ms-flex-positive: 3; + flex-grow: 3; } } + +@media screen and (max-width: 575px) { + .hero-balance .balance-display { + text-align: center; } + .hero-balance .balance-display .token-amount { + font-size: 175%; + margin-top: 12.5%; } + .hero-balance .balance-display .fiat-amount { + font-size: 115%; + margin-top: 8.5%; + color: #a0a0a0; } } + +@media screen and (min-width: 576px) { + .hero-balance .balance-display { + margin-left: 3%; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: start; + -ms-flex-align: start; + align-items: flex-start; } + .hero-balance .balance-display .token-amount { + font-size: 135%; } + .hero-balance .balance-display .fiat-amount { + margin-top: .25%; + font-size: 105%; } } + +.hero-balance .balance-icon { + border-radius: 25px; + width: 45px; + height: 45px; + border: 1px solid #dedede; } + +@media screen and (max-width: 575px) { + .hero-balance .hero-balance-buttons { + width: 100%; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + padding: 16px 0; } } + +@media screen and (min-width: 576px) { + .hero-balance .hero-balance-buttons { + -webkit-box-flex: 2; + -ms-flex-positive: 2; + flex-grow: 2; + -webkit-box-pack: end; + -ms-flex-pack: end; + justify-content: flex-end; } } + +.hero-balance .hero-balance-buttons button.btn-clear { + background: #fff; + border: 1px solid; + border-radius: 2px; + font-size: 12px; } + @media screen and (max-width: 575px) { + .hero-balance .hero-balance-buttons button.btn-clear { + border-color: #2f9ae0; + color: #2f9ae0; + height: 36px; } } + @media screen and (min-width: 576px) { + .hero-balance .hero-balance-buttons button.btn-clear { + border-color: #2f9ae0; + color: #2f9ae0; + padding: 0; + width: 85px; + height: 34px; } } + +.wallet-balance-wrapper { + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + -webkit-transition: linear 200ms; + transition: linear 200ms; + background: rgba(231, 231, 231, 0); } + .wallet-balance-wrapper--active { + background: #e7e7e7; } + +.wallet-balance { + background: inherit; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + cursor: pointer; + border-top: 1px solid #e7e7e7; } + .wallet-balance .balance-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + margin: 20px 24px; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-flex: 3; + -ms-flex-positive: 3; + flex-grow: 3; } + @media screen and (min-width: 576px) and (max-width: 890px) { + .wallet-balance .balance-container { + margin: 10% 4%; } } + .wallet-balance .balance-display { + margin-left: 15px; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: start; + -ms-flex-align: start; + align-items: flex-start; } + .wallet-balance .balance-display .token-amount { + font-size: 135%; } + .wallet-balance .balance-display .fiat-amount { + margin-top: .25%; + font-size: 105%; } + @media screen and (min-width: 576px) and (max-width: 890px) { + .wallet-balance .balance-display { + margin-left: 4%; } + .wallet-balance .balance-display .token-amount { + font-size: 105%; } + .wallet-balance .balance-display .fiat-amount { + font-size: 95%; } } + .wallet-balance .balance-icon { + border-radius: 25px; + width: 45px; + height: 45px; + border: 1px solid #dedede; } + +.tx-list-container { + height: 87.5%; } + @media screen and (min-width: 576px) { + .tx-list-container { + overflow-y: scroll; } } + +.tx-list-header { + text-transform: capitalize; } + +@media screen and (max-width: 575px) { + .tx-list-header-wrapper { + margin-top: .2em; + margin-bottom: .6em; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .tx-list-header { + -ms-flex-item-align: center; + align-self: center; + font-size: 12px; + color: #9b9b9b; + font-family: Roboto; + text-transform: uppercase; } } + +@media screen and (min-width: 576px) { + .tx-list-header-wrapper { + -webkit-box-flex: 0; + -ms-flex: 0 0 55px; + flex: 0 0 55px; } + .tx-list-header { + font-size: 16px; + margin: 1.5em 2.37em; } + .tx-list-container::-webkit-scrollbar { + display: none; } } + +.tx-list-content-divider { + height: 1px; + background: #e7e7e7; + -webkit-box-flex: 0; + -ms-flex: 0 0 1px; + flex: 0 0 1px; } + @media screen and (max-width: 575px) { + .tx-list-content-divider { + margin: .1em 0; } } + @media screen and (min-width: 576px) { + .tx-list-content-divider { + margin: .1em 2.37em; } } + +.tx-list-item-wrapper { + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; + width: 0; + -webkit-box-align: stretch; + -ms-flex-align: stretch; + align-items: stretch; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; } + @media screen and (max-width: 575px) { + .tx-list-item-wrapper { + padding: 0 1.3em .8em; } } + @media screen and (min-width: 576px) { + .tx-list-item-wrapper { + padding-bottom: 12px; } } + +.tx-list-clickable { + cursor: pointer; } + .tx-list-clickable:hover { + background: rgba(222, 222, 222, 0.2); } + +.tx-list-pending-item-container { + cursor: pointer; + opacity: .5; } + +.tx-list-date-wrapper { + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } + @media screen and (max-width: 575px) { + .tx-list-date-wrapper { + margin-top: 6px; } } + @media screen and (min-width: 576px) { + .tx-list-date-wrapper { + margin-top: 12px; } } + +.tx-list-content-wrapper { + -webkit-box-align: stretch; + -ms-flex-align: stretch; + align-items: stretch; + margin-bottom: 4px; + margin-top: 2px; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; } + @media screen and (max-width: 575px) { + .tx-list-content-wrapper { + font-size: 12px; } + .tx-list-content-wrapper .tx-list-status { + font-size: 14px !important; } + .tx-list-content-wrapper .tx-list-account { + font-size: 14px !important; } + .tx-list-content-wrapper .tx-list-value { + font-size: 14px; + line-height: 18px; } + .tx-list-content-wrapper .tx-list-fiat-value { + font-size: 12px; + line-height: 16px; } } + +.tx-list-date { + color: #9b9b9b; + font-size: 12px; + font-family: Roboto; } + +.tx-list-identicon-wrapper { + -ms-flex-item-align: center; + align-self: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + margin-right: 16px; } + +.tx-list-account-and-status-wrapper { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row wrap; + flex-flow: row wrap; + width: 0; } + @media screen and (max-width: 575px) { + .tx-list-account-and-status-wrapper { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: start; + -ms-flex-align: start; + align-items: flex-start; + -ms-flex-item-align: center; + align-self: center; } + .tx-list-account-and-status-wrapper .tx-list-account-wrapper { + height: 18px; } + .tx-list-account-and-status-wrapper .tx-list-account-wrapper .tx-list-account { + line-height: 14px; } } + @media screen and (min-width: 576px) { + .tx-list-account-and-status-wrapper { + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .tx-list-account-and-status-wrapper .tx-list-account-wrapper { + -webkit-box-flex: 1.3; + -ms-flex: 1.3 2 auto; + flex: 1.3 2 auto; + min-width: 153px; } + .tx-list-account-and-status-wrapper .tx-list-status-wrapper { + -webkit-box-flex: 6; + -ms-flex: 6 6 auto; + flex: 6 6 auto; } } + .tx-list-account-and-status-wrapper .tx-list-account { + font-size: 16px; + color: #5d5d5d; } + .tx-list-account-and-status-wrapper .tx-list-status { + color: #9b9b9b; + font-size: 16px; + text-transform: capitalize; } + .tx-list-account-and-status-wrapper .tx-list-status--rejected, + .tx-list-account-and-status-wrapper .tx-list-status--failed { + color: #d0021b; } + +.tx-list-item { + border-top: 1px solid #e7e7e7; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; } + @media screen and (min-width: 576px) { + .tx-list-item { + margin: 0 2.37em; } } + .tx-list-item:last-of-type { + border-bottom: 1px solid #e7e7e7; + margin-bottom: 32px; } + .tx-list-item__wrapper { + -ms-flex-item-align: center; + align-self: center; + -webkit-box-flex: 2; + -ms-flex: 2 2 auto; + flex: 2 2 auto; + color: #9b9b9b; } + .tx-list-item__wrapper .tx-list-value { + font-size: 16px; + text-align: right; } + .tx-list-item__wrapper .tx-list-value--confirmed { + color: #02c9b1; } + .tx-list-item__wrapper .tx-list-fiat-value { + font-size: 12px; + text-align: right; } + .tx-list-item--empty { + text-align: center; + border-bottom: none !important; + padding: 16px; } + +.tx-list-details-wrapper { + overflow: hidden; + -webkit-box-flex: 0; + -ms-flex: 0 0 35%; + flex: 0 0 35%; } + +.tx-list-value { + font-size: 16px; + text-align: right; + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; } + +.tx-list-fiat-value { + text-align: right; + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; } + +.tx-list-value--confirmed { + color: #02c9b1; } + +/* stylelint-disable */ +/* +App Sections + TODO: Move into separate files. +*/ +/* initialize */ +textarea.twelve-word-phrase { + padding: 12px; + width: 300px; + height: 140px; + font-size: 16px; + background: #fff; + resize: none; } + +.initialize-screen hr { + width: 60px; + margin: 12px; + border-color: #f7861c; + border-style: solid; } + +.initialize-screen label { + margin-top: 20px; } + +.initialize-screen button.create-vault { + margin-top: 40px; } + +.initialize-screen .warning { + font-size: 14px; + margin: 0 16px; } + +/* unlock */ +.error { + color: #f7861c; + margin-bottom: 9px; } + +.warning { + color: #ffae00; } + +.lock { + width: 50px; + height: 50px; } + +.lock.locked { + -webkit-transform: scale(1.5); + transform: scale(1.5); + opacity: 0; + -webkit-transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in, -webkit-transform 400ms ease-in; } + +.lock.unlocked { + -webkit-transform: scale(1); + transform: scale(1); + opacity: 1; + -webkit-transition: opacity 500ms ease-out, background 200ms ease-in, -webkit-transform 500ms ease-out; + transition: opacity 500ms ease-out, background 200ms ease-in, -webkit-transform 500ms ease-out; + transition: opacity 500ms ease-out, transform 500ms ease-out, background 200ms ease-in; + transition: opacity 500ms ease-out, transform 500ms ease-out, background 200ms ease-in, -webkit-transform 500ms ease-out; } + +.lock.locked .lock-top { + -webkit-transform: scaleX(1) translateX(0); + transform: scaleX(1) translateX(0); + -webkit-transition: -webkit-transform 250ms ease-in; + transition: -webkit-transform 250ms ease-in; + transition: transform 250ms ease-in; + transition: transform 250ms ease-in, -webkit-transform 250ms ease-in; } + +.lock.unlocked .lock-top { + -webkit-transform: scaleX(-1) translateX(-12px); + transform: scaleX(-1) translateX(-12px); + -webkit-transition: -webkit-transform 250ms ease-in; + transition: -webkit-transform 250ms ease-in; + transition: transform 250ms ease-in; + transition: transform 250ms ease-in, -webkit-transform 250ms ease-in; } + +.lock.unlocked:hover { + border-radius: 4px; + background: #e5e5e5; + border: 1px solid #b1b1b1; } + +.lock.unlocked:active { + background: #c3c3c3; } + +.section-title .fa-arrow-left { + margin: -2px 8px 0px -8px; } + +.unlock-screen #metamask-mascot-container { + margin-top: 24px; } + +.unlock-screen h1 { + margin-top: -28px; + margin-bottom: 42px; } + +.unlock-screen input[type=password] { + width: 260px; } + +.sizing-input { + font-size: 14px; + height: 30px; + padding-left: 5px; } + +.editable-label { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + +/* Webkit */ +.unlock-screen input::-webkit-input-placeholder { + text-align: center; + font-size: 1.2em; } + +/* Firefox 18- */ +.unlock-screen input:-moz-placeholder { + text-align: center; + font-size: 1.2em; } + +/* Firefox 19+ */ +.unlock-screen input::-moz-placeholder { + text-align: center; + font-size: 1.2em; } + +/* IE */ +.unlock-screen input:-ms-input-placeholder { + text-align: center; + font-size: 1.2em; } + +/* accounts */ +.accounts-section { + margin: 0 0px; } + +.accounts-section .horizontal-line { + margin: 0 18px; } + +.accounts-list-option { + height: 120px; } + +.accounts-list-option .identicon-wrapper { + width: 100px; } + +.unconftx-link { + margin-top: 24px; + cursor: pointer; } + +.unconftx-link .fa-arrow-right { + margin: 0 -8px 0px 8px; } + +/* identity panel */ +.identity-panel { + font-weight: 500; } + +.identity-panel .identicon-wrapper { + margin: 4px; + margin-top: 8px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.identity-panel .identicon-wrapper span { + margin: 0 auto; } + +.identity-panel .identity-data { + margin: 8px 8px 8px 18px; } + +.identity-panel i { + margin-top: 32px; + margin-right: 6px; + color: #b9b9b9; } + +.identity-panel .arrow-right { + padding-left: 18px; + width: 42px; + min-width: 18px; + height: 100%; } + +.identity-copy.flex-column { + -webkit-box-flex: .25; + -ms-flex: .25 0 auto; + flex: .25 0 auto; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + +/* accounts screen */ +.identity-section .identity-panel { + background: #e9e9e9; + border-bottom: 1px solid #b1b1b1; + cursor: pointer; } + +.identity-section .identity-panel.selected { + background: #fff; + color: #f3c83e; } + +.identity-section .identity-panel.selected .identicon { + border-color: #ffa500; } + +.identity-section .accounts-list-option:hover, +.identity-section .accounts-list-option.selected { + background: #fff; } + +/* account detail screen */ +.account-detail-section { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -ms-flex-wrap: wrap; + flex-wrap: wrap; + overflow-y: auto; + -webkit-box-orient: inherit; + -webkit-box-direction: inherit; + -ms-flex-direction: inherit; + flex-direction: inherit; } + +.grow-tenx { + -webkit-box-flex: 10; + -ms-flex-positive: 10; + flex-grow: 10; } + +.unapproved-tx-icon { + height: 16px; + width: 16px; + background: #2faef4; + border-color: #aeaeae; + border-radius: 13px; } + +.edit-text { + height: 100%; + visibility: hidden; } + +.editing-label { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + margin-left: 50px; + margin-bottom: 2px; + font-size: 11px; + text-rendering: geometricPrecision; + color: #f7861c; } + +.name-label:hover .edit-text { + visibility: visible; } + +/* tx confirm */ +.unconftx-section input[type=password] { + height: 22px; + padding: 2px; + margin: 12px; + margin-bottom: 24px; + border-radius: 4px; + border: 2px solid #f3c83e; + background: #faf6f0; } + +/* Ether Balance Widget */ +.ether-balance-amount { + color: #f7861c; } + +.ether-balance-label { + color: #aba9aa; } + +/* Info screen */ +.info-gray { + font-family: Roboto; + text-transform: uppercase; + color: #aeaeae; } + +.icon-size { + width: 20px; } + +.info { + font-family: Roboto, Arial; + padding-bottom: 10px; + display: inline-block; + padding-left: 5px; } + +/* buy eth warning screen */ +.custom-radios { + -ms-flex-pack: distribute; + justify-content: space-around; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + +.custom-radio-selected { + width: 17px; + height: 17px; + border: solid; + border-style: double; + border-radius: 15px; + border-width: 5px; + background: #f7861c; + border-color: #f7f7f7; } + +.custom-radio-inactive { + width: 14px; + height: 14px; + border: solid; + border-width: 1px; + border-radius: 24px; + border-color: #aeaeae; } + +.radio-titles { + color: #f7861c; } + +.eth-warning { + -webkit-transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in, -webkit-transform 400ms ease-in; } + +.buy-subview { + -webkit-transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, -webkit-transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in; + transition: opacity 400ms ease-in, transform 400ms ease-in, -webkit-transform 400ms ease-in; } + +.input-container:hover .edit-text { + visibility: visible; } + +.buy-inputs { + font-family: Roboto; + font-size: 13px; + height: 20px; + background: transparent; + -webkit-box-sizing: border-box; + box-sizing: border-box; + border: solid; + border-color: transparent; + border-width: .5px; + border-radius: 2px; } + +.input-container:hover .buy-inputs { + -webkit-box-sizing: inherit; + box-sizing: inherit; + border: solid; + border-color: #f7861c; + border-width: .5px; + border-radius: 2px; } + +.buy-inputs:focus { + border: solid; + border-color: #f7861c; + border-width: .5px; + border-radius: 2px; } + +.activeForm { + background: #f7f7f7; + border: none; + border-radius: 8px 8px 0px 0px; + width: 50%; + text-align: center; + padding-bottom: 4px; } + +.inactiveForm { + border: none; + border-radius: 8px 8px 0px 0px; + width: 50%; + text-align: center; + padding-bottom: 4px; } + +.ex-coins { + font-family: Roboto; + text-transform: uppercase; + text-align: center; + font-size: 33px; + width: 118px; + height: 42px; + padding: 1px; + color: #4d4d4d; } + +.marketinfo { + font-family: Roboto; + color: #aeaeae; + font-size: 15px; + line-height: 17px; } + +#fromCoin::-webkit-calendar-picker-indicator { + display: none; } + +#coinList { + width: 400px; + height: 500px; + overflow: scroll; } + +.icon-control .fa-refresh { + visibility: hidden; } + +.icon-control:hover .fa-refresh { + visibility: visible; } + +.icon-control:hover .fa-chevron-right { + visibility: hidden; } + +.inactive { + color: #aeaeae; } + +.inactive button { + background: #aeaeae; + color: #fff; } + +.qr-ellip-address, .ellip-address { + overflow: hidden; + text-overflow: ellipsis; } + +.qr-header { + font-size: 25px; + margin-top: 40px; } + +.qr-message { + font-size: 12px; + color: #f7861c; } + +div.message-container > div:first-child { + margin-top: 18px; + font-size: 15px; + color: #4d4d4d; } + +.pop-hover:hover { + -webkit-transform: scale(1.1); + transform: scale(1.1); } + +/* stylelint-enable */ +.token-list-item { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + padding: 20px 24px; + cursor: pointer; + -webkit-transition: linear 200ms; + transition: linear 200ms; + background-color: rgba(231, 231, 231, 0); + position: relative; } + .token-list-item__token-balance { + font-size: 130%; } + @media screen and (min-width: 576px) and (max-width: 890px) { + .token-list-item__token-balance { + font-size: 105%; } } + .token-list-item__fiat-amount { + margin-top: .25%; + font-size: 105%; + text-transform: uppercase; } + @media screen and (min-width: 576px) and (max-width: 890px) { + .token-list-item__fiat-amount { + font-size: 95%; } } + @media screen and (min-width: 576px) and (max-width: 890px) { + .token-list-item { + padding: 10% 4%; } } + .token-list-item--active { + background-color: #e7e7e7; } + .token-list-item__identicon { + margin-right: 15px; + border: '1px solid #dedede'; } + @media screen and (min-width: 576px) and (max-width: 890px) { + .token-list-item__identicon { + margin-right: 4%; } } + .token-list-item__ellipsis { + line-height: 45px; } + .token-list-item__balance-wrapper { + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; } + +.token-menu-dropdown { + height: 55px; + width: 191px; + border-radius: 4px; + background-color: rgba(0, 0, 0, 0.82); + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.5); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.5); + position: fixed; + margin-top: 20px; + margin-left: 105px; + z-index: 2000; } + .token-menu-dropdown__close-area { + position: fixed; + top: 0; + left: 0; + z-index: 2100; + width: 100%; + height: 100%; + cursor: default; } + .token-menu-dropdown__container { + padding: 16px 34px 32px; + z-index: 2200; + position: relative; } + .token-menu-dropdown__options { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + .token-menu-dropdown__option { + color: #fff; + font-family: Roboto; + font-size: 16px; + line-height: 21px; + text-align: center; } + +.add-token { + width: 498px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + position: relative; + z-index: 12; + font-family: 'DIN Next Light'; } + .add-token__wrapper { + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .add-token__title-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + padding: 30px 60px 12px; + border-bottom: 1px solid #efefef; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .add-token__title { + color: #5d5d5d; + font-size: 20px; + line-height: 26px; + text-align: center; + font-weight: 600; + margin-bottom: 12px; } + .add-token__description { + text-align: center; } + .add-token__description + .add-token__description { + margin-top: 24px; } + .add-token__confirmation-description { + margin: 12px 0; } + .add-token__content-container { + width: 100%; + border-bottom: 1px solid #efefef; } + .add-token__input-container { + padding: 11px 0; + width: 263px; + margin: 0 auto; + position: relative; } + .add-token__search-input-error-message { + position: absolute; + bottom: -10px; + font-size: 12px; + width: 100%; + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; + color: #f00; } + .add-token__input { + width: 100%; + border: 2px solid #efefef; + border-radius: 4px; + padding: 5px 15px; + font-size: 14px; + line-height: 19px; } + .add-token__input::-webkit-input-placeholder { + color: #cdcdcd; } + .add-token__input:-ms-input-placeholder { + color: #cdcdcd; } + .add-token__input::-ms-input-placeholder { + color: #cdcdcd; } + .add-token__input::placeholder { + color: #cdcdcd; } + .add-token__footers { + width: 100%; } + .add-token__add-custom { + color: #5d5d5d; + font-size: 18px; + line-height: 24px; + text-align: center; + padding: 12px 0; + font-weight: 600; + cursor: pointer; } + .add-token__add-custom:hover { + background-color: rgba(0, 0, 0, 0.05); } + .add-token__add-custom:active { + background-color: rgba(0, 0, 0, 0.1); } + .add-token__add-custom .fa { + position: absolute; + right: 24px; + font-size: 24px; + line-height: 24px; } + .add-token__add-custom-form { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + margin: 8px 0 51px; } + .add-token__add-custom-field { + width: 290px; + margin: 0 auto; + position: relative; } + .add-token__add-custom-field--error .add-token__add-custom-input { + border-color: #f00; } + .add-token__add-custom-error-message { + position: absolute; + bottom: -21px; + font-size: 12px; + width: 100%; + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; + color: #f00; } + .add-token__add-custom-label { + font-size: 16px; + line-height: 21px; + margin-bottom: 8px; } + .add-token__add-custom-input { + width: 100%; + border: 1px solid #cdcdcd; + padding: 5px 15px; + font-size: 14px; + line-height: 19px; } + .add-token__add-custom-input::-webkit-input-placeholder { + color: #cdcdcd; } + .add-token__add-custom-input:-ms-input-placeholder { + color: #cdcdcd; } + .add-token__add-custom-input::-ms-input-placeholder { + color: #cdcdcd; } + .add-token__add-custom-input::placeholder { + color: #cdcdcd; } + .add-token__add-custom-field + .add-token__add-custom-field { + margin-top: 21px; } + .add-token__buttons { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + margin: 30px 0 51px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .add-token__token-icons-container { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row wrap; + flex-flow: row wrap; } + .add-token__token-wrapper { + -webkit-transition: 200ms ease-in-out; + transition: 200ms ease-in-out; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-flex: 0; + -ms-flex: 0 0 42.5%; + flex: 0 0 42.5%; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + padding: 12px; + margin: 2.5%; + -webkit-box-sizing: border-box; + box-sizing: border-box; + border-radius: 10px; + cursor: pointer; + border: 2px solid transparent; + position: relative; } + .add-token__token-wrapper:hover { + border: 2px solid rgba(122, 201, 253, 0.5); } + .add-token__token-wrapper--selected { + border: 2px solid #7ac9fd !important; } + .add-token__token-wrapper--disabled { + opacity: .4; + pointer-events: none; } + .add-token__token-data { + -ms-flex-item-align: start; + align-self: flex-start; } + .add-token__token-name { + font-size: 14px; + line-height: 19px; } + .add-token__token-symbol { + font-size: 22px; + line-height: 29px; + font-weight: 600; } + .add-token__token-icon { + width: 60px; + height: 60px; + background-repeat: no-repeat; + background-size: contain; + background-position: center; + border-radius: 50%; + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.24); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.24); + margin-right: 12px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .add-token__token-message { + position: absolute; + color: #02c9b1; + font-size: 11px; + bottom: 0; + left: 85px; } + .add-token__confirmation-token-list { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; } + .add-token__confirmation-token-list .token-balance { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-align: start; + -ms-flex-align: start; + align-items: flex-start; } + .add-token__confirmation-token-list .token-balance__amount { + color: #5d5d5d; + font-size: 43px; + font-weight: 300; + line-height: 43px; + margin-right: 8px; } + .add-token__confirmation-token-list .token-balance__symbol { + color: #5d5d5d; + font-size: 16px; + line-height: 24px; } + .add-token__confirmation-title { + padding: 30px 120px 12px; } + @media screen and (max-width: 575px) { + .add-token__confirmation-title { + padding: 20px 0; + width: 100%; } } + .add-token__confirmation-content { + padding-bottom: 60px; } + .add-token__confirmation-token-list-item { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + margin: 0 auto; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .add-token__confirmation-token-list-item + .add-token__confirmation-token-list-item { + margin-top: 30px; } + .add-token__confirmation-token-icon { + margin-right: 18px; } + @media screen and (max-width: 575px) { + .add-token { + top: 0; + width: 100%; + overflow: hidden; + height: 100%; } + .add-token__wrapper { + -webkit-box-shadow: none !important; + box-shadow: none !important; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; + width: 100%; + overflow-y: auto; } + .add-token__footers { + border-bottom: 1px solid #efefef; } + .add-token__token-icon { + width: 50px; + height: 50px; } + .add-token__token-symbol { + font-size: 18px; + line-height: 24px; } + .add-token__token-name { + font-size: 12px; + line-height: 16px; } + .add-token__buttons { + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + width: 100%; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + padding: 12px 0; + margin: 0; + border-top: 1px solid #efefef; } + .add-token__buttons button { + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + margin: 0 12px; } } + +.currency-display { + height: 54px; + width: 100%ß; + border: 1px solid #dedede; + border-radius: 4px; + background-color: #fff; + color: #9b9b9b; + font-family: Roboto; + font-size: 16px; + font-weight: 300; + padding: 8px 10px; + position: relative; } + .currency-display__primary-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + .currency-display__input { + color: #5d5d5d; + font-family: Roboto; + font-size: 16px; + line-height: 22px; + border: none; + outline: 0 !important; + max-width: 100%; } + .currency-display__primary-currency { + color: #5d5d5d; + font-weight: 400; + font-family: Roboto; + font-size: 16px; + line-height: 22px; } + .currency-display__converted-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + .currency-display__converted-value, .currency-display__converted-currency { + color: #9b9b9b; + font-family: Roboto; + font-size: 12px; + line-height: 12px; } + .currency-display__input-wrapper { + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; } + .currency-display__currency-symbol { + margin-top: 1px; } + +.account-menu { + position: fixed; + z-index: 100; + top: 58px; + width: 310px; } + @media screen and (max-width: 575px) { + .account-menu { + right: calc(((100vw - 100%) / 2) + 8px); } } + @media screen and (min-width: 576px) { + .account-menu { + right: calc((100vw - 85vw) / 2); } } + @media screen and (min-width: 769px) { + .account-menu { + right: calc((100vw - 80vw) / 2); } } + @media screen and (min-width: 1281px) { + .account-menu { + right: calc((100vw - 65vw) / 2); } } + .account-menu__icon { + margin-left: 20px; + cursor: pointer; } + .account-menu__header { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; } + .account-menu__logout-button { + border: 1px solid #9b9b9b; + background-color: transparent; + color: #fff; + border-radius: 4px; + font-size: 12px; + line-height: 23px; + padding: 0 24px; + font-weight: 200; } + .account-menu img { + width: 16px; + height: 16px; } + .account-menu__accounts { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + overflow-y: auto; + max-height: 240px; + position: relative; + z-index: 200; } + .account-menu__accounts::-webkit-scrollbar { + display: none; } + @media screen and (max-width: 575px) { + .account-menu__accounts { + max-height: 215px; } } + .account-menu__accounts .keyring-label { + margin-top: 5px; + background-color: #000; + color: #9b9b9b; } + .account-menu__account { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + padding: 16px 14px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + @media screen and (max-width: 575px) { + .account-menu__account { + padding: 12px 14px; } } + .account-menu__account-info { + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + padding-top: 4px; } + .account-menu__check-mark { + width: 14px; + margin-right: 12px; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .account-menu__check-mark-icon { + background-image: url("images/check-white.svg"); + height: 18px; + width: 18px; + background-repeat: no-repeat; + background-position: center; + background-size: contain; + margin: 3px 0; } + .account-menu .identicon { + margin: 0 12px 0 0; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + .account-menu__name { + color: #fff; + font-size: 18px; + font-weight: 200; + line-height: 16px; } + .account-menu__balance { + color: #9b9b9b; + font-size: 14px; + line-height: 19px; } + .account-menu__action { + font-size: 16px; + line-height: 18px; + font-weight: 200; + cursor: pointer; } + +.menu { + border-radius: 4px; + background: rgba(0, 0, 0, 0.8); + -webkit-box-shadow: rgba(0, 0, 0, 0.15) 0 2px 2px 2px; + box-shadow: rgba(0, 0, 0, 0.15) 0 2px 2px 2px; + min-width: 150px; + color: #fff; } + .menu__item { + padding: 18px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-flow: row nowrap; + flex-flow: row nowrap; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + position: relative; + z-index: 200; + font-weight: 200; } + @media screen and (max-width: 575px) { + .menu__item { + padding: 14px; } } + .menu__item--clickable { + cursor: pointer; } + .menu__item--clickable:hover { + background-color: rgba(255, 255, 255, 0.05); } + .menu__item--clickable:active { + background-color: rgba(255, 255, 255, 0.1); } + .menu__item__icon { + height: 16px; + width: 16px; + margin-right: 14px; } + .menu__item__text { + font-size: 16px; + line-height: 21px; } + .menu__divider { + background-color: #5d5d5d; + width: 100%; + height: 1px; } + .menu__close-area { + position: fixed; + width: 100%; + height: 100%; + top: 0; + left: 0; + z-index: 100; } + +.gas-slider { + position: relative; + width: 313px; } + .gas-slider__input { + width: 317px; + margin-left: -2px; + z-index: 2; } + .gas-slider input[type=range] { + -webkit-appearance: none !important; } + .gas-slider input[type=range]::-webkit-slider-thumb { + -webkit-appearance: none !important; + height: 26px; + width: 26px; + border: 2px solid #B8B8B8; + background-color: #FFFFFF; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + border-radius: 50%; + position: relative; + z-index: 10; } + .gas-slider__bar { + height: 6px; + width: 313px; + background: #dedede; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + position: absolute; + top: 11px; + z-index: 0; } + .gas-slider__low, .gas-slider__high { + height: 6px; + width: 49px; + z-index: 1; } + .gas-slider__low { + background-color: #e91550; } + .gas-slider__high { + background-color: #02c9b1; } + +.settings { + position: relative; + background: #fff; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + height: auto; + overflow: auto; } + +.settings__header { + padding: 25px; } + +.settings__close-button::after { + content: '\00D7'; + font-size: 40px; + color: #9b9b9b; + position: absolute; + top: 25px; + right: 30px; + cursor: pointer; } + +.settings__error { + padding-bottom: 20px; + text-align: center; + color: #e91550; } + +.settings__content { + padding: 0 25px; } + +.settings__content-row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + padding: 10px 0 20px; } + @media screen and (max-width: 575px) { + .settings__content-row { + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + padding: 10px 0; } } + +.settings__content-item { + -webkit-box-flex: 1; + -ms-flex: 1; + flex: 1; + min-width: 0; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; + padding: 0 5px; + height: 71px; } + @media screen and (max-width: 575px) { + .settings__content-item { + height: initial; + padding: 5px 0; } } + .settings__content-item--without-height { + height: initial; } + +.settings__content-item-col { + max-width: 300px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-direction: column; + flex-direction: column; } + @media screen and (max-width: 575px) { + .settings__content-item-col { + max-width: 100%; + width: 100%; } } + +.settings__content-description { + font-size: 14px; + color: #9b9b9b; + padding-top: 5px; } + +.settings__input { + padding-left: 10px; + font-size: 14px; + height: 40px; + border: 1px solid #dedede; } + +.settings__input::-webkit-input-placeholder { + font-weight: 100; + color: #9b9b9b; } + +.settings__input::-moz-placeholder { + font-weight: 100; + color: #9b9b9b; } + +.settings__input:-ms-input-placeholder { + font-weight: 100; + color: #9b9b9b; } + +.settings__input:-moz-placeholder { + font-weight: 100; + color: #9b9b9b; } + +.settings__provider-wrapper { + font-size: 16px; + border: 1px solid #dedede; + border-radius: 2px; + padding: 15px; + background-color: #fff; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; } + +.settings__provider-icon { + height: 10px; + width: 10px; + margin-right: 10px; + border-radius: 10px; } + +.settings__rpc-save-button { + -ms-flex-item-align: end; + align-self: flex-end; + padding: 5px; + text-transform: uppercase; + color: #9b9b9b; + cursor: pointer; } + +.settings__clear-button { + font-size: 16px; + border: 1px solid #2f9ae0; + color: #2f9ae0; + border-radius: 2px; + padding: 18px; + background-color: #fff; + text-transform: uppercase; } + +.settings__clear-button--red { + border: 1px solid #d0021b; + color: #d0021b; } + +.settings__info-logo-wrapper { + height: 80px; + margin-bottom: 20px; } + +.settings__info-logo { + max-height: 100%; + max-width: 100%; } + +.settings__info-item { + padding: 10px 0; } + +.settings__info-link-header { + padding-bottom: 15px; } + @media screen and (max-width: 575px) { + .settings__info-link-header { + padding-bottom: 5px; } } + +.settings__info-link-item { + padding: 15px 0; } + @media screen and (max-width: 575px) { + .settings__info-link-item { + padding: 5px 0; } } + +.settings__info-version-number { + padding-top: 5px; + font-size: 13px; + color: #9b9b9b; } + +.settings__info-about { + color: #9b9b9b; + margin-bottom: 15px; } + +.settings__info-link { + color: #2f9ae0; } + +.settings__info-separator { + margin: 15px 0; + width: 80px; + border-color: #dedede; + border: none; + height: 1px; + background-color: #dedede; + color: #dedede; } + +.tab-bar { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: horizontal; + -webkit-box-direction: normal; + -ms-flex-direction: row; + flex-direction: row; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: end; + -ms-flex-align: end; + align-items: flex-end; } + +.tab-bar__tab { + min-width: 0; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + padding: 15px 25px; + border-bottom: 1px solid #dedede; + -webkit-box-sizing: border-box; + box-sizing: border-box; + font-size: 18px; } + +.tab-bar__tab--active { + border-color: #000; } + +.tab-bar__grow-tab { + -webkit-box-flex: 1; + -ms-flex-positive: 1; + flex-grow: 1; } + +.simple-dropdown { + height: 56px; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: start; + -ms-flex-pack: start; + justify-content: flex-start; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + border: 1px solid #dedede; + border-radius: 4px; + background-color: #fff; + font-size: 16px; + color: #4d4d4d; + cursor: pointer; + position: relative; } + +.simple-dropdown__caret { + color: #cdcdcd; + padding: 0 10px; } + +.simple-dropdown__selected { + -webkit-box-flex: 1; + -ms-flex-positive: 1; + flex-grow: 1; + padding: 0 15px; } + +.simple-dropdown__options { + z-index: 1050; + position: absolute; + height: 220px; + width: 100%; + border: 1px solid #d2d8dd; + border-radius: 4px; + background-color: #fff; + -webkit-box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + margin-top: 10px; + overflow-y: scroll; + left: 0; + top: 100%; } + +.simple-dropdown__option { + padding: 10px; } + .simple-dropdown__option:hover { + background-color: #efefef; } + +.simple-dropdown__option--selected { + background-color: #dedede; } + .simple-dropdown__option--selected:hover { + background-color: #dedede; + cursor: default; } + +.simple-dropdown__close-area { + position: fixed; + top: 0; + left: 0; + z-index: 1000; + width: 100%; + height: 100%; } + +.request-signature__container { + width: 380px; + border-radius: 8px; + background-color: #fff; + -webkit-box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08); + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column nowrap; + flex-flow: column nowrap; + z-index: 25; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + font-family: Roboto; + position: relative; + height: 100%; } + @media screen and (max-width: 575px) { + .request-signature__container { + width: 100%; + top: 0; + -webkit-box-shadow: none; + box-shadow: none; } } + @media screen and (min-width: 576px) { + .request-signature__container { + max-height: 620px; } } + +.request-signature__header { + height: 64px; + width: 100%; + position: relative; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; } + +.request-signature__header-background { + position: absolute; + background-color: #e9edf0; + z-index: 2; + width: 100%; + height: 100%; } + +.request-signature__header__text { + height: 29px; + width: 179px; + color: #5B5D67; + font-family: Roboto; + font-size: 22px; + font-weight: 300; + line-height: 29px; + z-index: 3; } + +.request-signature__header__tip-container { + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + +.request-signature__header__tip { + height: 25px; + width: 25px; + background: #e9edf0; + -webkit-transform: rotate(45deg); + transform: rotate(45deg); + position: absolute; + bottom: -8px; + z-index: 1; } + +.request-signature__account-info { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: justify; + -ms-flex-pack: justify; + justify-content: space-between; + margin-top: 18px; + margin-bottom: 20px; } + +.request-signature__account { + color: #9b9b9b; + margin-left: 17px; } + +.request-signature__account-text { + font-size: 14px; } + +.request-signature__balance { + color: #9b9b9b; + margin-right: 17px; + width: 124px; } + +.request-signature__balance-text { + text-align: right; + font-size: 14px; } + +.request-signature__balance-value { + text-align: right; + margin-top: 2.5px; } + +.request-signature__request-icon { + margin-top: 25px; } + +.request-signature__body { + width: 100%; + height: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; + -webkit-box-flex: 1; + -ms-flex: 1 1 auto; + flex: 1 1 auto; + height: 0; } + +.request-signature__request-info { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; } + +.request-signature__headline { + height: 48px; + width: 240px; + color: #4d4d4d; + font-family: Roboto; + font-size: 18px; + font-weight: 300; + line-height: 24px; + text-align: center; + margin-top: 20px; } + +.request-signature__notice, .request-signature__warning { + font-family: "Avenir Next"; + font-size: 14px; + line-height: 19px; + text-align: center; + margin-top: 41px; + margin-bottom: 11px; + width: 100%; } + +.request-signature__notice { + color: #9b9b9b; } + +.request-signature__warning { + color: #e91550; } + +.request-signature__rows { + height: 100%; + overflow-y: scroll; + overflow-x: hidden; + border-top: 1px solid #d2d8dd; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; } + +.request-signature__row { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + -ms-flex-flow: column; + flex-flow: column; } + +.request-signature__row-title { + width: 80px; + color: #9b9b9b; + font-family: Roboto; + font-size: 16px; + line-height: 22px; + margin-top: 12px; + margin-left: 18px; + width: 100%; } + +.request-signature__row-value { + color: #5d5d5d; + font-family: Roboto; + font-size: 14px; + line-height: 19px; + width: 100%; + overflow-wrap: break-word; + border-bottom: 1px solid #d2d8dd; + padding: 6px 18px 15px; } + +.request-signature__footer { + width: 100%; + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: space-evenly; + -ms-flex-pack: space-evenly; + justify-content: space-evenly; + font-size: 22px; + position: relative; + -webkit-box-flex: 0; + -ms-flex: 0 0 auto; + flex: 0 0 auto; + border-top: 1px solid #d2d8dd; } + .request-signature__footer__cancel-button, .request-signature__footer__sign-button { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + -webkit-box-flex: 1; + -ms-flex: 1 0 auto; + flex: 1 0 auto; + font-family: Roboto; + font-size: 16px; + font-weight: 300; + height: 55px; + line-height: 32px; + cursor: pointer; + border-radius: 2px; + -webkit-box-shadow: none; + box-shadow: none; + max-width: 162px; + margin: 12px; } + .request-signature__footer__cancel-button { + background: none; + border: 1px solid #9b9b9b; + margin-right: 6px; } + .request-signature__footer__sign-button { + background-color: #02c9b1; + border-width: 0; + color: #fff; + margin-left: 6px; } + +.account-dropdown-mini { + height: 22px; + background-color: #fff; + font-family: Roboto; + line-height: 16px; + font-size: 12px; + width: 124px; } + .account-dropdown-mini__close-area { + position: fixed; + top: 0; + left: 0; + z-index: 1000; + width: 100%; + height: 100%; } + .account-dropdown-mini__list { + z-index: 1050; + position: absolute; + height: 180px; + width: 96pxpx; + border: 1px solid #d2d8dd; + border-radius: 4px; + background-color: #fff; + -webkit-box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.11); + overflow-y: scroll; } + .account-dropdown-mini .account-list-item { + margin-top: 6px; } + .account-dropdown-mini .account-list-item__account-name { + text-overflow: ellipsis; + overflow: hidden; + white-space: nowrap; + width: 80px; } + .account-dropdown-mini .account-list-item__top-row { + margin: 0; } + .account-dropdown-mini .account-list-item__icon { + position: initial; } + +.editable-label { + display: -webkit-box; + display: -ms-flexbox; + display: flex; + -webkit-box-align: center; + -ms-flex-align: center; + align-items: center; + -webkit-box-pack: center; + -ms-flex-pack: center; + justify-content: center; + position: relative; } + .editable-label__value { + max-width: 250px; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; } + .editable-label__input { + width: 250px; + font-size: 14px; + text-align: center; + border: 1px solid #dedede; } + .editable-label__input--error { + border: 1px solid #d0021b; } + .editable-label__icon-wrapper { + position: absolute; + margin-left: 10px; + left: 100%; } + .editable-label__icon { + cursor: pointer; + color: #9b9b9b; } + +/* + Trumps + */ +/* universal */ +.app-primary .main-enter { + position: absolute; + width: 100%; } + +/* center position */ +.app-primary.from-right .main-enter-active, +.app-primary.from-left .main-enter-active { + overflow-x: hidden; + -webkit-transform: translateX(0); + transform: translateX(0); + -webkit-transition: -webkit-transform 300ms ease-in; + transition: -webkit-transform 300ms ease-in; + transition: transform 300ms ease-in; + transition: transform 300ms ease-in, -webkit-transform 300ms ease-in; } + +/* exited positions */ +.app-primary.from-left .main-leave-active { + -webkit-transform: translateX(360px); + transform: translateX(360px); + -webkit-transition: -webkit-transform 300ms ease-in; + transition: -webkit-transform 300ms ease-in; + transition: transform 300ms ease-in; + transition: transform 300ms ease-in, -webkit-transform 300ms ease-in; } + +.app-primary.from-right .main-leave-active { + -webkit-transform: translateX(-360px); + transform: translateX(-360px); + -webkit-transition: -webkit-transform 300ms ease-in; + transition: -webkit-transform 300ms ease-in; + transition: transform 300ms ease-in; + transition: transform 300ms ease-in, -webkit-transform 300ms ease-in; } + +.sidebar.from-left { + -webkit-transform: translateX(-320px); + transform: translateX(-320px); + -webkit-transition: -webkit-transform 300ms ease-in; + transition: -webkit-transform 300ms ease-in; + transition: transform 300ms ease-in; + transition: transform 300ms ease-in, -webkit-transform 300ms ease-in; } + +/* loader transitions */ +.loader-enter, +.loader-leave-active { + opacity: 0; + -webkit-transition: opacity 150 ease-in; + transition: opacity 150 ease-in; } + +.loader-enter-active, +.loader-leave { + opacity: 1; + -webkit-transition: opacity 150 ease-in; + transition: opacity 150 ease-in; } + +/* entering positions */ +.app-primary.from-right .main-enter:not(.main-enter-active) { + -webkit-transform: translateX(360px); + transform: translateX(360px); } + +.app-primary.from-left .main-enter:not(.main-enter-active) { + -webkit-transform: translateX(-360px); + transform: translateX(-360px); } + +i.fa.fa-question-circle.fa-lg.menu-icon { + font-size: 18px; } + +/* stylelint-disable */ +#buy-modal-content-footer-text { + font-family: 'DIN OT'; + font-size: 16px; } + +/* stylelint-enable */ + +/*# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"index.css","sources":["index.scss","itcss/settings/index.scss","itcss/settings/variables.scss","itcss/settings/typography.scss","itcss/tools/index.scss","itcss/tools/utilities.scss","itcss/generic/index.scss","itcss/generic/reset.scss","itcss/base/index.scss","itcss/objects/index.scss","itcss/components/index.scss","itcss/components/buttons.scss","itcss/components/header.scss","itcss/components/footer.scss","itcss/components/network.scss","itcss/components/modal.scss","itcss/components/newui-sections.scss","itcss/components/account-dropdown.scss","itcss/components/send.scss","itcss/components/confirm.scss","itcss/components/loading-overlay.scss","itcss/components/hero-balance.scss","itcss/components/wallet-balance.scss","itcss/components/transaction-list.scss","itcss/components/sections.scss","itcss/components/token-list.scss","itcss/components/add-token.scss","itcss/components/currency-display.scss","itcss/components/account-menu.scss","itcss/components/menu.scss","itcss/components/gas-slider.scss","itcss/components/settings.scss","itcss/components/tab-bar.scss","itcss/components/simple-dropdown.scss","itcss/components/request-signature.scss","itcss/components/account-dropdown-mini.scss","itcss/components/editable-label.scss","itcss/trumps/index.scss"],"sourcesContent":["/*\n  ITCSS\n\n  http://www.creativebloq.com/web-design/manage-large-css-projects-itcss-101517528\n  https://www.xfive.co/blog/itcss-scalable-maintainable-css-architecture/\n */\n@import './itcss/settings/index.scss';\n@import './itcss/tools/index.scss';\n@import './itcss/generic/index.scss';\n@import './itcss/base/index.scss';\n@import './itcss/objects/index.scss';\n@import './itcss/components/index.scss';\n@import './itcss/trumps/index.scss';\n","@import './variables.scss';\n\n@import './typography.scss';\n","/*\n  Variables\n */\n\n// Base Colors\n$white: #fff;\n$black: #000;\n$orange: #ffa500;\n$red: #f00;\n$gray: #808080;\n\n/*\n  Colors\n  http://chir.ag/projects/name-that-color\n */\n$white-linen: #faf6f0; // formerly 'faint orange (textfield shades)'\n$rajah: #f5c26d; // formerly 'light orange (button shades)'\n$buttercup: #f5a623; // formerly 'dark orange (text)'\n$tundora: #4a4a4a; // formerly 'borders/font/any gray'\n$gallery: #efefef;\n$alabaster: #f7f7f7;\n$shark: #22232c;\n$wild-sand: #f6f6f6;\n$white: #fff;\n$dusty-gray: #9b9b9b;\n$alto: #dedede;\n$alabaster: #fafafa;\n$silver-chalice: #aeaeae;\n$curious-blue: #2f9ae0;\n$concrete: #f3f3f3;\n$tundora: #4d4d4d;\n$nile-blue: #1b344d;\n$scorpion: #5d5d5d;\n$silver: #cdcdcd;\n$caribbean-green: #02c9b1;\n$monzo: #d0021b;\n$crimson: #e91550;\n$blue-lagoon: #038789;\n$purple: #690496;\n$tulip-tree: #ebb33f;\n$malibu-blue: #7ac9fd;\n$athens-grey: #e9edf0;\n$jaffa: #f28930;\n$geyser: #d2d8dd;\n\n/*\n  Z-Indicies\n */\n$dropdown-z-index: 30;\n$token-icon-z-index: 15;\n$container-z-index: 15;\n$header-z-index: 12;\n$mobile-header-z-index: 26;\n$main-container-z-index: 18;\n$send-card-z-index: 20;\n$sidebar-z-index: 26;\n$sidebar-overlay-z-index: 25;\n\n/*\n  Z Indicies - Current\n  app - 11\n  hex/bn as decimal input - 1 - remove?\n  dropdown - 11\n  loading - 10 - higher?\n  mascot - 0 - remove?\n */\n\n/*\n  Responsive Breakpoints\n */\n$break-small: 575px;\n$break-midpoint: 780px;\n$break-large: 576px;\n\n\n$primary-font-type: Roboto;\n\n","@import url('https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900');\n\n@import url('https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css');\n\n@font-face {\n  font-family: 'Montserrat Regular';\n  src: url('/fonts/Montserrat/Montserrat-Regular.woff') format('woff');\n  src: url('/fonts/Montserrat/Montserrat-Regular.ttf') format('truetype');\n  font-weight: 400;\n  font-style: normal;\n  font-size: 'small';\n}\n\n@font-face {\n  font-family: 'Montserrat Bold';\n  src: url('/fonts/Montserrat/Montserrat-Bold.woff') format('woff');\n  src: url('/fonts/Montserrat/Montserrat-Bold.ttf') format('truetype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'Montserrat Light';\n  src: url('/fonts/Montserrat/Montserrat-Light.woff') format('woff');\n  src: url('/fonts/Montserrat/Montserrat-Light.ttf') format('truetype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'Montserrat UltraLight';\n  src: url('/fonts/Montserrat/Montserrat-UltraLight.woff') format('woff');\n  src: url('/fonts/Montserrat/Montserrat-UltraLight.ttf') format('truetype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'DIN OT';\n  src: url('/fonts/DIN_OT/DINOT-2.otf') format('opentype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'DIN OT Light';\n  src: url('/fonts/DIN_OT/DINOT-2.otf') format('opentype');\n  font-weight: 200;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'DIN NEXT';\n  src: url('/fonts/DIN NEXT/DIN NEXT W01 Regular.otf') format('opentype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'DIN NEXT Light';\n  src: url('/fonts/DIN NEXT/DIN NEXT W10 Light.otf') format('opentype');\n  font-weight: 400;\n  font-style: normal;\n}\n\n@font-face {\n  font-family: 'Lato';\n  src: url('/fonts/Lato/Lato-Regular.ttf') format('truetype');\n  font-weight: 400;\n  font-style: normal;\n}\n","@import './utilities.scss';\n","/*\n  Utility Classes\n */\n\n/* color */\n\n.color-orange {\n  color: #f7861c; // TODO: move to settings/variables\n}\n\n.color-forest {\n  color: #0a5448; // TODO: move to settings/variables\n}\n\n/* lib */\n\n.full-size {\n  height: 100%;\n  width: 100%;\n}\n\n.full-width {\n  width: 100%;\n}\n\n.full-flex-height {\n  display: flex;\n  flex: 1 1 auto;\n  flex-direction: column;\n}\n\n.full-height {\n  height: 100%;\n}\n\n.flex-column {\n  display: flex;\n  flex-direction: column;\n}\n\n.space-between {\n  justify-content: space-between;\n}\n\n.space-around {\n  justify-content: space-around;\n}\n\n.flex-column-bottom {\n  display: flex;\n  flex-direction: column-reverse;\n}\n\n.flex-row {\n  display: flex;\n  flex-direction: row;\n}\n\n.flex-space-between {\n  justify-content: space-between;\n}\n\n.flex-space-around {\n  justify-content: space-around;\n}\n\n.flex-right {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-end;\n}\n\n.flex-left {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n}\n\n.flex-fixed {\n  flex: none;\n}\n\n.flex-basis-auto {\n  flex-basis: auto;\n}\n\n.flex-grow {\n  flex: 1 1 auto;\n}\n\n.flex-wrap {\n  flex-wrap: wrap;\n}\n\n.flex-center {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n}\n\n.flex-justify-center {\n  justify-content: center;\n}\n\n.flex-align-center {\n  align-items: center;\n}\n\n.flex-self-end {\n  align-self: flex-end;\n}\n\n.flex-self-stretch {\n  align-self: stretch;\n}\n\n.flex-vertical {\n  flex-direction: column;\n}\n\n.z-bump {\n  z-index: 1;\n}\n\n.select-none {\n  cursor: inherit;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n.pointer {\n  cursor: pointer;\n}\n\n.cursor-pointer {\n  cursor: pointer;\n  transform-origin: center center;\n  transition: transform 50ms ease-in-out;\n}\n\n.cursor-pointer:hover {\n  transform: scale(1.1);\n}\n\n.cursor-pointer:active {\n  transform: scale(.95);\n}\n\n.cursor-disabled {\n  cursor: not-allowed;\n}\n\n.margin-bottom-sml {\n  margin-bottom: 20px;\n}\n\n.margin-bottom-med {\n  margin-bottom: 40px;\n}\n\n.margin-right-left {\n  margin: 0 20px;\n}\n\n.bold {\n  font-weight: 700;\n}\n\n.text-transform-uppercase {\n  text-transform: uppercase;\n}\n\n.font-small {\n  font-size: 12px;\n}\n\n.font-medium {\n  font-size: 1.2em;\n}\n\nhr.horizontal-line {\n  display: block;\n  height: 1px;\n  border: 0;\n  border-top: 1px solid #ccc;\n  margin: 1em 0;\n  padding: 0;\n}\n\n.hover-white:hover {\n  background: $white;\n}\n\n.red-dot {\n  background: #e91550;\n  color: $white;\n  border-radius: 10px;\n}\n\n.diamond {\n  transform: rotate(45deg);\n  background: #038789;\n}\n\n.hollow-diamond {\n  transform: rotate(45deg);\n  border: 3px solid #690496;\n}\n\n.golden-square {\n  background: #ebb33f;\n}\n\n.pending-dot {\n  background: $red;\n  left: 14px;\n  top: 14px;\n  color: $white;\n  border-radius: 10px;\n  height: 20px;\n  min-width: 20px;\n  position: relative;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  padding: 4px;\n  z-index: 1;\n}\n\n.keyring-label {\n  z-index: 1;\n  font-size: 8px;\n  line-height: 8px;\n  background: rgba(255, 255, 255, 0.4);\n  color: #fff;\n  border-radius: 10px;\n  padding: 4px;\n  text-align: center;\n  height: 15px;\n}\n\n.ether-balance {\n  display: flex;\n  align-items: center;\n}\n\n.tabSection {\n  min-width: 350px;\n}\n\n.menu-icon {\n  display: inline-block;\n  height: 12px;\n  min-width: 12px;\n  margin: 13px;\n}\n\n.ether-icon {\n  background: rgb(0, 163, 68);\n  border-radius: 20px;\n}\n\n.testnet-icon {\n  background: #2465e1;\n}\n\n.drop-menu-item {\n  display: flex;\n  align-items: center;\n}\n\n.invisible {\n  visibility: hidden;\n}\n\n.one-line-concat {\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.critical-error {\n  text-align: center;\n  margin-top: 20px;\n  color: $red;\n}\n\n/*\n  Misc\n */\n\n// TODO: move into component-level contextual 'active' state\n.letter-spacey {\n  letter-spacing: .1em;\n}\n\n.active {\n  color: #909090;\n}\n\n.check {\n  margin-left: 7px;\n  color: #f7861c;\n  flex: 1 0 auto;\n  display: flex;\n  justify-content: flex-end;\n}\n","/*\n  Generic\n */\n\n@import './reset.scss';\n\n* {\n  box-sizing: border-box;\n}\n\nhtml,\nbody {\n  font-family: Roboto, Arial;\n  color: #4d4d4d;\n  font-weight: 300;\n  line-height: 1.4em;\n  background: #f7f7f7;\n  width: 100%;\n  height: 100%;\n  margin: 0;\n  padding: 0;\n}\n\nhtml {\n  min-height: 500px;\n}\n\n.app-root {\n  overflow: hidden;\n  position: relative;\n}\n\n.app-primary {\n  display: flex;\n}\n\ninput:focus,\ntextarea:focus {\n  outline: none;\n}\n\n/* stylelint-disable */\n#app-content {\n  overflow-x: hidden;\n  height: 100%;\n  display: flex;\n  flex-direction: column;\n\n  @media screen and (max-width: $break-small) {\n    background-color: $white;\n  }\n}\n/* stylelint-enable */\n\na {\n  text-decoration: none;\n  color: inherit;\n}\n\na:hover {\n  color: #df6b0e;\n}\n\ninput.large-input,\ntextarea.large-input {\n  padding: 8px;\n}\n\ninput.large-input {\n  height: 36px;\n}\n","/* http://meyerweb.com/eric/tools/css/reset/\n   v2.0 | 20110126\n   License: none (public domain)\n*/\n\nhtml,\nbody,\ndiv,\nspan,\napplet,\nobject,\niframe,\nh1,\nh2,\nh3,\nh4,\nh5,\nh6,\np,\nblockquote,\npre,\na,\nabbr,\nacronym,\naddress,\nbig,\ncite,\ncode,\ndel,\ndfn,\nem,\nimg,\nins,\nkbd,\nq,\ns,\nsamp,\nsmall,\nstrike,\nstrong,\nsub,\nsup,\ntt,\nvar,\nb,\nu,\ni,\ncenter,\ndl,\ndt,\ndd,\nol,\nul,\nli,\nfieldset,\nform,\nlabel,\nlegend,\ntable,\ncaption,\ntbody,\ntfoot,\nthead,\ntr,\nth,\ntd,\narticle,\naside,\ncanvas,\ndetails,\nembed,\nfigure,\nfigcaption,\nfooter,\nheader,\nhgroup,\nmenu,\nnav,\noutput,\nruby,\nsection,\nsummary,\ntime,\nmark,\naudio,\nvideo {\n  margin: 0;\n  padding: 0;\n  border: 0;\n  font-size: 100%;\n  /* stylelint-disable */\n  font: inherit;\n  /* stylelint-enable */\n  vertical-align: baseline;\n}\n\n/* HTML5 display-role reset for older browsers */\n\n/* stylelint-disable */\n\narticle,\naside,\ndetails,\nfigcaption,\nfigure,\nfooter,\nheader,\nhgroup,\nmenu,\nnav,\nsection {\n  display: block;\n}\n\nbody {\n  line-height: 1;\n}\n\nol,\nul {\n  list-style: none;\n}\n\nblockquote,\nq {\n  quotes: none;\n}\n\nblockquote:before,\nblockquote:after,\nq:before,\nq:after {\n  content: '';\n  content: none;\n}\n\ntable {\n  border-collapse: collapse;\n  border-spacing: 0;\n}\n\nbutton {\n  border-style: none;\n  cursor: pointer;\n}\n\n/* stylelint-enable */\n","// Base\n","// Objects\n","@import './buttons.scss';\n\n@import './header.scss';\n\n@import './footer.scss';\n\n@import './network.scss';\n\n@import './modal.scss';\n\n@import './newui-sections.scss';\n\n@import './account-dropdown.scss';\n\n@import './send.scss';\n\n@import './confirm.scss';\n\n@import './loading-overlay.scss';\n\n// Balances\n@import './hero-balance.scss';\n\n@import './wallet-balance.scss';\n\n// Tx List and Sections\n@import './transaction-list.scss';\n\n@import './sections.scss';\n\n@import './token-list.scss';\n\n@import './add-token.scss';\n\n@import './currency-display.scss';\n\n@import './account-menu.scss';\n\n@import './menu.scss';\n\n@import './gas-slider.scss';\n\n@import './settings.scss';\n\n@import './tab-bar.scss';\n\n@import './simple-dropdown.scss';\n\n@import './request-signature.scss';\n\n@import './account-dropdown-mini.scss';\n\n@import './editable-label.scss';\n","/*\n  Buttons\n */\n\n.btn-green {\n  background-color: #02c9b1; // TODO: reusable color in colors.css\n}\n\nbutton.btn-clear {\n  background: $white;\n  border: 1px solid;\n}\n\n// No longer used in flat design, remove when modal buttons done\n// div.wallet-btn {\n//   border: 1px solid rgb(91, 93, 103);\n//   border-radius: 2px;\n//   height: 30px;\n//   width: 75px;\n//   font-size: 0.8em;\n//   text-align: center;\n//   line-height: 25px;\n// }\n\n// .btn-red {\n//   background: rgba(254, 35, 17, 1);\n//   box-shadow: 0px 3px 6px rgba(254, 35, 17, 0.36);\n// }\n\nbutton[disabled],\ninput[type=\"submit\"][disabled] {\n  cursor: not-allowed;\n  opacity: .5;\n  // background: rgba(197, 197, 197, 1);\n  // box-shadow: 0 3px 6px rgba(197, 197, 197, .36);\n}\n\n// button.spaced {\n//   margin: 2px;\n// }\n\n// button:not([disabled]):hover, input[type=\"submit\"]:not([disabled]):hover {\n//   transform: scale(1.1);\n// }\n// button:not([disabled]):active, input[type=\"submit\"]:not([disabled]):active {\n//   transform: scale(0.95);\n// }\n\nbutton.primary {\n  padding: 8px 12px;\n  background: #f7861c;\n  box-shadow: 0 3px 6px rgba(247, 134, 28, .36);\n  color: $white;\n  font-size: 1.1em;\n  font-family: Roboto;\n  text-transform: uppercase;\n}\n\n.btn-light {\n  padding: 8px 12px;\n  // background: #FFFFFF; // $bg-white\n  box-shadow: 0 3px 6px rgba(247, 134, 28, .36);\n  color: #585d67; // TODO: make reusable light button color\n  font-size: 1.1em;\n  font-family: Roboto;\n  text-transform: uppercase;\n  text-align: center;\n  line-height: 20px;\n  border-radius: 2px;\n  border: 1px solid #979797; // #TODO: make reusable light border color\n  opacity: .5;\n}\n\n// TODO: cleanup: not used anywhere\nbutton.btn-thin {\n  border: 1px solid;\n  border-color: #4d4d4d;\n  color: #4d4d4d;\n  background: rgb(255, 174, 41);\n  border-radius: 4px;\n  min-width: 200px;\n  margin: 12px 0;\n  padding: 6px;\n  font-size: 13px;\n}\n\n.btn-secondary {\n  border: 1px solid #979797;\n  border-radius: 2px;\n  background-color: $white;\n  font-size: 16px;\n  line-height: 24px;\n  padding: 16px 42px;\n\n  &[disabled] {\n    background-color: $white !important;\n    opacity: .5;\n  }\n}\n\n.btn-tertiary {\n  border: 1px solid transparent;\n  border-radius: 2px;\n  background-color: transparent;\n  font-size: 16px;\n  line-height: 24px;\n  padding: 16px 42px;\n}\n",".app-header {\n  align-items: center;\n  visibility: visible;\n  background: $gallery;\n  position: relative;\n  z-index: $header-z-index;\n  display: flex;\n  flex-flow: column nowrap;\n\n  @media screen and (max-width: 575px) {\n    padding: 12px;\n    width: 100%;\n    box-shadow: 0 0 0 1px rgba(0, 0, 0, .08);\n    z-index: $mobile-header-z-index;\n  }\n\n  @media screen and (min-width: 576px) {\n    height: 75px;\n    justify-content: center;\n\n    &::after {\n      content: '';\n      position: absolute;\n      width: 100%;\n      height: 32px;\n      background: $gallery;\n      bottom: -32px;\n    }\n  }\n\n  .metafox-icon {\n    cursor: pointer;\n  }\n}\n\n.app-header-contents {\n  display: flex;\n  justify-content: space-between;\n  flex-flow: row nowrap;\n  width: 100%;\n  height: 6.9vh;\n\n  @media screen and (max-width: 575px) {\n    height: 100%;\n  }\n\n  @media screen and (min-width: 576px) {\n    width: 85vw;\n  }\n\n  @media screen and (min-width: 769px) {\n    width: 80vw;\n  }\n\n  @media screen and (min-width: 1281px) {\n    width: 65vw;\n  }\n}\n\n.app-header h1 {\n  font-family: Roboto;\n  text-transform: uppercase;\n  font-weight: 400;\n  color: #22232c; // $shark\n  line-height: 29px;\n\n  @media screen and (max-width: 575px) {\n    display: none;\n  }\n}\n\nh2.page-subtitle {\n  text-transform: uppercase;\n  color: #aeaeae;\n  font-size: 1em;\n  margin: 12px;\n}\n\n.network-component-wrapper {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n}\n\n.left-menu-wrapper {\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  cursor: pointer;\n}\n\n.header__right-actions {\n  display: flex;\n  flex-flow: row nowrap;\n  align-items: center;\n\n  .identicon {\n    cursor: pointer;\n  }\n}\n",".app-footer {\n  padding-bottom: 10px;\n  align-items: center;\n}\n",".network-component--disabled {\n  // border-color: transparent !important;\n  cursor: default;\n\n  .fa-caret-down {\n    opacity: 0;\n  }\n}\n\n.network-component.pointer {\n  border: 1px solid $shark;\n  border-radius: 82px;\n  padding: 6px;\n  flex: 0 0 auto;\n\n  &.ethereum-network {\n    border-color: rgb(3, 135, 137);\n\n    .menu-icon-circle div {\n      background-color: rgba(3, 135, 137, .7) !important;\n    }\n  }\n\n  &.ropsten-test-network {\n    border-color: rgb(233, 21, 80);\n\n    .menu-icon-circle div {\n      background-color: rgba(233, 21, 80, .7) !important;\n    }\n  }\n\n  &.kovan-test-network {\n    border-color: rgb(105, 4, 150);\n\n    .menu-icon-circle div {\n      background-color: rgba(105, 4, 150, .7) !important;\n    }\n  }\n\n  &.rinkeby-test-network {\n    border-color: rgb(235, 179, 63);\n\n    .menu-icon-circle div {\n      background-color: rgba(235, 179, 63, .7) !important;\n    }\n  }\n}\n\n.dropdown-menu-item {\n  .menu-icon-circle,\n  .menu-icon-circle--active {\n    margin: 0 14px;\n  }\n}\n\n.network-indicator {\n  display: flex;\n  align-items: center;\n  font-size: .6em;\n\n  .fa-caret-down {\n    line-height: 15px;\n    font-size: 12px;\n    padding: 0 4px;\n  }\n}\n\n.network-name {\n  line-height: 15px;\n  padding: 0 4px;\n  font-family: Roboto;\n  font-size: 12px;\n  flex: 1 0 auto;\n}\n\n.network-droppo {\n  right: 2px;\n\n  @media screen and (min-width: 576px) {\n    right: calc(((100% - 85vw) / 2) + 2px);\n  }\n\n  @media screen and (min-width: 769px) {\n    right: calc(((100% - 80vw) / 2) + 2px);\n  }\n\n  @media screen and (min-width: 1281px) {\n    right: calc(((100% - 65vw) / 2) + 2px);\n  }\n}\n\n.network-name-item {\n  font-weight: 100;\n  flex: 1 0 auto;\n  color: $dusty-gray;\n}\n\n.network-check,\n.network-check__transparent {\n  color: $white;\n  margin-left: 7px;\n}\n\n.network-check__transparent {\n  opacity: 0;\n  width: 16px;\n  margin: 0;\n}\n\n.menu-icon-circle,\n.menu-icon-circle--active {\n  background: none;\n  border-radius: 22px;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  border: 1px solid transparent;\n  margin: 0 4px;\n}\n\n.menu-icon-circle--active {\n  border: 1px solid $white;\n  background: rgba(100, 100, 100, .4);\n}\n\n.menu-icon-circle div,\n.menu-icon-circle--active div {\n  height: 12px;\n  width: 12px;\n  border-radius: 17px;\n}\n\n.menu-icon-circle--active div {\n  opacity: 1;\n}\n\n.network-dropdown-header {\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  width: 100%;\n}\n\n.network-dropdown-divider {\n  width: 100%;\n  height: 1px;\n  margin: 10px 0;\n  background-color: $scorpion;\n}\n\n.network-dropdown-title {\n  height: 25px;\n  width: 75px;\n  color: $white;\n  font-family: Roboto;\n  font-size: 18px;\n  line-height: 25px;\n  text-align: center;\n}\n\n.network-dropdown-content {\n  height: 36px;\n  width: 265px;\n  color: $dusty-gray;\n  font-family: Roboto;\n  font-size: 14px;\n  line-height: 18px;\n}\n\n",".modal > div:focus {\n  outline: none !important;\n}\n\n// Buy Modal\n.buy-modal-content {\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n  text-align: center;\n  font-family: Roboto;\n  padding: 0 16px;\n}\n\n.buy-modal-content-option {\n  cursor: pointer;\n  color: #5B5D67;\n}\n\n.qr-ellip-address, .ellip-address {\n  width: 247px;\n  border: none;\n  font-family: Roboto;\n  font-size: 14px;\n}\n\n@media screen and (max-width: 575px) {\n  .buy-modal-content-title-wrapper {\n    justify-content: space-around;\n    width: 100%;\n    height: 100px;\n  }\n\n  .buy-modal-content-title {\n    font-size: 26px;\n    margin-top: 15px;\n  }\n\n  .buy-modal-content-options {\n    flex-direction: column;\n    padding: 5% 33%;\n  }\n\n  .buy-modal-content-footer {\n    text-transform: uppercase;\n    width: 100%;\n    height: 50px;\n  }\n\n  div.buy-modal-content-option {\n    display: flex;\n    flex-direction: column;\n    width: 80vw;\n    height: 15vh;\n    margin: 10px;\n    text-align: center;\n    border-radius: 6px;\n    border: 1px solid $black;\n    padding: 0% 7%;\n    justify-content: center;\n\n    div.buy-modal-content-option-title {\n      font-size: 20px;\n    }\n\n    div.buy-modal-content-option-subtitle {\n      font-size: 16px;\n    }\n  }\n}\n\n@media screen and (min-width: 576px) {\n  .buy-modal-content-title-wrapper {\n    justify-content: space-around;\n    width: 100%;\n    height: 110px;\n  }\n\n  .buy-modal-content-title {\n    font-size: 26px;\n    margin-top: 15px;\n  }\n\n  .buy-modal-content-footer {\n    text-transform: uppercase;\n    width: 100%;\n    height: 50px;\n  }\n\n  .buy-modal-content-options {\n    flex-direction: row;\n    margin: 20px 0 60px;\n  }\n\n  div.buy-modal-content-option {\n    display: flex;\n    flex-direction: column;\n    width: 20vw;\n    height: 120px;\n    text-align: center;\n    border-radius: 6px;\n    border: 1px solid $black;\n    margin: 0 8px;\n    padding: 18px 0;\n\n    div.buy-modal-content-option-title {\n      font-size: 20px;\n      margin-bottom: 12px;\n\n      @media screen and (max-width: 679px) {\n        font-size: 14px;\n      }\n\n      @media screen and (min-width: 1281px) {\n        font-size: 20px;\n      }\n    }\n\n    div.buy-modal-content-option-subtitle {\n      font-size: 16px;\n      padding: 0 10px;\n      height: 25%;\n\n      @media screen and (max-width: 679px) {\n        font-size: 10px;\n        padding: 0 10px;\n        margin-bottom: 5px;\n        line-height: 15px;\n      }\n\n      @media screen and (min-width: 680px) {\n        font-size: 14px;\n        padding: 0 4px;\n        margin-bottom: 2px;\n      }\n\n      @media screen and (min-width: 1281px) {\n        font-size: 16px;\n        padding: 0;\n      }\n    }\n\n    div.buy-modal-content-footer {\n      margin-top: 8vh;\n    }\n  }\n}\n\n// Edit Account Name Modal\n.edit-account-name-modal-content {\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-start;\n  align-items: center;\n  position: relative;\n}\n\n.edit-account-name-modal-cancel {\n  position: absolute;\n  top: 12px;\n  right: 20px;\n  font-size: 25px;\n}\n\n.edit-account-name-modal-title {\n  margin: 15px;\n}\n\n.edit-account-name-modal-save-button {\n  width: 33%;\n  height: 45px;\n  margin: 15px;\n  font-weight: 700;\n  margin-top: 25px;\n}\n\n.edit-account-name-modal-input {\n  width: 90%;\n  height: 50px;\n  text-align: left;\n  margin: 10px;\n  padding: 10px;\n  font-size: 18px;\n}\n\n// Account Modal Container\n.account-modal-container {\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-start;\n  align-items: center;\n  position: relative;\n  padding: 5px 0 31px 0;\n  border: 1px solid $silver;\n  border-radius: 4px;\n  font-family: Roboto;\n\n  button {\n    cursor: pointer;\n  }\n}\n\n.account-modal-back {\n  color: $dusty-gray;\n  position: absolute;\n  top: 13px;\n  left: 17px;\n  cursor: pointer;\n\n  &__text {\n    margin-top: 2px;\n    font-family: Roboto;\n    font-size: 14px;\n    line-height: 18px;\n  }\n}\n\n.account-modal-close::after {\n  content: '\\00D7';\n  font-size: 40px;\n  color: $dusty-gray;\n  position: absolute;\n  top: 10px;\n  right: 12px;\n  cursor: pointer;\n}\n\n.account-modal-container .identicon {\n  position: relative;\n  left: 0;\n  right: 0;\n  margin: 0 auto;\n  top: -32px;\n  margin-bottom: -32px;\n}\n\n\n// Account Details Modal\n\n.account-modal-container {\n\n  .qr-header {\n    margin-top: 9px;\n    font-size: 20px;\n  }\n\n  .qr-wrapper {\n    margin-top: 5px;\n  }\n\n  .ellip-address-wrapper {\n    display: flex;\n    justify-content: center;\n    border: 1px solid $alto;\n    padding: 5px 10px;\n    font-family: Roboto;\n    margin-top: 7px;\n    width: 286px;\n  }\n\n  .btn-clear {\n    min-height: 28px;\n    font-size: 14px;\n    border-color: $curious-blue;\n    color: $curious-blue;\n    border-radius: 2px;\n    flex-basis: 100%;\n    width: 75%;\n    margin-top: 17px;\n    padding: 10px 22px;\n    height: 44px;\n    width: 235px;\n    font-family: Roboto;\n  }\n}\n\n.account-modal-divider {\n  width: 100%;\n  height: 1px;\n  margin: 19px 0 8px 0;\n  background-color: $alto;\n}\n\n// Export Private Key Modal\n\n.account-modal-container .account-name {\n  margin-top: 9px;\n  font-size: 20px;\n}\n\n.account-modal-container .modal-body-title {\n  margin-top: 16px;\n  margin-bottom: 16px;\n  font-size: 18px;\n}\n\n.account-modal__name {\n  margin-top: 9px;\n  font-size: 20px;\n}\n\n.private-key-password {\n  display: flex;\n  flex-direction: column;\n}\n\n.private-key-password-label, .private-key-password-error {\n  color: $scorpion;\n  font-size: 14px;\n  line-height: 18px;\n  margin-bottom: 10px;\n}\n\n.private-key-password-error {\n  color: $crimson;\n  margin-bottom: 0;\n}\n\n.private-key-password-input {\n  padding: 10px 0 13px 17px;\n  font-size: 16px;\n  line-height: 21px;\n  width: 291px;\n  height: 44px;\n}\n\n.private-key-password::-webkit-input-placeholder {\n  color: $dusty-gray;\n  font-family: Roboto;\n}\n\n.private-key-password-warning {\n  border-radius: 8px;\n  background-color: #FFF6F6;\n  font-size: 12px;\n  font-weight: 500;\n  line-height: 15px;\n  color: $crimson;\n  width: 292px;\n  padding: 9px 15px;\n  margin-top: 18px;\n  font-family: Roboto;\n}\n\n.export-private-key-buttons {\n  display: flex;\n  flex-direction: row;\n  justify-content: center;\n\n  .btn-clear {\n    width: 141px;\n    height: 54px;\n  }\n\n  .btn-cancel {\n    margin-right: 15px;\n    border-color: $dusty-gray;\n    color: $scorpion;\n  }\n}\n\n.private-key-password-display-wrapper {\n  height: 80px;\n  width: 291px;\n  border: 1px solid $silver;\n  border-radius: 2px;\n}\n\n.private-key-password-display-textarea {\n  color: $crimson;\n  font-family: Roboto;\n  font-size: 16px;\n  line-height: 21px;\n  border: none;\n  height: 75px;\n  width: 100%;\n  overflow: hidden;\n  resize: none;\n  padding: 9px 13px 8px;\n  text-transform: uppercase;\n  font-weight: 300;\n}\n\n\n// New Account Modal\n.new-account-modal-wrapper {\n  display: flex;\n  flex-direction: column;\n  justify-content: flex-start;\n  align-items: center;\n  position: relative;\n  border: 1px solid $alto;\n  box-shadow: 0 0 2px 2px $alto;\n  font-family: Roboto;\n}\n\n.new-account-modal-header {\n  background: $wild-sand;\n  width: 100%;\n  display: flex;\n  justify-content: center;\n  padding: 30px;\n  font-size: 22px;\n  color: $nile-blue;\n  height: 79px;\n}\n\n.modal-close-x::after {\n  content: '\\00D7';\n  font-size: 2em;\n  color: $dusty-gray;\n  position: absolute;\n  top: 25px;\n  right: 17.5px;\n  font-family: sans-serif;\n  cursor: pointer;\n}\n\n.new-account-modal-content {\n  width: 100%;\n  display: flex;\n  justify-content: center;\n  margin-top: 15px;\n  font-size: 17px;\n  color: $nile-blue;\n}\n\n.new-account-modal-content.after-input {\n  margin-top: 15px;\n  line-height: 25px;\n}\n\n.new-account-input-wrapper {\n  display: flex;\n  width: 100%;\n  justify-content: center;\n  padding-bottom: 2px;\n  margin-top: 13px;\n}\n\n.new-account-input {\n  padding: 15px;\n  padding-bottom: 20px;\n  border-radius: 8px;\n  border: 1px solid $alto;\n  width: 100%;\n  font-size: 1em;\n  color: $dusty-gray;\n  font-family: Roboto;\n  font-size: 17px;\n  margin: 0 60px;\n}\n\n// For reference on below placeholder selectors: https://stackoverflow.com/questions/2610497/change-an-html5-inputs-placeholder-color-with-css\n.new-account-input::-webkit-input-placeholder {\n  color: $dusty-gray;\n}\n\n.new-account-input:-moz-placeholder {\n  color: $dusty-gray;\n  opacity: 1;\n}\n\n.new-account-input::-moz-placeholder {\n  color: $dusty-gray;\n  opacity: 1;\n}\n\n.new-account-input:-ms-input-placeholder {\n  color: $dusty-gray;\n}\n\n.new-account-input::-ms-input-placeholder {\n  color: $dusty-gray;\n}\n\n.new-account-modal-content.button {\n  margin-top: 22px;\n  margin-bottom: 30px;\n  width: 113px;\n  height: 44px;\n}\n\n.new-account-modal-wrapper .btn-clear {\n  font-size: 14px;\n  font-weight: 700;\n  background: $white;\n  border: 1px solid;\n  border-radius: 2px;\n  color: $tundora;\n  flex: 1;\n}\n\n// Hide token confirmation\n\n.hide-token-confirmation {\n  min-height: 250.72px;\n  width: 374.49px;\n  border-radius: 4px;\n  background-color: #FFFFFF;\n  box-shadow: 0 1px 7px 0 rgba(0,0,0,0.5);\n\n  &__container {\n    padding: 24px 27px 21px;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n  }\n\n  &__identicon {\n    margin-bottom: 10px\n  }\n\n  &__symbol {\n    color: $tundora;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 24px;\n    text-align: center;\n    margin-bottom: 7.5px;\n  }\n\n  &__title {\n    height: 30px;\n    width: 271.28px;\n    color: $tundora;\n    font-family: Roboto;\n    font-size: 22px;\n    line-height: 30px;\n    text-align: center;\n    margin-bottom: 10.5px;\n  }\n\n  &__copy {\n    height: 41px;\n    width: 318px;\n    color: $scorpion;\n    font-family: Roboto;\n    font-size: 14px;\n    line-height: 18px;\n    text-align: center;\n  }\n\n  &__buttons {\n    display: flex;\n    flex-direction: row;\n    justify-content: center;\n    margin-top: 15px;\n    width: 100%;\n\n    button {\n      height: 44px;\n      width: 113px;\n      border: 1px solid $scorpion;\n      border-radius: 2px;\n      color: $tundora;\n      font-family: Roboto;\n      font-size: 14px;\n      line-height: 20px;\n      text-align: center;\n      margin-left: 4px;\n      margin-right: 4px;\n    }\n  }\n}\n","/*\n  NewUI Container Elements\n */\n\n// Component Colors\n$tx-view-bg: $white;\n$wallet-view-bg: $wild-sand;\n\n// Main container\n.main-container {\n  // position: absolute;\n  z-index: $main-container-z-index;\n  font-family: Roboto;\n  display: flex;\n  flex-wrap: wrap;\n  align-items: stretch;\n}\n\n.main-container::-webkit-scrollbar {\n  display: none;\n}\n\n// tx view\n\n.tx-view {\n  flex: 63.5 0 66.5%;\n  background: $tx-view-bg;\n\n  // No title on mobile\n  @media screen and (max-width: 575px) {\n    .identicon-wrapper {\n      display: none;\n    }\n\n    .account-name {\n      display: none;\n    }\n  }\n}\n\n// wallet view and sidebar\n\n.wallet-view {\n  display: flex;\n  flex-direction: column;\n  flex: 33.5 1 33.5%;\n  width: 0;\n  background: $wallet-view-bg;\n  z-index: 200;\n  position: relative;\n\n  @media screen and (min-width: 576px) {\n    overflow-y: scroll;\n    overflow-x: hidden;\n  }\n\n  .wallet-view-account-details {\n    flex: 0 0 auto;\n  }\n\n  &__name-container {\n    flex: 0 0 auto;\n    cursor: pointer;\n    width: 100%;\n  }\n\n  &__keyring-label {\n    height: 40px;\n    color: $dusty-gray;\n    font-family: Roboto;\n    font-size: 10px;\n    line-height: 40px;\n    text-align: right;\n    padding: 0 20px;\n  }\n\n  &__details-button {\n    color: $curious-blue;\n    font-size: 10px;\n    line-height: 13px;\n    text-align: center;\n    border: 1px solid $curious-blue;\n    border-radius: 10.5px;\n    background-color: transparent;\n    margin: 0 auto;\n    padding: 4px 12px;\n    flex: 0 0 auto;\n  }\n\n  &__address {\n    border-radius: 3px;\n    background-color: $alto;\n    color: $scorpion;\n    font-size: 14px;\n    line-height: 12px;\n    padding: 4px 12px;\n    margin: 24px auto;\n    font-weight: 300;\n    cursor: pointer;\n    flex: 0 0 auto;\n  }\n\n  &__sidebar-close {\n\n    @media screen and (max-width: 575px) {\n      &::after {\n        content: '\\00D7';\n        font-size: 40px;\n        color: $tundora;\n        position: absolute;\n        top: 12px;\n        left: 12px;\n        cursor: pointer;\n      }\n    }\n  }\n\n  &__add-token-button {\n    flex: 0 0 auto;\n    color: $dusty-gray;\n    font-size: 14px;\n    line-height: 19px;\n    text-align: center;\n    margin: 36px auto;\n    border: 1px solid $dusty-gray;\n    border-radius: 2px;\n    font-weight: 300;\n    background: none;\n    padding: 9px 30px;\n  }\n}\n\n@media screen and (min-width: 576px) {\n  .wallet-view::-webkit-scrollbar {\n    display: none;\n  }\n}\n\n.wallet-view-title-wrapper {\n  flex: 0 0 25px;\n}\n\n.wallet-view-title {\n  margin-left: 15px;\n  font-size: 16px;\n\n  // No title on mobile\n  @media screen and (max-width: 575px) {\n    display: none;\n  }\n}\n\n.wallet-view.sidebar {\n  flex: 1 0 230px;\n  background: rgb(250, 250, 250);\n  z-index: $sidebar-z-index;\n  position: fixed;\n  top: 56px;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  opacity: 1;\n  visibility: visible;\n  will-change: transform;\n  overflow-y: auto;\n  box-shadow: rgba(0, 0, 0, .15) 2px 2px 4px;\n  width: 85%;\n  height: calc(100% - 56px);\n}\n\n.sidebar-overlay {\n  z-index: $sidebar-overlay-z-index;\n  position: fixed;\n  // top: 41px;\n  height: 100%;\n  width: 100%;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  opacity: 1;\n  visibility: visible;\n  background-color: rgba(0, 0, 0, .3);\n}\n\n// main-container media queries\n\n@media screen and (min-width: 576px) {\n  .lap-visible {\n    display: flex;\n  }\n\n  .phone-visible {\n    display: none;\n  }\n\n  .main-container {\n    // margin-top: 6.9vh;\n    width: 85%;\n    height: 90vh;\n    box-shadow: 0 0 7px 0 rgba(0, 0, 0, .08);\n  }\n}\n\n@media screen and (min-width: 769px) {\n  .main-container {\n    // margin-top: 6.9vh;\n    width: 80%;\n    height: 82vh;\n    box-shadow: 0 0 7px 0 rgba(0, 0, 0, .08);\n  }\n}\n\n@media screen and (min-width: 1281px) {\n  .main-container {\n    // margin-top: 6.9vh;\n    width: 65%;\n    height: 82vh;\n    box-shadow: 0 0 7px 0 rgba(0, 0, 0, .08);\n  }\n}\n\n@media screen and (max-width: 575px) {\n  .lap-visible {\n    display: none;\n  }\n\n  .phone-visible {\n    display: flex;\n  }\n\n  .main-container {\n    // margin-top: 41px;\n    height: 100%;\n    width: 100%;\n    overflow-y: auto;\n    background-color: $white;\n  }\n\n  button.btn-clear {\n    width: 93px;\n    height: 50px;\n    font-size: .7em;\n    background: $white;\n    border: 1px solid;\n  }\n}\n\n// wallet view\n.account-name {\n  font-size: 24px;\n  font-weight: 200;\n  line-height: 20px;\n  color: $scorpion;\n  margin-top: 8px;\n  margin-bottom: 24px;\n  white-space: nowrap;\n  text-overflow: ellipsis;\n  overflow: hidden;\n  width: 100%;\n  padding: 0 8px;\n  text-align: center;\n}\n\n// account options dropdown\n.account-options-menu {\n  align-items: center;\n  justify-content: flex-start;\n  margin: 5% 7% 0%;\n}\n\n.fiat-amount {\n  text-transform: uppercase;\n}\n\n.token-balance__amount {\n  padding-right: 6px;\n}\n",".account-dropdown-name {\n  font-family: Roboto;\n}\n\n.account-dropdown-balance {\n  color: $dusty-gray;\n  line-height: 19px;\n}\n\n.account-dropdown-edit-button {\n  color: $dusty-gray;\n  font-family: Roboto;\n\n  &:hover {\n    color: $white;\n  }\n}\n\n.account-list-item {\n  &__top-row {\n    display: flex;\n    margin-top: 10px;\n    margin-left: 8px;\n    position: relative;\n  }\n\n  &__account-balances {\n    height: auto;\n    border: none;\n    background-color: transparent;\n    color: #9b9b9b;\n    margin-left: 34px;\n    margin-top: 4px;\n    position: relative;\n  }\n  \n  &__account-name {\n    font-size: 16px;\n    margin-left: 8px;\n  }\n\n  &__icon {\n    position: absolute;\n    right: 12px;\n    top: 1px;\n  }\n\n  &__account-primary-balance,\n  &__account-secondary-balance {\n    font-family: Roboto;\n    line-height: 16px;\n    font-size: 12px;\n    font-weight: 300;\n  }\n\n  &__account-primary-balance {\n    color: $scorpion;\n    border: none;\n    outline: 0 !important;\n  }\n\n  &__account-secondary-balance {\n    color: $dusty-gray;\n  }\n\n  &__account-address {\n    margin-left: 35px;\n    width: 80%;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n\n  &__dropdown {\n    &:hover {\n      background: rgba($alto, .2);\n      cursor: pointer;\n\n      input {\n        background: rgba($alto, .1);\n      }\n    }\n  }\n}\n",".send-screen-wrapper {\n  display: flex;\n  flex-flow: column nowrap;\n  z-index: 25;\n  font-family: Roboto;\n\n  @media screen and (max-width: $break-small) {\n    width: 100%;\n    overflow-y: auto;\n  }\n\n  section {\n    flex: 0 0 auto;\n  }\n}\n\n.send-screen-card {\n  background-color: #fff;\n  box-shadow: 0 2px 4px 0 rgba(0, 0, 0, .08);\n  padding: 46px 40.5px 26px;\n  position: relative;\n  // top: -26px;\n  align-items: center;\n  display: flex;\n  flex-flow: column nowrap;\n  width: 498px;\n  flex: 1 0 auto;\n\n  @media screen and (max-width: $break-small) {\n    top: 0;\n    width: 100%;\n    box-shadow: none;\n    padding: 12px;\n  }\n}\n\n/* Send Screen */\n\n.send-screen section {\n  margin: 4px 16px;\n}\n\n.send-screen input {\n  width: 100%;\n  font-size: 12px;\n}\n\n.send-eth-icon {\n  border-radius: 50%;\n  width: 70px;\n  height: 70px;\n  border: 1px solid $alto;\n  box-shadow: 0 0 4px 0 rgba(0, 0, 0, .2);\n  position: absolute;\n  top: -35px;\n  z-index: 25;\n  padding: 4px;\n  background-color: $white;\n\n  @media screen and (max-width: $break-small) {\n    position: relative;\n    top: 0;\n  }\n}\n\n.send-screen-input-wrapper {\n  width: 95%;\n  position: relative;\n\n  .fa-bolt {\n    padding-right: 4px;\n  }\n\n  .large-input {\n    border: 1px solid $dusty-gray;\n    border-radius: 4px;\n    margin: 4px 0 20px;\n    font-size: 16px;\n    line-height: 22.4px;\n    font-family: Roboto;\n  }\n\n  .send-screen-gas-input {\n    border: 1px solid transparent;\n  }\n\n  &__error-message {\n    display: none;\n  }\n\n  &--error {\n    input,\n    .send-screen-gas-input {\n      border-color: $red !important;\n    }\n\n    .send-screen-input-wrapper__error-message {\n      display: block;\n      position: absolute;\n      bottom: 4px;\n      font-size: 12px;\n      line-height: 12px;\n      left: 8px;\n      color: $red;\n    }\n  }\n\n  .send-screen-input-wrapper__error-message {\n    display: block;\n    position: absolute;\n    bottom: 4px;\n    font-size: 12px;\n    line-height: 12px;\n    left: 8px;\n    color: $red;\n  }\n}\n\n.send-screen-input {\n  width: 100%;\n}\n\n.send-screen-gas-input {\n  width: 100%;\n  height: 41px;\n  border-radius: 3px;\n  background-color: #f3f3f3;\n  border-width: 0;\n  border-style: none;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  padding-left: 10px;\n  padding-right: 12px;\n  font-size: 16px;\n  color: $scorpion;\n}\n\n.send-screen-amount-labels {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n}\n\n.send-screen-gas-labels {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n}\n\n.currency-toggle {\n  &__item {\n    color: $curious-blue;\n    cursor: pointer;\n\n    &--selected {\n      color: $black;\n      cursor: default;\n    }\n  }\n}\n\n.send-screen-gas-input-customize {\n  color: $curious-blue;\n  font-size: 12px;\n  cursor: pointer;\n}\n\n.gas-tooltip-close-area {\n  position: fixed;\n  top: 0;\n  left: 0;\n  z-index: 1000;\n  width: 100%;\n  height: 100%;\n}\n\n.customize-gas-tooltip-container {\n  position: absolute;\n  bottom: 50px;\n  width: 237px;\n  height: 307px;\n  background-color: $white;\n  opacity: 1;\n  box-shadow: $alto 0 0 5px;\n  z-index: 1050;\n  padding: 13px 19px;\n  font-size: 16px;\n  border-radius: 4px;\n  font-family: \"Lato\";\n  font-weight: 500;\n}\n\n.gas-tooltip-arrow {\n  height: 25px;\n  width: 25px;\n  z-index: 1200;\n  background: $white;\n  position: absolute;\n  transform: rotate(45deg);\n  left: 107px;\n  top: 294px;\n  box-shadow: 2px 2px 2px $alto;\n}\n\n.customize-gas-tooltip-container input[type=\"number\"]::-webkit-inner-spin-button {\n  -webkit-appearance: none;\n  display: none;\n}\n\n.customize-gas-tooltip-container input[type=\"number\"]:hover::-webkit-inner-spin-button {\n  -webkit-appearance: none;\n  display: none;\n}\n\n.customize-gas-tooltip {\n  position: relative;\n}\n\n.gas-tooltip {\n  display: flex;\n  justify-content: center;\n}\n\n.gas-tooltip-label {\n  font-size: 16px;\n  color: $tundora;\n}\n\n.gas-tooltip-header {\n  padding-bottom: 12px;\n}\n\n.gas-tooltip-input-label {\n  margin-bottom: 5px;\n}\n\n.gas-tooltip-input-label i {\n  color: $silver-chalice;\n  margin-left: 6px;\n}\n\n.customize-gas-input {\n  width: 178px;\n  height: 28px;\n  border: 1px solid $alto;\n  font-size: 16px;\n  color: $nile-blue;\n  padding-left: 8px;\n}\n\n.customize-gas-input-wrapper {\n  position: relative;\n}\n\n.gas-tooltip-input-detail {\n  position: absolute;\n  top: 4px;\n  right: 26px;\n  font-size: 12px;\n  color: $silver-chalice;\n}\n\n.gas-tooltip-input-arrows {\n  position: absolute;\n  top: 0;\n  right: 4px;\n  width: 17px;\n  height: 28px;\n  border: 1px solid #dadada;\n  border-left: 0;\n  display: flex;\n  flex-direction: column;\n  color: #9b9b9b;\n  font-size: .8em;\n  padding: 1px 4px;\n  cursor: pointer;\n}\n\n.token-gas {\n  &__amount {\n    display: inline-block;\n    margin-right: 4px;\n  }\n\n  &__symbol {\n    display: inline-block;\n  }\n}\n\n.send-screen {\n  &__title {\n    color: $scorpion;\n    font-size: 18px;\n    line-height: 29px;\n  }\n\n  &__subtitle {\n    margin: 10px 0 20px;\n    font-size: 14px;\n    line-height: 24px;\n  }\n\n  &__send-button,\n  &__cancel-button {\n    width: 163px;\n    text-align: center;\n  }\n\n  &__send-button__disabled {\n    opacity: .5;\n    cursor: auto;\n  }\n}\n\n.send-token {\n  display: flex;\n  flex-flow: column nowrap;\n  z-index: 25;\n  font-family: Roboto;\n\n  &__content {\n    width: 498px;\n    height: 605px;\n    background-color: #fff;\n    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, .08);\n    padding: 46px 40.5px 26px;\n    position: relative;\n    // top: -26px;\n    align-items: center;\n    display: flex;\n    flex-flow: column nowrap;\n    flex: 1 0 auto;\n\n    @media screen and (max-width: $break-small) {\n      top: 0;\n      width: 100%;\n      box-shadow: none;\n      padding: 12px;\n    }\n  }\n\n  .identicon {\n    position: absolute;\n    top: -35px;\n    z-index: 25;\n\n    @media screen and (max-width: $break-small) {\n      position: relative;\n      top: 0;\n      flex: 0 0 auto;\n    }\n  }\n\n  &__title {\n    color: $scorpion;\n    font-size: 18px;\n    line-height: 29px;\n  }\n\n  &__description,\n  &__balance-text,\n  &__token-symbol {\n    margin-top: 10px;\n    font-size: 14px;\n    line-height: 24px;\n    text-align: center;\n  }\n\n  &__token-balance {\n    font-size: 40px;\n    line-height: 40px;\n    margin-top: 13px;\n\n    .token-balance__amount {\n      padding-right: 12px;\n    }\n  }\n\n  &__button-group {\n    display: flex;\n    flex-flow: column nowrap;\n    align-items: center;\n    flex: 0 0 auto;\n\n    @media screen and (max-width: $break-small) {\n      margin-top: 24px;\n    }\n\n    button {\n      width: 163px;\n    }\n  }\n}\n\n.confirm-send-token {\n  &__hero-amount-wrapper {\n    width: 100%;\n  }\n}\n\n.send-v2 {\n  &__container {\n    // height: 701px;\n    width: 380px;\n    border-radius: 8px;\n    background-color: $white;\n    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, .08);\n    display: flex;\n    flex-flow: column nowrap;\n    z-index: 25;\n    align-items: center;\n    font-family: Roboto;\n    position: relative;\n\n    @media screen and (max-width: $break-small) {\n      width: 100%;\n      top: 0;\n      box-shadow: none;\n      flex: 1 1 auto;\n    }\n  }\n\n  &__send-header-icon-container {\n    z-index: 25;\n\n    @media screen and (max-width: $break-small) {\n      position: relative;\n      top: 0;\n    }\n  }\n\n  &__send-header-icon {\n    border-radius: 50%;\n    width: 48px;\n    height: 48px;\n    border: 1px solid $alto;\n    z-index: 25;\n    padding: 4px;\n    background-color: $white;\n  }\n\n  &__send-arrow-icon {\n    color: #f28930;\n    transform: rotate(-45deg);\n    position: absolute;\n    top: -2px;\n    left: 0;\n    font-size: 1.12em;\n  }\n\n  &__arrow-background {\n    background-color: $white;\n    height: 14px;\n    width: 14px;\n    position: absolute;\n    top: 52px;\n    left: 199px;\n    border-radius: 50%;\n    z-index: 100;\n\n    @media screen and (max-width: $break-small) {\n      top: 36px;\n    }\n  }\n\n  &__header {\n    height: 88px;\n    width: 380px;\n    background-color: $athens-grey;\n    position: relative;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n\n    @media screen and (max-width: $break-small) {\n      height: 59px;\n      width: 100vw;\n    }\n  }\n\n  &__header-tip {\n    height: 25px;\n    width: 25px;\n    background: $athens-grey;\n    position: absolute;\n    transform: rotate(45deg);\n    left: 178px;\n    top: 75px;\n\n    @media screen and (max-width: $break-small) {\n      top: 46px;\n      left: 0;\n      right: 0;\n      margin: 0 auto;\n    }\n  }\n\n  &__title {\n    color: $scorpion;\n    font-size: 22px;\n    line-height: 29px;\n    text-align: center;\n    margin-top: 25px;\n  }\n\n  &__copy {\n    color: $gray;\n    font-size: 14px;\n    font-weight: 300;\n    line-height: 19px;\n    text-align: center;\n    margin-top: 10px;\n    width: 287px;\n  }\n\n  &__error {\n    font-size: 12px;\n    line-height: 12px;\n    left: 8px;\n    color: $red;\n  }\n\n  &__error-border {\n    color: $red;\n  }\n\n  &__form {\n    margin: 13px 0;\n    width: 100%;\n\n    @media screen and (max-width: $break-small) {\n      padding: 13px 0;\n      margin: 0;\n      height: 0;\n      overflow-y: auto;\n      flex: 1 1 auto;\n    }\n  }\n\n  &__form-header,\n  &__form-header-copy {\n    width: 100%;\n    display: flex;\n    flex-flow: column;\n    align-items: center;\n  }\n\n  &__form-row {\n    margin: 14.5px 18px 0px;\n    position: relative;\n    display: flex;\n    flex-flow: row;\n    flex: 1 0 auto;\n    justify-content: space-between;\n  }\n\n  &__form-field {\n    flex: 1 1 auto;\n  }\n\n  &__form-label {\n    color: $scorpion;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 22px;\n    width: 88px;\n  }\n\n  &__from-dropdown {\n    height: 73px;\n    width: 100%;\n    border: 1px solid $alto;\n    border-radius: 4px;\n    background-color: $white;\n    font-family: Roboto;\n    line-height: 16px;\n    font-size: 12px;\n    color: $tundora;\n    position: relative;\n\n    &__close-area {\n      position: fixed;\n      top: 0;\n      left: 0;\n      z-index: 1000;\n      width: 100%;\n      height: 100%;\n    }\n    \n    &__list {\n      z-index: 1050;\n      position: absolute;\n      height: 220px;\n      width: 100%;\n      border: 1px solid $geyser;\n      border-radius: 4px;\n      background-color: $white;\n      box-shadow: 0 3px 6px 0 rgba(0 ,0 ,0 ,.11);\n      margin-top: 11px;\n      margin-left: -1px;\n      overflow-y: scroll;\n    }\n  }\n\n  &__to-autocomplete {\n    position: relative;\n\n    &__down-caret {\n      position: absolute;\n      top: 18px;\n      right: 12px;\n    }\n  }\n\n  &__to-autocomplete, &__memo-text-area {\n    &__input {\n      height: 54px;\n      width: 100%;\n      border: 1px solid $alto;\n      border-radius: 4px;\n      background-color: $white;\n      color: $dusty-gray;\n      padding: 10px;\n      font-family: Roboto;\n      font-size: 16px;\n      line-height: 21px;\n      font-weight: 300;\n    }\n  }\n\n  &__amount-max {\n    color: $curious-blue;\n    font-family: Roboto;\n    font-size: 12px;\n    left: 8px;\n    border: none;\n    cursor: pointer;\n  }\n\n  &__gas-fee-display {\n    width: 100%;\n  }\n\n  &__sliders-icon-container {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    height: 24px;\n    width: 24px;\n    border: 1px solid $curious-blue;\n    border-radius: 4px;\n    background-color: $white;\n    padding: 5px;\n    position: absolute;\n    right: 15px;\n    top: 14px;\n    cursor: pointer;\n  }\n\n  &__sliders-icon {\n    color: $curious-blue;\n  }\n\n  &__memo-text-area {\n    &__input {\n      padding: 6px 10px;\n    }\n  }\n\n  &__footer {\n    height: 92px;\n    width: 100%;\n    display: flex;\n    justify-content: space-evenly;\n    align-items: center;\n    border-top: 1px solid $alto;\n    background: $white;\n    padding: 0 12px;\n  }\n\n  &__next-btn,\n  &__cancel-btn,\n  &__next-btn__disabled {\n    width: 163px;\n    text-align: center;\n    height: 55px;\n    border-radius: 2px;\n    background-color: $white;\n    font-family: Roboto;\n    font-size: 16px;\n    font-weight: 300;\n    line-height: 21px;\n    border: 1px solid;\n    margin: 0 4px;\n  }\n\n  &__next-btn,\n  &__next-btn__disabled {\n    color: $curious-blue;\n    border-color: $curious-blue;\n  }\n\n  &__next-btn__disabled {\n    opacity: .5;\n    cursor: auto;\n  }\n\n  &__cancel-btn {\n    color: $dusty-gray;\n    border-color: $dusty-gray;\n  }\n\n  &__customize-gas {\n    border: 1px solid #D8D8D8;\n    border-radius: 4px;\n    background-color: #FFFFFF;\n    box-shadow: 0 2px 4px 0 rgba(0,0,0,0.14);\n    font-family: Roboto;\n    display: flex;\n    flex-flow: column;\n\n    @media screen and (max-width: $break-small) {\n      width: 100vw;\n      height: 100vh;\n    }\n\n    &__header {\n      height: 52px;\n      border-bottom: 1px solid $alto;\n      display: flex;\n      align-items: center;\n      justify-content: space-between;\n      font-size: 22px;\n\n      @media screen and (max-width: $break-small) {\n        flex: 0 0 auto;\n      }\n    }\n\n    &__title {\n      margin-left: 19.25px;\n    }\n\n    &__close::after {\n      content: '\\00D7';\n      font-size: 1.8em;\n      color: $dusty-gray;\n      font-family: sans-serif;\n      cursor: pointer;\n      margin-right: 19.25px;\n    }\n\n    &__content {\n      display: flex;\n      flex-flow: column nowrap;\n      height: 100%;\n    }\n\n    &__body {\n      display: flex;\n      margin-bottom: 24px;\n\n      @media screen and (max-width: $break-small) {\n        flex-flow: column;\n        flex: 1 1 auto;\n      }\n    }\n\n    &__footer {\n      height: 75px;\n      border-top: 1px solid $alto;\n      display: flex;\n      align-items: center;\n      justify-content: space-between;\n      font-size: 22px;\n      position: relative;\n\n      @media screen and (max-width: $break-small) {\n        flex: 0 0 auto;\n      }\n    }\n\n    &__buttons {\n      display: flex;\n      justify-content: space-between;\n      width: 181.75px;\n      margin-right: 21.25px;\n    }\n\n    &__revert, &__cancel, &__save, &__save__error {\n      display: flex;\n      justify-content: center;\n      align-items: center;\n      cursor: pointer;\n    }\n\n    &__revert {\n      color: $silver-chalice;\n      font-size: 16px;\n      margin-left: 21.25px;\n    }\n\n    &__cancel, &__save, &__save__error {\n      height: 34.64px;\n      width: 85.74px;\n      border: 1px solid $dusty-gray;\n      border-radius: 2px;\n      font-family: 'DIN OT';\n      font-size: 12px;\n      color: $dusty-gray;\n    }\n\n    &__save__error {\n      opacity: 0.5;\n      cursor: auto;\n    }\n\n    &__error-message {\n      display: block;\n      position: absolute;\n      top: 4px;\n      right: 4px;\n      font-size: 12px;\n      line-height: 12px;\n      color: $red;\n    }\n  }\n\n  &__gas-modal-card {\n    width: 360px;\n    display: flex;\n    flex-flow: column;\n    align-items: flex-start;\n    padding-left: 20px;\n\n    &__title {\n      height: 26px;\n      color: $tundora;\n      font-family: Roboto;\n      font-size: 20px;\n      font-weight: 300;\n      line-height: 26px;\n      margin-top: 17px;\n    }\n\n    &__copy {\n      height: 38px;\n      width: 314px;\n      color: $tundora;\n      font-family: Roboto;\n      font-size: 14px;\n      line-height: 19px;\n      margin-top: 17px;\n    }\n\n    .customize-gas-input-wrapper {\n      margin-top: 17px;\n    }\n\n    .customize-gas-input {\n      height: 54px;\n      width: 315px;\n      border: 1px solid $geyser;\n      background-color: $white;\n      padding-left: 15px;\n    }\n\n    .gas-tooltip-input-arrows {\n      width: 32px;\n      height: 54px;\n      border-left: 1px solid #dadada;\n      font-size: 18px;\n      color: $tundora;\n      right: 0px;\n      padding: 1px 4px;\n      display: flex;\n      justify-content: space-around;\n      align-items: center;\n    }\n\n    input[type=\"number\"]::-webkit-inner-spin-button {\n      -webkit-appearance: none;\n      display: none;\n    }\n\n    input[type=\"number\"]:hover::-webkit-inner-spin-button {\n      -webkit-appearance: none;\n      display: none;\n    }\n  }\n}\n",".confirm-screen-container {\n  position: relative;\n  align-items: center;\n  font-family: Roboto;\n  flex: 0 0 auto;\n  flex-flow: column nowrap;\n  box-shadow: 0 2px 4px 0 rgba($black, .08);\n  border-radius: 8px;\n\n  @media screen and (max-width: 575px) {\n    width: 100%;\n  }\n\n  @media screen and (min-width: 576px) {\n    // top: -26px;\n  }\n}\n\n.notification {\n  .confirm-screen-wrapper {\n\n    @media screen and (max-width: $break-small) {\n      height: calc(100vh - 85px);\n    }\n  }\n}\n\n.confirm-screen-wrapper {\n  height: 100%;\n  width: 380px;\n  background-color: $white;\n  display: flex;\n  flex-flow: column nowrap;\n  z-index: 25;\n  align-items: center;\n  font-family: Roboto;\n  position: relative;\n  overflow-y: auto;\n  overflow-x: hidden;\n  border-top-left-radius: 8px;\n  border-top-right-radius: 8px;\n\n  @media screen and (max-width: $break-small) {\n    width: 100%;\n    overflow-x: hidden;\n    overflow-y: auto;\n    top: 0;\n    box-shadow: none;\n    height: calc(100vh - 58px - 85px);\n    border-top-left-radius: 0;\n    border-top-right-radius: 0;\n  }\n}\n\n.confirm-screen-wrapper > .confirm-screen-total-box {\n  margin-left: 10px;\n  margin-right: 10px;\n}\n\n.confirm-screen-wrapper > .confirm-memo-wrapper {\n  margin: 0;\n}\n\n.confirm-screen-header {\n  height: 88px;\n  background-color: $athens-grey;\n  position: relative;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  font-size: 22px;\n  line-height: 29px;\n  width: 100%;\n  padding: 25px 0;\n  flex: 0 0 auto;\n\n  @media screen and (max-width: $break-small) {\n    font-size: 20px;\n  }\n}\n\n.confirm-screen-header-tip {\n  height: 25px;\n  width: 25px;\n  background: $athens-grey;\n  position: absolute;\n  transform: rotate(45deg);\n  top: 71px;\n  left: 0;\n  right: 0;\n  margin: 0 auto;\n}\n\n.confirm-screen-title {\n  line-height: 27px;\n\n  @media screen and (max-width: $break-small) {\n    margin-left: 22px;\n    margin-right: 8px;\n  }\n}\n\n.confirm-screen-back-button {\n  background: transparent;\n  border: 1px solid $curious-blue;\n  left: 24px;\n  position: absolute;\n  text-align: center;\n  color: $curious-blue;\n  padding: 6px 13px 7px 12px;\n  border-radius: 2px;\n  height: 30px;\n  width: 54px;\n\n  @media screen and (max-width: $break-small) {\n    margin-right: 12px;\n  }\n}\n\n.confirm-screen-account-wrapper {\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n}\n\n.confirm-screen-account-name {\n  margin-top: 12px;\n  font-size: 14px;\n  line-height: 19px;\n  color: $scorpion;\n  text-align: center;\n}\n\n.confirm-screen-row-info {\n  font-size: 16px;\n  line-height: 21px;\n}\n\n.confirm-screen-account-number {\n  font-size: 10px;\n  line-height: 16px;\n  color: $dusty-gray;\n  text-align: center;\n  height: 16px;\n}\n\n.confirm-send-ether,\n.confirm-send-token {\n  i.fa-arrow-right {\n    align-self: start;\n    margin: 24px 14px 0 !important;\n  }\n}\n\n.confirm-screen-identicons {\n  margin-top: 24px;\n  flex: 0 0 auto;\n\n  i.fa-arrow-right {\n    align-self: start;\n    margin: 42px 14px 0;\n  }\n\n  i.fa-file-text-o {\n    font-size: 60px;\n    margin: 16px 8px 0 8px;\n    text-align: center;\n  }\n}\n\n.confirm-screen-sending-to-message {\n  text-align: center;\n  font-size: 16px;\n  margin-top: 30px;\n  font-family: 'DIN NEXT Light';\n}\n\n.confirm-screen-send-amount {\n  color: $scorpion;\n  margin-top: 12px;\n  text-align: center;\n  font-size: 40px;\n  font-weight: 300;\n  line-height: 53px;\n  flex: 0 0 auto;\n}\n\n.confirm-screen-send-amount-currency {\n  font-size: 20px;\n  line-height: 20px;\n  text-align: center;\n  flex: 0 0 auto;\n}\n\n.confirm-memo-wrapper {\n  min-height: 24px;\n  width: 100%;\n  border-bottom: 1px solid $alto;\n  flex: 0 0 auto;\n}\n\n.confirm-screen-send-memo {\n  color: $scorpion;\n  font-size: 16px;\n  line-height: 19px;\n  font-weight: 400;\n}\n\n.confirm-screen-label {\n  font-size: 18px;\n  line-height: 40px;\n  color: $scorpion;\n  text-align: left;\n}\n\nsection .confirm-screen-account-name,\nsection .confirm-screen-account-number,\n.confirm-screen-row-info,\n.confirm-screen-row-detail {\n  text-align: left;\n}\n\n.confirm-screen-rows {\n  display: flex;\n  flex-flow: column nowrap;\n  width: 100%;\n  flex: 0 0 auto;\n}\n\n.confirm-screen-section-column {\n  flex: .5;\n}\n\n.confirm-screen-row {\n  display: flex;\n  flex-flow: row nowrap;\n  border-bottom: 1px solid $alto;\n  width: 100%;\n  align-items: center;\n  padding: 12px;\n  padding-left: 35px;\n  font-size: 16px;\n  line-height: 22px;\n  font-weight: 300;\n}\n\n.confirm-screen-row-detail {\n  font-size: 12px;\n  line-height: 16px;\n  color: $dusty-gray;\n}\n\n.confirm-screen-total-box {\n  background-color: $wild-sand;\n  padding: 20px;\n  padding-left: 35px;\n  border-bottom: 1px solid $alto;\n\n  .confirm-screen-label {\n    line-height: 18px;\n  }\n\n  .confirm-screen-row-detail {\n    color: $scorpion;\n  }\n\n  &__subtitle {\n    font-size: 12px;\n    line-height: 22px;\n  }\n\n  .confirm-screen-row-info {\n    font-size: 16px;\n    font-weight: 500;\n    line-height: 21px;\n  }\n}\n\n.confirm-screen-confirm-button {\n  height: 62px;\n  border-radius: 2px;\n  background-color: #02c9b1;\n  font-size: 16px;\n  color: $white;\n  text-align: center;\n  font-family: Roboto;\n  padding-top: 15px;\n  padding-bottom: 15px;\n  border-width: 0;\n  box-shadow: none;\n  flex: 1 0 auto;\n  font-weight: 300;\n  margin: 0 8px;\n}\n\n.btn-light.confirm-screen-cancel-button {\n  height: 62px;\n  background: none;\n  border: none;\n  opacity: 1;\n  font-family: Roboto;\n  border-width: 0;\n  padding-top: 15px;\n  padding-bottom: 15px;\n  font-size: 16px;\n  line-height: 32px;\n  box-shadow: none;\n  cursor: pointer;\n  flex: 1 0 auto;\n  font-weight: 300;\n  margin: 0 8px;\n}\n\n#pending-tx-form {\n  flex: 1 0 auto;\n  position: relative;\n  display: flex;\n  flex-flow: row nowrap;\n  background-color: $white;\n  padding: 12px 18px;\n  border-bottom-left-radius: 8px;\n  border-bottom-right-radius: 8px;\n  width: 100%;\n\n  @media screen and (max-width: $break-small) {\n    border-top: 1px solid $alto;\n    border-bottom-left-radius: 0;\n    border-bottom-right-radius: 0;\n  }\n}\n",".loading-overlay {\n  left: 0px;\n  z-index: 50;\n  position: absolute;\n  flex-direction: column;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  width: 100%;\n  background: rgba(255, 255, 255, 0.8);\n\n  @media screen and (max-width: 575px) {\n    margin-top: 56px;\n    height: calc(100% - 56px);\n  }\n\n  @media screen and (min-width: 576px) {\n    margin-top: 75px;\n    height: calc(100% - 75px);\n  }\n}\n",".hero-balance {\n\n  @media screen and (max-width: $break-small) {\n    display: flex;\n    flex-direction: column;\n    justify-content: flex-start;\n    align-items: center;\n    margin: .3em .9em 0;\n    // height: 80vh;\n    // max-height: 225px;\n    flex: 0 0 auto;\n  }\n\n  @media screen and (min-width: $break-large) {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-start;\n    align-items: center;\n    margin: 2.8em 2.37em .8em;\n  }\n\n  .balance-container {\n    display: flex;\n    margin: 0;\n    justify-content: flex-start;\n    align-items: center;\n\n    @media screen and (max-width: $break-small) {\n      flex-direction: column;\n      flex: 0 0 auto;\n    }\n\n    @media screen and (min-width: $break-large) {\n      flex-direction: row;\n      flex-grow: 3;\n    }\n  }\n\n  .balance-display {\n\n    @media screen and (max-width: $break-small) {\n      text-align: center;\n\n      .token-amount {\n        font-size: 175%;\n        margin-top: 12.5%;\n      }\n\n      .fiat-amount {\n        font-size: 115%;\n        margin-top: 8.5%;\n        color: #a0a0a0;\n      }\n    }\n\n    @media screen and (min-width: $break-large) {\n      margin-left: 3%;\n      justify-content: flex-start;\n      align-items: flex-start;\n\n      .token-amount {\n        font-size: 135%;\n      }\n\n      .fiat-amount {\n        margin-top: .25%;\n        font-size: 105%;\n      }\n    }\n  }\n\n  .balance-icon {\n    border-radius: 25px;\n    width: 45px;\n    height: 45px;\n    border: 1px solid $alto;\n  }\n\n  .hero-balance-buttons {\n\n    @media screen and (max-width: $break-small) {\n      width: 100%;\n      // height: 100px; // needed a round number to set the heights of the buttons inside\n      flex: 0 0 auto;\n      padding: 16px 0;\n    }\n\n    @media screen and (min-width: $break-large) {\n      flex-grow: 2;\n      justify-content: flex-end;\n    }\n\n    button.btn-clear {\n      background: $white;\n      border: 1px solid;\n      border-radius: 2px;\n      font-size: 12px;\n\n      @media screen and (max-width: $break-small) {\n        border-color: $curious-blue;\n        color: $curious-blue;\n        height: 36px;\n      }\n\n      @media screen and (min-width: $break-large) {\n        border-color: $curious-blue;\n        color: $curious-blue;\n        padding: 0;\n        width: 85px;\n        height: 34px;\n      }\n    }\n  }\n}\n","$wallet-balance-bg: #e7e7e7;\n$wallet-balance-breakpoint: 890px;\n$wallet-balance-breakpoint-range: \"screen and (min-width: #{$break-large}) and (max-width: #{$wallet-balance-breakpoint})\";\n\n.wallet-balance-wrapper {\n  flex: 0 0 auto;\n  transition: linear 200ms;\n  background: rgba($wallet-balance-bg, 0);\n\n  &--active {\n    background: rgba($wallet-balance-bg, 1);\n  }\n}\n\n.wallet-balance {\n  background: inherit;\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  flex: 0 0 auto;\n  cursor: pointer;\n  border-top: 1px solid $wallet-balance-bg;\n\n  .balance-container {\n    display: flex;\n    justify-content: flex-start;\n    align-items: center;\n    margin: 20px 24px;\n    flex-direction: row;\n    flex-grow: 3;\n\n    @media #{$wallet-balance-breakpoint-range} {\n      margin: 10% 4%;\n    }\n  }\n\n  .balance-display {\n    margin-left: 15px;\n    justify-content: flex-start;\n    align-items: flex-start;\n\n    .token-amount {\n      font-size: 135%;\n    }\n\n    .fiat-amount {\n      margin-top: .25%;\n      font-size: 105%;\n    }\n\n    @media #{$wallet-balance-breakpoint-range} {\n      margin-left: 4%;\n\n      .token-amount {\n        font-size: 105%;\n      }\n\n      .fiat-amount {\n        font-size: 95%;\n      }\n    }\n  }\n\n  .balance-icon {\n    border-radius: 25px;\n    width: 45px;\n    height: 45px;\n    border: 1px solid $alto;\n  }\n}\n",".tx-list-container {\n  height: 87.5%;\n\n  @media screen and (min-width: $break-large) {\n    overflow-y: scroll;\n  }\n}\n\n.tx-list-header {\n  text-transform: capitalize;\n}\n\n@media screen and (max-width: $break-small) {\n  .tx-list-header-wrapper {\n    margin-top: .2em;\n    margin-bottom: .6em;\n    // TODO: Resolve Layout Conflicst in Wallet View\n    //  - This fixes txlist \"transactions\" title dispay\n    // margin-top: 0.2em;\n    // margin-bottom: 0.6em;\n    justify-content: center;\n    flex: 0 0 auto;\n  }\n\n  .tx-list-header {\n    align-self: center;\n    font-size: 12px;\n    color: $dusty-gray;\n    font-family: Roboto;\n    text-transform: uppercase;\n  }\n}\n\n@media screen and (min-width: $break-large) {\n  .tx-list-header-wrapper {\n    flex: 0 0 55px;\n  }\n\n  .tx-list-header {\n    font-size: 16px;\n    margin: 1.5em 2.37em;\n  }\n\n  .tx-list-container::-webkit-scrollbar {\n    display: none;\n  }\n}\n\n.tx-list-content-divider {\n  height: 1px;\n  background: rgb(231, 231, 231);\n  flex: 0 0 1px;\n\n  @media screen and (max-width: $break-small) {\n    margin: .1em 0;\n  }\n\n  @media screen and (min-width: $break-large) {\n    margin: .1em 2.37em;\n  }\n}\n\n.tx-list-item-wrapper {\n  flex: 1 1 auto;\n  width: 0;\n  align-items: stretch;\n  justify-content: flex-start;\n  display: flex;\n  flex-flow: column nowrap;\n\n  @media screen and (max-width: $break-small) {\n    padding: 0 1.3em .8em;\n  }\n\n  @media screen and (min-width: $break-large) {\n    padding-bottom: 12px;\n  }\n}\n\n.tx-list-clickable {\n  cursor: pointer;\n\n  &:hover {\n    background: rgba($alto, .2);\n  }\n}\n\n.tx-list-pending-item-container {\n  cursor: pointer;\n  opacity: .5;\n}\n\n.tx-list-date-wrapper {\n  flex: 1 1 auto;\n\n  @media screen and (max-width: $break-small) {\n    margin-top: 6px;\n  }\n\n  @media screen and (min-width: $break-large) {\n    margin-top: 12px;\n  }\n}\n\n.tx-list-content-wrapper {\n  align-items: stretch;\n  margin-bottom: 4px;\n  margin-top: 2px;\n  flex: 1 0 auto;\n  width: 100%;\n  display: flex;\n  flex-flow: row nowrap;\n\n  @media screen and (max-width: $break-small) {\n    font-size: 12px;\n\n    .tx-list-status {\n      font-size: 14px !important;\n    }\n\n    .tx-list-account {\n      font-size: 14px !important;\n    }\n\n    .tx-list-value {\n      font-size: 14px;\n      line-height: 18px;\n    }\n\n    .tx-list-fiat-value {\n      font-size: 12px;\n      line-height: 16px;\n    }\n  }\n}\n\n.tx-list-date {\n  color: $dusty-gray;\n  font-size: 12px;\n  font-family: Roboto;\n}\n\n.tx-list-identicon-wrapper {\n  align-self: center;\n  flex: 0 0 auto;\n  margin-right: 16px;\n}\n\n.tx-list-account-and-status-wrapper {\n  display: flex;\n  flex: 1 1 auto;\n  flex-flow: row wrap;\n  width: 0;\n\n  @media screen and (max-width: $break-small) {\n    flex-direction: column;\n    justify-content: flex-start;\n    align-items: flex-start;\n    align-self: center;\n\n    .tx-list-account-wrapper {\n      height: 18px;\n\n      .tx-list-account {\n        line-height: 14px;\n      }\n    }\n  }\n\n  @media screen and (min-width: $break-large) {\n    flex-direction: row;\n    justify-content: flex-start;\n    align-items: center;\n\n    .tx-list-account-wrapper {\n      flex: 1.3 2 auto;\n      min-width: 153px;\n    }\n\n    .tx-list-status-wrapper {\n      flex: 6 6 auto;\n    }\n  }\n\n  .tx-list-account {\n    font-size: 16px;\n    color: $scorpion;\n  }\n\n  .tx-list-status {\n    color: $dusty-gray;\n    font-size: 16px;\n    text-transform: capitalize;\n  }\n\n  .tx-list-status--rejected,\n  .tx-list-status--failed {\n    color: $monzo;\n  }\n}\n\n.tx-list-item {\n  border-top: 1px solid rgb(231, 231, 231);\n  flex: 0 0 auto;\n  display: flex;\n  flex-flow: row nowrap;\n\n  @media screen and (max-width: $break-small) {\n    // margin: 0 1.3em .95em; !important\n  }\n\n  @media screen and (min-width: $break-large) {\n    margin: 0 2.37em;\n  }\n\n  &:last-of-type {\n    border-bottom: 1px solid rgb(231, 231, 231);\n    margin-bottom: 32px;\n  }\n\n  &__wrapper {\n    align-self: center;\n    flex: 2 2 auto;\n    color: $dusty-gray;\n\n    .tx-list-value {\n      font-size: 16px;\n      text-align: right;\n    }\n\n    .tx-list-value--confirmed {\n      color: $caribbean-green;\n    }\n\n    .tx-list-fiat-value {\n      font-size: 12px;\n      text-align: right;\n    }\n  }\n\n  &--empty {\n    text-align: center;\n    border-bottom: none !important;\n    padding: 16px;\n  }\n}\n\n.tx-list-details-wrapper {\n  overflow: hidden;\n  flex: 0 0 35%;\n}\n\n.tx-list-value {\n  font-size: 16px;\n  text-align: right;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n}\n\n.tx-list-fiat-value {\n  text-align: right;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n}\n\n.tx-list-value--confirmed {\n  color: $caribbean-green;\n}\n","// Old scss, do not lint - clean up later\n/* stylelint-disable */\n\n\n/*\nApp Sections\n  TODO: Move into separate files.\n*/\n\n/* initialize */\ntextarea.twelve-word-phrase {\n  padding: 12px;\n  width: 300px;\n  height: 140px;\n  font-size: 16px;\n  background: $white;\n  resize: none;\n}\n\n.initialize-screen hr {\n  width: 60px;\n  margin: 12px;\n  border-color: #f7861c;\n  border-style: solid;\n}\n\n.initialize-screen label {\n  margin-top: 20px;\n}\n\n.initialize-screen button.create-vault {\n  margin-top: 40px;\n}\n\n.initialize-screen .warning {\n  font-size: 14px;\n  margin: 0 16px;\n}\n\n/* unlock */\n.error {\n  // color: #e20202;\n  color: #f7861c;\n  margin-bottom: 9px;\n}\n\n.warning {\n  color: #ffae00;\n}\n\n.lock {\n  width: 50px;\n  height: 50px;\n}\n\n.lock.locked {\n  transform: scale(1.5);\n  opacity: 0;\n  transition: opacity 400ms ease-in, transform 400ms ease-in;\n}\n\n.lock.unlocked {\n  transform: scale(1);\n  opacity: 1;\n  transition: opacity 500ms ease-out, transform 500ms ease-out, background 200ms ease-in;\n}\n\n.lock.locked .lock-top {\n  transform: scaleX(1) translateX(0);\n  transition: transform 250ms ease-in;\n}\n\n.lock.unlocked .lock-top {\n  transform: scaleX(-1) translateX(-12px);\n  transition: transform 250ms ease-in;\n}\n\n.lock.unlocked:hover {\n  border-radius: 4px;\n  background: #e5e5e5;\n  border: 1px solid #b1b1b1;\n}\n\n.lock.unlocked:active {\n  background: #c3c3c3;\n}\n\n.section-title .fa-arrow-left {\n  margin: -2px 8px 0px -8px;\n}\n\n.unlock-screen #metamask-mascot-container {\n  margin-top: 24px;\n}\n\n.unlock-screen h1 {\n  margin-top: -28px;\n  margin-bottom: 42px;\n}\n\n.unlock-screen input[type=password] {\n  width: 260px;\n}\n\n.sizing-input {\n  font-size: 14px;\n  height: 30px;\n  padding-left: 5px;\n}\n\n.editable-label {\n  display: flex;\n}\n\n/* Webkit */\n\n.unlock-screen input::-webkit-input-placeholder {\n  text-align: center;\n  font-size: 1.2em;\n}\n\n/* Firefox 18- */\n\n.unlock-screen input:-moz-placeholder {\n  text-align: center;\n  font-size: 1.2em;\n}\n\n/* Firefox 19+ */\n\n.unlock-screen input::-moz-placeholder {\n  text-align: center;\n  font-size: 1.2em;\n}\n\n/* IE */\n\n.unlock-screen input:-ms-input-placeholder {\n  text-align: center;\n  font-size: 1.2em;\n}\n\n/* accounts */\n\n.accounts-section {\n  margin: 0 0px;\n}\n\n.accounts-section .horizontal-line {\n  margin: 0 18px;\n}\n\n.accounts-list-option {\n  height: 120px;\n}\n\n.accounts-list-option .identicon-wrapper {\n  width: 100px;\n}\n\n.unconftx-link {\n  margin-top: 24px;\n  cursor: pointer;\n}\n\n.unconftx-link .fa-arrow-right {\n  margin: 0 -8px 0px 8px;\n}\n\n/* identity panel */\n\n.identity-panel {\n  font-weight: 500;\n}\n\n.identity-panel .identicon-wrapper {\n  margin: 4px;\n  margin-top: 8px;\n  display: flex;\n  align-items: center;\n}\n\n.identity-panel .identicon-wrapper span {\n  margin: 0 auto;\n}\n\n.identity-panel .identity-data {\n  margin: 8px 8px 8px 18px;\n}\n\n.identity-panel i {\n  margin-top: 32px;\n  margin-right: 6px;\n  color: #b9b9b9;\n}\n\n.identity-panel .arrow-right {\n  padding-left: 18px;\n  width: 42px;\n  min-width: 18px;\n  height: 100%;\n}\n\n.identity-copy.flex-column {\n  flex: .25 0 auto;\n  justify-content: center;\n}\n\n/* accounts screen */\n\n.identity-section {\n}\n\n.identity-section .identity-panel {\n  background: #e9e9e9;\n  border-bottom: 1px solid #b1b1b1;\n  cursor: pointer;\n}\n\n.identity-section .identity-panel.selected {\n  background: $white;\n  color: #f3c83e;\n}\n\n.identity-section .identity-panel.selected .identicon {\n  border-color: $orange;\n}\n\n.identity-section .accounts-list-option:hover,\n.identity-section .accounts-list-option.selected {\n  background: $white;\n}\n\n/* account detail screen */\n\n.account-detail-section {\n  display: flex;\n  flex-wrap: wrap;\n  overflow-y: auto;\n  flex-direction: inherit;\n}\n\n.grow-tenx {\n  flex-grow: 10;\n}\n\n.name-label {\n}\n\n.unapproved-tx-icon {\n  height: 16px;\n  width: 16px;\n  background: rgb(47, 174, 244);\n  border-color: $silver-chalice;\n  border-radius: 13px;\n}\n\n.edit-text {\n  height: 100%;\n  visibility: hidden;\n}\n\n.editing-label {\n  display: flex;\n  justify-content: flex-start;\n  margin-left: 50px;\n  margin-bottom: 2px;\n  font-size: 11px;\n  text-rendering: geometricPrecision;\n  color: #f7861c;\n}\n\n.name-label:hover .edit-text {\n  visibility: visible;\n}\n/* tx confirm */\n\n.unconftx-section input[type=password] {\n  height: 22px;\n  padding: 2px;\n  margin: 12px;\n  margin-bottom: 24px;\n  border-radius: 4px;\n  border: 2px solid #f3c83e;\n  background: #faf6f0;\n}\n\n/* Ether Balance Widget */\n\n.ether-balance-amount {\n  color: #f7861c;\n}\n\n.ether-balance-label {\n  color: #aba9aa;\n}\n\n/* Info screen */\n.info-gray {\n  font-family: Roboto;\n  text-transform: uppercase;\n  color: $silver-chalice;\n}\n\n.icon-size {\n  width: 20px;\n}\n\n.info {\n  font-family: Roboto, Arial;\n  padding-bottom: 10px;\n  display: inline-block;\n  padding-left: 5px;\n}\n\n/* buy eth warning screen */\n.custom-radios {\n  justify-content: space-around;\n  align-items: center;\n}\n\n.custom-radio-selected {\n  width: 17px;\n  height: 17px;\n  border: solid;\n  border-style: double;\n  border-radius: 15px;\n  border-width: 5px;\n  background: rgba(247, 134, 28, 1);\n  border-color: #f7f7f7;\n}\n\n.custom-radio-inactive {\n  width: 14px;\n  height: 14px;\n  border: solid;\n  border-width: 1px;\n  border-radius: 24px;\n  border-color: $silver-chalice;\n}\n\n.radio-titles {\n  color: rgba(247, 134, 28, 1);\n}\n\n.eth-warning {\n  transition: opacity 400ms ease-in, transform 400ms ease-in;\n}\n\n.buy-subview {\n  transition: opacity 400ms ease-in, transform 400ms ease-in;\n}\n\n.input-container:hover .edit-text {\n  visibility: visible;\n}\n\n.buy-inputs {\n  font-family: Roboto;\n  font-size: 13px;\n  height: 20px;\n  background: transparent;\n  box-sizing: border-box;\n  border: solid;\n  border-color: transparent;\n  border-width: .5px;\n  border-radius: 2px;\n}\n\n.input-container:hover .buy-inputs {\n  box-sizing: inherit;\n  border: solid;\n  border-color: #f7861c;\n  border-width: .5px;\n  border-radius: 2px;\n}\n\n.buy-inputs:focus {\n  border: solid;\n  border-color: #f7861c;\n  border-width: .5px;\n  border-radius: 2px;\n}\n\n.activeForm {\n  background: #f7f7f7;\n  border: none;\n  border-radius: 8px 8px 0px 0px;\n  width: 50%;\n  text-align: center;\n  padding-bottom: 4px;\n}\n\n.inactiveForm {\n  border: none;\n  border-radius: 8px 8px 0px 0px;\n  width: 50%;\n  text-align: center;\n  padding-bottom: 4px;\n}\n\n.ex-coins {\n  font-family: Roboto;\n  text-transform: uppercase;\n  text-align: center;\n  font-size: 33px;\n  width: 118px;\n  height: 42px;\n  padding: 1px;\n  color: #4d4d4d;\n}\n\n.marketinfo {\n  font-family: Roboto;\n  color: $silver-chalice;\n  font-size: 15px;\n  line-height: 17px;\n}\n\n#fromCoin::-webkit-calendar-picker-indicator {\n  display: none;\n}\n\n#coinList {\n  width: 400px;\n  height: 500px;\n  overflow: scroll;\n}\n\n.icon-control .fa-refresh {\n  visibility: hidden;\n}\n\n.icon-control:hover .fa-refresh {\n  visibility: visible;\n}\n\n.icon-control:hover .fa-chevron-right {\n  visibility: hidden;\n}\n\n.inactive {\n  color: $silver-chalice;\n}\n\n.inactive button {\n  background: $silver-chalice;\n  color: $white;\n}\n\n.qr-ellip-address, .ellip-address {\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n.qr-header {\n  font-size: 25px;\n  margin-top: 40px;\n}\n\n.qr-message {\n  font-size: 12px;\n  color: #f7861c;\n}\n\ndiv.message-container > div:first-child {\n  margin-top: 18px;\n  font-size: 15px;\n  color: #4d4d4d;\n}\n\n.pop-hover:hover {\n  transform: scale(1.1);\n}\n\n/* stylelint-enable */\n","$wallet-balance-breakpoint: 890px;\n$wallet-balance-breakpoint-range: \"screen and (min-width: #{$break-large}) and (max-width: #{$wallet-balance-breakpoint})\";\n\n.token-list-item {\n  display: flex;\n  flex-flow: row nowrap;\n  align-items: center;\n  padding: 20px 24px;\n  cursor: pointer;\n  transition: linear 200ms;\n  background-color: rgba($wallet-balance-bg, 0);\n  position: relative;\n\n  &__token-balance {\n    font-size: 130%;\n\n    @media #{$wallet-balance-breakpoint-range} {\n      font-size: 105%;\n    }\n  }\n\n  &__fiat-amount {\n    margin-top: .25%;\n    font-size: 105%;\n    text-transform: uppercase;\n\n    @media #{$wallet-balance-breakpoint-range} {\n      font-size: 95%;\n    }\n  }\n\n  @media #{$wallet-balance-breakpoint-range} {\n    padding: 10% 4%;\n  }\n\n  &--active {\n    background-color: rgba($wallet-balance-bg, 1);\n  }\n\n  &__identicon {\n    margin-right: 15px;\n    border: '1px solid #dedede';\n\n    @media #{$wallet-balance-breakpoint-range} {\n      margin-right: 4%;\n    }\n  }\n\n  &__ellipsis {\n    // position: absolute;\n    // top: 20px;\n    // right: 24px;\n    line-height: 45px;\n  }\n\n  &__balance-wrapper {\n    flex: 1 1 auto;\n  }\n}\n\n.token-menu-dropdown {\n  height: 55px;\n  width: 191px;\n  border-radius: 4px;\n  background-color: rgba(0,0,0,0.82);\n  box-shadow: 0 2px 4px 0 rgba(0,0,0,0.5);\n  position: fixed;\n  margin-top: 20px;\n  margin-left: 105px;\n  z-index: 2000;\n\n  &__close-area {\n    position: fixed;\n    top: 0;\n    left: 0;\n    z-index: 2100;\n    width: 100%;\n    height: 100%;\n    cursor: default;\n  }\n\n  &__container {\n    padding: 16px 34px 32px;\n    z-index: 2200;\n    position: relative;\n  }\n\n  &__options {\n    display: flex;\n    flex-direction: column;\n    justify-content: center;\n  }\n\n  &__option {\n    color: $white;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 21px;\n    text-align: center;\n  }\n}",".add-token {\n  width: 498px;\n  display: flex;\n  flex-flow: column nowrap;\n  align-items: center;\n  position: relative;\n  z-index: 12;\n  font-family: 'DIN Next Light';\n\n  &__wrapper {\n    background-color: $white;\n    box-shadow: 0 2px 4px 0 rgba($black, .08);\n    display: flex;\n    flex-flow: column nowrap;\n    align-items: center;\n    flex: 0 0 auto;\n  }\n\n  &__title-container {\n    display: flex;\n    flex-flow: column nowrap;\n    align-items: center;\n    padding: 30px 60px 12px;\n    border-bottom: 1px solid $gallery;\n    flex: 0 0 auto;\n  }\n\n  &__title {\n    color: $scorpion;\n    font-size: 20px;\n    line-height: 26px;\n    text-align: center;\n    font-weight: 600;\n    margin-bottom: 12px;\n  }\n\n  &__description {\n    text-align: center;\n  }\n\n  &__description + &__description {\n    margin-top: 24px;\n  }\n\n  &__confirmation-description {\n    margin: 12px 0;\n  }\n\n  &__content-container {\n    width: 100%;\n    border-bottom: 1px solid $gallery;\n  }\n\n  &__input-container {\n    padding: 11px 0;\n    width: 263px;\n    margin: 0 auto;\n    position: relative;\n  }\n\n  &__search-input-error-message {\n    position: absolute;\n    bottom: -10px;\n    font-size: 12px;\n    width: 100%;\n    text-overflow: ellipsis;\n    overflow: hidden;\n    white-space: nowrap;\n    color: $red;\n  }\n\n  &__input {\n    width: 100%;\n    border: 2px solid $gallery;\n    border-radius: 4px;\n    padding: 5px 15px;\n    font-size: 14px;\n    line-height: 19px;\n\n    &::placeholder {\n      color: $silver;\n    }\n  }\n\n  &__footers {\n    width: 100%;\n  }\n\n  &__add-custom {\n    color: $scorpion;\n    font-size: 18px;\n    line-height: 24px;\n    text-align: center;\n    padding: 12px 0;\n    font-weight: 600;\n    cursor: pointer;\n\n    &:hover {\n      background-color: rgba(0, 0, 0, .05);\n    }\n\n    &:active {\n      background-color: rgba(0, 0, 0, .1);\n    }\n\n    .fa {\n      position: absolute;\n      right: 24px;\n      font-size: 24px;\n      line-height: 24px;\n    }\n  }\n\n  &__add-custom-form {\n    display: flex;\n    flex-flow: column nowrap;\n    margin: 8px 0 51px;\n  }\n\n  &__add-custom-field {\n    width: 290px;\n    margin: 0 auto;\n    position: relative;\n\n    &--error {\n      .add-token__add-custom-input {\n        border-color: $red;\n      }\n    }\n  }\n\n  &__add-custom-error-message {\n    position: absolute;\n    bottom: -21px;\n    font-size: 12px;\n    width: 100%;\n    text-overflow: ellipsis;\n    overflow: hidden;\n    white-space: nowrap;\n    color: $red;\n  }\n\n  &__add-custom-label {\n    font-size: 16px;\n    line-height: 21px;\n    margin-bottom: 8px;\n  }\n\n  &__add-custom-input {\n    width: 100%;\n    border: 1px solid $silver;\n    padding: 5px 15px;\n    font-size: 14px;\n    line-height: 19px;\n\n    &::placeholder {\n      color: $silver;\n    }\n  }\n\n  &__add-custom-field + &__add-custom-field {\n    margin-top: 21px;\n  }\n\n  &__buttons {\n    display: flex;\n    flex-flow: column nowrap;\n    margin: 30px 0 51px;\n    flex: 0 0 auto;\n  }\n\n  &__token-icons-container {\n    display: flex;\n    flex-flow: row wrap;\n  }\n\n  &__token-wrapper {\n    transition: 200ms ease-in-out;\n    display: flex;\n    flex-flow: row nowrap;\n    flex: 0 0 42.5%;\n    align-items: center;\n    padding: 12px;\n    margin: 2.5%;\n    box-sizing: border-box;\n    border-radius: 10px;\n    cursor: pointer;\n    border: 2px solid transparent;\n    position: relative;\n\n    &:hover {\n      border: 2px solid rgba($malibu-blue, .5);\n    }\n\n    &--selected {\n      border: 2px solid $malibu-blue !important;\n    }\n\n    &--disabled {\n      opacity: .4;\n      pointer-events: none;\n    }\n  }\n\n  &__token-data {\n    align-self: flex-start;\n  }\n\n  &__token-name {\n    font-size: 14px;\n    line-height: 19px;\n  }\n\n  &__token-symbol {\n    font-size: 22px;\n    line-height: 29px;\n    font-weight: 600;\n  }\n\n  &__token-icon {\n    width: 60px;\n    height: 60px;\n    background-repeat: no-repeat;\n    background-size: contain;\n    background-position: center;\n    border-radius: 50%;\n    background-color: $white;\n    box-shadow: 0 2px 4px 0 rgba($black, .24);\n    margin-right: 12px;\n    flex: 0 0 auto;\n  }\n\n  &__token-message {\n    position: absolute;\n    color: $caribbean-green;\n    font-size: 11px;\n    bottom: 0;\n    left: 85px;\n  }\n\n  &__confirmation-token-list {\n    display: flex;\n    flex-flow: column nowrap;\n\n    .token-balance {\n      display: flex;\n      flex-flow: row nowrap;\n      align-items: flex-start;\n\n      &__amount {\n        color: $scorpion;\n        font-size: 43px;\n        font-weight: 300;\n        line-height: 43px;\n        margin-right: 8px;\n      }\n\n      &__symbol {\n        color: $scorpion;\n        font-size: 16px;\n        line-height: 24px;\n      }\n    }\n  }\n\n  &__confirmation-title {\n    padding: 30px 120px 12px;\n\n    @media screen and (max-width: $break-small) {\n      padding: 20px 0;\n      width: 100%;\n    }\n  }\n\n  &__confirmation-content {\n    padding-bottom: 60px;\n  }\n\n  &__confirmation-token-list-item {\n    display: flex;\n    flex-flow: row nowrap;\n    margin: 0 auto;\n    align-items: center;\n  }\n\n  &__confirmation-token-list-item + &__confirmation-token-list-item {\n    margin-top: 30px;\n  }\n\n  &__confirmation-token-icon {\n    margin-right: 18px;\n  }\n\n  @media screen and (max-width: $break-small) {\n    top: 0;\n    width: 100%;\n    overflow: hidden;\n    height: 100%;\n\n    &__wrapper {\n      box-shadow: none !important;\n      flex: 1 1 auto;\n      width: 100%;\n      overflow-y: auto;\n    }\n\n    &__footers {\n      border-bottom: 1px solid $gallery;\n    }\n\n    &__token-icon {\n      width: 50px;\n      height: 50px;\n    }\n\n    &__token-symbol {\n      font-size: 18px;\n      line-height: 24px;\n    }\n\n    &__token-name {\n      font-size: 12px;\n      line-height: 16px;\n    }\n\n    &__buttons {\n      flex-flow: row nowrap;\n      width: 100%;\n      align-items: center;\n      justify-content: center;\n      padding: 12px 0;\n      margin: 0;\n      border-top: 1px solid $gallery;\n\n      button {\n        flex: 1 0 auto;\n        margin: 0 12px;\n      }\n    }\n  }\n}\n",".currency-display {\n  height: 54px;\n  width: 100%ß;\n  border: 1px solid $alto;\n  border-radius: 4px;\n  background-color: $white;\n  color: $dusty-gray;\n  font-family: Roboto;\n  font-size: 16px;\n  font-weight: 300;\n  padding: 8px 10px;\n  position: relative;\n\n  &__primary-row {\n    display: flex;\n  }\n\n  &__input {\n    color: $scorpion;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 22px;\n    border: none;\n    outline: 0 !important;\n    max-width: 100%;\n  }\n\n  &__primary-currency {\n    color: $scorpion;\n    font-weight: 400;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 22px;\n  }\n\n  &__converted-row {\n    display: flex;\n  }\n\n  &__converted-value,\n  &__converted-currency {\n    color: $dusty-gray;\n    font-family: Roboto;\n    font-size: 12px;\n    line-height: 12px;\n  }\n\n  &__input-wrapper {\n    position: relative;\n    display: flex;\n  }\n\n  &__currency-symbol {\n    margin-top: 1px;\n  }\n}",".account-menu {\n  position: fixed;\n  z-index: 100;\n  top: 58px;\n  width: 310px;\n\n  @media screen and (max-width: 575px) {\n    right: calc(((100vw - 100%) / 2) + 8px);\n  }\n\n  @media screen and (min-width: 576px) {\n    right: calc((100vw - 85vw) / 2);\n  }\n\n  @media screen and (min-width: 769px) {\n    right: calc((100vw - 80vw) / 2);\n  }\n\n  @media screen and (min-width: 1281px) {\n    right: calc((100vw - 65vw) / 2);\n  }\n\n  &__icon {\n    margin-left: 20px;\n    cursor: pointer;\n  }\n\n  &__header {\n    display: flex;\n    flex-flow: row nowrap;\n    justify-content: space-between;\n    align-items: center;\n  }\n\n  &__logout-button {\n    border: 1px solid $dusty-gray;\n    background-color: transparent;\n    color: $white;\n    border-radius: 4px;\n    font-size: 12px;\n    line-height: 23px;\n    padding: 0 24px;\n    font-weight: 200;\n  }\n\n  img {\n    width: 16px;\n    height: 16px;\n  }\n\n  &__accounts {\n    display: flex;\n    flex-flow: column nowrap;\n    overflow-y: auto;\n    max-height: 240px;\n    position: relative;\n    z-index: 200;\n\n    &::-webkit-scrollbar {\n      display: none;\n    }\n\n    @media screen and (max-width: 575px) {\n      max-height: 215px;\n    }\n\n    .keyring-label {\n      margin-top: 5px;\n      background-color: $black;\n      color: $dusty-gray;\n    }\n  }\n\n  &__account {\n    display: flex;\n    flex-flow: row nowrap;\n    padding: 16px 14px;\n    flex: 0 0 auto;\n\n    @media screen and (max-width: 575px) {\n      padding: 12px 14px;\n    }\n  }\n\n  &__account-info {\n    flex: 1 0 auto;\n    display: flex;\n    flex-flow: column nowrap;\n    padding-top: 4px;\n  }\n\n  &__check-mark {\n    width: 14px;\n    margin-right: 12px;\n    flex: 0 0 auto;\n  }\n\n  &__check-mark-icon {\n    background-image: url(\"images/check-white.svg\");\n    height: 18px;\n    width: 18px;\n    background-repeat: no-repeat;\n    background-position: center;\n    background-size: contain;\n    margin: 3px 0;\n  }\n\n  .identicon {\n    margin: 0 12px 0 0;\n    flex: 0 0 auto;\n  }\n\n  &__name {\n    color: $white;\n    font-size: 18px;\n    font-weight: 200;\n    line-height: 16px;\n  }\n\n  &__balance {\n    color: $dusty-gray;\n    font-size: 14px;\n    line-height: 19px;\n  }\n\n  &__action {\n    font-size: 16px;\n    line-height: 18px;\n    font-weight: 200;\n    cursor: pointer;\n  }\n}\n",".menu {\n  border-radius: 4px;\n  background: rgba($black, .8);\n  box-shadow: rgba($black, .15) 0 2px 2px 2px;\n  min-width: 150px;\n  color: $white;\n\n  &__item {\n    padding: 18px;\n    display: flex;\n    flex-flow: row nowrap;\n    align-items: center;\n    position: relative;\n    z-index: 200;\n    font-weight: 200;\n\n    @media screen and (max-width: 575px) {\n      padding: 14px;\n    }\n\n    &--clickable {\n      cursor: pointer;\n\n      &:hover {\n        background-color: rgba($white, .05);\n      }\n\n      &:active {\n        background-color: rgba($white, .1);\n      }\n    }\n\n    &__icon {\n      height: 16px;\n      width: 16px;\n      margin-right: 14px;\n    }\n\n    &__text {\n      font-size: 16px;\n      line-height: 21px;\n    }\n  }\n\n  &__divider {\n    background-color: $scorpion;\n    width: 100%;\n    height: 1px;\n  }\n\n  &__close-area {\n    position: fixed;\n    width: 100%;\n    height: 100%;\n    top: 0;\n    left: 0;\n    z-index: 100;\n  }\n}\n",".gas-slider {\n  position: relative;\n  width: 313px;\n\n  &__input {\n    width: 317px;\n    margin-left: -2px;\n    z-index: 2;\n  }\n\n  input[type=range] {\n    -webkit-appearance: none !important;\n  }\n\n  input[type=range]::-webkit-slider-thumb {\n    -webkit-appearance: none !important;\n    height: 26px;\n    width: 26px;\n    border: 2px solid #B8B8B8;\n    background-color: #FFFFFF;\n    box-shadow: 0 2px 4px 0 rgba(0,0,0,0.08);\n    border-radius: 50%;\n    position: relative;\n    z-index: 10;\n  }\n\n  &__bar {\n    height: 6px;\n    width: 313px;\n    background: $alto;\n    display: flex;\n    justify-content: space-between;\n    position: absolute;\n    top: 11px;\n    z-index: 0;\n  }\n\n  &__low, &__high {\n    height: 6px;\n    width: 49px;\n    z-index: 1;\n  }\n\n  &__low {\n    background-color: $crimson;\n  }\n\n  &__high {\n    background-color: $caribbean-green;\n  }\n}",".settings {\n  position: relative;\n  background: $white;\n  display: flex;\n  flex-flow: column nowrap;\n  height: auto;\n  overflow: auto;\n}\n\n.settings__header {\n  padding: 25px;\n}\n\n.settings__close-button::after {\n  content: '\\00D7';\n  font-size: 40px;\n  color: $dusty-gray;\n  position: absolute;\n  top: 25px;\n  right: 30px;\n  cursor: pointer;\n}\n\n.settings__error {\n  padding-bottom: 20px;\n  text-align: center;\n  color: $crimson;\n}\n\n.settings__content {\n  padding: 0 25px;\n}\n\n.settings__content-row {\n  display: flex;\n  flex-direction: row;\n  padding: 10px 0 20px;\n\n  @media screen and (max-width: 575px) {\n    flex-direction: column;\n    padding: 10px 0;\n  }\n}\n\n.settings__content-item {\n  flex: 1;\n  min-width: 0;\n  display: flex;\n  flex-direction: column;\n  padding: 0 5px;\n  height: 71px;\n\n  @media screen and (max-width: 575px) {\n    height: initial;\n    padding: 5px 0;\n  }\n\n  &--without-height {\n    height: initial;\n  }\n}\n\n.settings__content-item-col {\n  max-width: 300px;\n  display: flex;\n  flex-direction: column;\n\n  @media screen and (max-width: 575px) {\n    max-width: 100%;\n    width: 100%;\n  }\n}\n\n.settings__content-description {\n  font-size: 14px;\n  color: $dusty-gray;\n  padding-top: 5px;\n}\n\n.settings__input {\n  padding-left: 10px;\n  font-size: 14px;\n  height: 40px;\n  border: 1px solid $alto;\n}\n\n.settings__input::-webkit-input-placeholder {\n  font-weight: 100;\n  color: $dusty-gray;\n}\n\n.settings__input::-moz-placeholder {\n  font-weight: 100;\n  color: $dusty-gray;\n}\n\n.settings__input:-ms-input-placeholder {\n  font-weight: 100;\n  color: $dusty-gray;\n}\n\n.settings__input:-moz-placeholder {\n  font-weight: 100;\n  color: $dusty-gray;\n}\n\n.settings__provider-wrapper {\n  font-size: 16px;\n  border: 1px solid $alto;\n  border-radius: 2px;\n  padding: 15px;\n  background-color: $white;\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n}\n\n.settings__provider-icon {\n  height: 10px;\n  width: 10px;\n  margin-right: 10px;\n  border-radius: 10px;\n}\n\n.settings__rpc-save-button {\n  align-self: flex-end;\n  padding: 5px;\n  text-transform: uppercase;\n  color: $dusty-gray;\n  cursor: pointer;\n}\n\n.settings__clear-button {\n  font-size: 16px;\n  border: 1px solid $curious-blue;\n  color: $curious-blue;\n  border-radius: 2px;\n  padding: 18px;\n  background-color: $white;\n  text-transform: uppercase;\n}\n\n.settings__clear-button--red {\n  border: 1px solid $monzo;\n  color: $monzo;\n}\n\n.settings__info-logo-wrapper {\n  height: 80px;\n  margin-bottom: 20px;\n}\n\n.settings__info-logo {\n  max-height: 100%;\n  max-width: 100%;\n}\n\n.settings__info-item {\n  padding: 10px 0;\n}\n\n.settings__info-link-header {\n  padding-bottom: 15px;\n\n  @media screen and (max-width: 575px) {\n    padding-bottom: 5px;\n  }\n}\n\n.settings__info-link-item {\n  padding: 15px 0;\n\n  @media screen and (max-width: 575px) {\n    padding: 5px 0;\n  }\n}\n\n.settings__info-version-number {\n  padding-top: 5px;\n  font-size: 13px;\n  color: $dusty-gray;\n}\n\n.settings__info-about {\n  color: $dusty-gray;\n  margin-bottom: 15px;\n}\n\n.settings__info-link {\n  color: $curious-blue;\n}\n\n.settings__info-separator {\n  margin: 15px 0;\n  width: 80px;\n  border-color: $alto;\n  border: none;\n  height: 1px;\n  background-color: $alto;\n  color: $alto;\n}\n",".tab-bar {\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: flex-end;\n}\n\n.tab-bar__tab {\n  min-width: 0;\n  flex: 0 0 auto;\n  padding: 15px 25px;\n  border-bottom: 1px solid $alto;\n  box-sizing: border-box;\n  font-size: 18px;\n}\n\n.tab-bar__tab--active {\n  border-color: $black;\n}\n\n.tab-bar__grow-tab {\n  flex-grow: 1;\n}\n",".simple-dropdown {\n  height: 56px;\n  display: flex;\n  justify-content: flex-start;\n  align-items: center;\n  border: 1px solid $alto;\n  border-radius: 4px;\n  background-color: $white;\n  font-size: 16px;\n  color: #4d4d4d;\n  cursor: pointer;\n  position: relative;\n}\n\n.simple-dropdown__caret {\n  color: $silver;\n  padding: 0 10px;\n}\n\n.simple-dropdown__selected {\n  flex-grow: 1;\n  padding: 0 15px;\n}\n\n.simple-dropdown__options {\n  z-index: 1050;\n  position: absolute;\n  height: 220px;\n  width: 100%;\n  border: 1px solid #d2d8dd;\n  border-radius: 4px;\n  background-color: #fff;\n  -webkit-box-shadow: 0 3px 6px 0 rgba(0, 0, 0, .11);\n  box-shadow: 0 3px 6px 0 rgba(0, 0, 0, .11);\n  margin-top: 10px;\n  overflow-y: scroll;\n  left: 0;\n  top: 100%;\n}\n\n.simple-dropdown__option {\n  padding: 10px;\n\n  &:hover {\n    background-color: $gallery;\n  }\n}\n\n.simple-dropdown__option--selected {\n  background-color: $alto;\n\n  &:hover {\n    background-color: $alto;\n    cursor: default;\n  }\n}\n\n.simple-dropdown__close-area {\n  position: fixed;\n  top: 0;\n  left: 0;\n  z-index: 1000;\n  width: 100%;\n  height: 100%;\n}\n",".request-signature {\n  &__container {\n    width: 380px;\n    border-radius: 8px;\n    background-color: $white;\n    box-shadow: 0 2px 4px 0 rgba(0,0,0,0.08);\n    display: flex;\n    flex-flow: column nowrap;\n    z-index: 25;\n    align-items: center;\n    font-family: Roboto;\n    position: relative;\n    height: 100%;\n\n    @media screen and (max-width: $break-small) {\n      width: 100%;\n      top: 0;\n      box-shadow: none;\n    }\n\n    @media screen and (min-width: $break-large) {\n      max-height: 620px;\n    }\n  }\n\n  &__header {\n    height: 64px;\n    width: 100%;\n    position: relative;\n    display: flex;\n    flex-flow: column;\n    justify-content: center;\n    align-items: center;\n    flex: 0 0 auto;\n  }\n\n  &__header-background {\n    position: absolute;\n    background-color: $athens-grey;\n    z-index: 2;\n    width: 100%;\n    height: 100%;\n  }\n\n  &__header__text {\n    height: 29px;\n    width: 179px;\n    color: #5B5D67;\n    font-family: Roboto;\n    font-size: 22px;\n    font-weight: 300;\n    line-height: 29px;\n    z-index: 3;\n  }\n\n  &__header__tip-container {\n    width: 100%;\n    display: flex;\n    justify-content: center;\n  }\n\n  &__header__tip {\n    height: 25px;\n    width: 25px;\n    background: $athens-grey;\n    transform: rotate(45deg);\n    position: absolute;\n    bottom: -8px;\n    z-index: 1;\n  }\n\n  &__account-info {\n    display: flex;\n    justify-content: space-between;\n    margin-top: 18px;\n    margin-bottom: 20px;\n  }\n\n  &__account {\n    color: $dusty-gray;\n    margin-left: 17px;\n  }\n\n  &__account-text {\n    font-size: 14px;\n  }\n\n  &__balance {\n    color: $dusty-gray;\n    margin-right: 17px;\n    width: 124px;\n  }\n\n  &__balance-text {\n    text-align: right;\n    font-size: 14px;\n  }\n\n  &__balance-value {\n    text-align: right;\n    margin-top: 2.5px;\n  }\n\n  &__request-icon {\n    margin-top: 25px;\n  }\n\n  &__body {\n    width: 100%;\n    height: 100%;\n    display: flex;\n    flex-flow: column;\n    flex: 1 1 auto;\n    height: 0;\n  }\n\n  &__request-info {\n    display: flex;\n    justify-content: center;\n  }\n\n  &__headline {\n    height: 48px;\n    width: 240px;\n    color: $tundora;\n    font-family: Roboto;\n    font-size: 18px;\n    font-weight: 300;\n    line-height: 24px;\n    text-align: center;\n    margin-top: 20px;\n  }\n\n  &__notice,\n  &__warning {\n    font-family: \"Avenir Next\";\n    font-size: 14px;\n    line-height: 19px;\n    text-align: center;\n    margin-top: 41px;\n    margin-bottom: 11px;\n    width: 100%;\n  }\n\n  &__notice {\n    color: $dusty-gray;\n  }\n\n  &__warning {\n    color: $crimson;\n  }\n\n  &__rows {\n    height: 100%;\n    overflow-y: scroll;\n    overflow-x: hidden;\n    border-top: 1px solid $geyser;\n    display: flex;\n    flex-flow: column;\n  }\n\n  &__row {\n    display: flex;\n    flex-flow: column;\n  }\n\n  &__row-title {\n    width: 80px;\n    color: $dusty-gray;\n    font-family: Roboto;\n    font-size: 16px;\n    line-height: 22px;\n    margin-top: 12px;\n    margin-left: 18px;\n    width: 100%;\n  }\n\n  &__row-value {\n    color: $scorpion;\n    font-family: Roboto;\n    font-size: 14px;\n    line-height: 19px;\n    width: 100%;\n    overflow-wrap: break-word;\n    border-bottom: 1px solid #d2d8dd;\n    padding: 6px 18px 15px;\n  }\n\n  &__footer {\n    width: 100%;\n    display: flex;\n    align-items: center;\n    justify-content: space-evenly;\n    font-size: 22px;\n    position: relative;\n    flex: 0 0 auto;\n    border-top: 1px solid $geyser;\n\n    &__cancel-button,\n    &__sign-button {\n      display: flex;\n      align-items: center;\n      justify-content: center;\n      flex: 1 0 auto;\n      font-family: Roboto;\n      font-size: 16px;\n      font-weight: 300;\n      height: 55px;\n      line-height: 32px;\n      cursor: pointer;\n      border-radius: 2px;\n      box-shadow: none;\n      max-width: 162px;\n      margin: 12px;\n    }\n\n    &__cancel-button {\n      background: none;\n      border: 1px solid $dusty-gray;\n      margin-right: 6px;\n    }\n\n    &__sign-button {\n      background-color: $caribbean-green;\n      border-width: 0;\n      color: $white;\n      margin-left: 6px;\n    }\n  }\n}",".account-dropdown-mini {\n  height: 22px;\n  background-color: $white;\n  font-family: Roboto;\n  line-height: 16px;\n  font-size: 12px;\n  width: 124px;\n\n  &__close-area {\n    position: fixed;\n    top: 0;\n    left: 0;\n    z-index: 1000;\n    width: 100%;\n    height: 100%;\n  }\n\n  &__list {\n    z-index: 1050;\n    position: absolute;\n    height: 180px;\n    width: 96pxpx;\n    border: 1px solid $geyser;\n    border-radius: 4px;\n    background-color: $white;\n    box-shadow: 0 3px 6px 0 rgba(0 ,0 ,0 ,.11);\n    overflow-y: scroll;\n  }\n\n  .account-list-item {\n    margin-top: 6px;\n  }\n\n  .account-list-item__account-name {\n    text-overflow: ellipsis;\n    overflow: hidden;\n    white-space: nowrap;\n    width: 80px;\n  }\n\n  .account-list-item__top-row {\n    margin: 0;\n  }\n\n  .account-list-item__icon {\n    position: initial;\n  }\n}",".editable-label {\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  position: relative;\n\n  &__value {\n    max-width: 250px;\n    overflow: hidden;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n  }\n\n  &__input {\n    width: 250px;\n    font-size: 14px;\n    text-align: center;\n    border: 1px solid $alto;\n\n    &--error {\n      border: 1px solid $monzo;\n    }\n  }\n\n  &__icon-wrapper {\n    position: absolute;\n    margin-left: 10px;\n    left: 100%;\n  }\n\n  &__icon {\n    cursor: pointer;\n    color: $dusty-gray;\n  }\n}\n","/*\n  Trumps\n */\n\n// Transitions\n\n/* universal */\n.app-primary .main-enter {\n  position: absolute;\n  width: 100%;\n}\n\n/* center position */\n.app-primary.from-right .main-enter-active,\n.app-primary.from-left .main-enter-active {\n  overflow-x: hidden;\n  transform: translateX(0);\n  transition: transform 300ms ease-in;\n}\n\n/* exited positions */\n.app-primary.from-left .main-leave-active {\n  transform: translateX(360px);\n  transition: transform 300ms ease-in;\n}\n\n.app-primary.from-right .main-leave-active {\n  transform: translateX(-360px);\n  transition: transform 300ms ease-in;\n}\n\n.sidebar.from-left {\n  transform: translateX(-320px);\n  transition: transform 300ms ease-in;\n}\n\n/* loader transitions */\n.loader-enter,\n.loader-leave-active {\n  opacity: 0;\n  transition: opacity 150 ease-in;\n}\n\n.loader-enter-active,\n.loader-leave {\n  opacity: 1;\n  transition: opacity 150 ease-in;\n}\n\n/* entering positions */\n.app-primary.from-right .main-enter:not(.main-enter-active) {\n  transform: translateX(360px);\n}\n\n.app-primary.from-left .main-enter:not(.main-enter-active) {\n  transform: translateX(-360px);\n}\n\ni.fa.fa-question-circle.fa-lg.menu-icon {\n  font-size: 18px;\n}\n\n// This text is contained inside a div.\n// ID needed to override user agent stylesheet.\n// See components/modal.scss\n\n/* stylelint-disable */\n#buy-modal-content-footer-text {\n  font-family: 'DIN OT';\n  font-size: 16px;\n}\n/* stylelint-enable */\n"],"names":[],"mappings":"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"} */ diff --git a/old-ui/app/css/reset.css b/old-ui/app/css/reset.css new file mode 100644 index 000000000..9ce89e8bc --- /dev/null +++ b/old-ui/app/css/reset.css @@ -0,0 +1,48 @@ +/* http://meyerweb.com/eric/tools/css/reset/ + v2.0 | 20110126 + License: none (public domain) +*/ + +html, body, div, span, applet, object, iframe, +h1, h2, h3, h4, h5, h6, p, blockquote, pre, +a, abbr, acronym, address, big, cite, code, +del, dfn, em, img, ins, kbd, q, s, samp, +small, strike, strong, sub, sup, tt, var, +b, u, i, center, +dl, dt, dd, ol, ul, li, +fieldset, form, label, legend, +table, caption, tbody, tfoot, thead, tr, th, td, +article, aside, canvas, details, embed, +figure, figcaption, footer, header, hgroup, +menu, nav, output, ruby, section, summary, +time, mark, audio, video { + margin: 0; + padding: 0; + border: 0; + font-size: 100%; + font: inherit; + vertical-align: baseline; +} +/* HTML5 display-role reset for older browsers */ +article, aside, details, figcaption, figure, +footer, header, hgroup, menu, nav, section { + display: block; +} +body { + line-height: 1; +} +ol, ul { + list-style: none; +} +blockquote, q { + quotes: none; +} +blockquote:before, blockquote:after, +q:before, q:after { + content: ''; + content: none; +} +table { + border-collapse: collapse; + border-spacing: 0; +} \ No newline at end of file diff --git a/old-ui/app/css/transitions.css b/old-ui/app/css/transitions.css new file mode 100644 index 000000000..393a944f9 --- /dev/null +++ b/old-ui/app/css/transitions.css @@ -0,0 +1,42 @@ +/* universal */ +.app-primary .main-enter { + position: absolute; + width: 100%; +} + +/* center position */ +.app-primary.from-right .main-enter-active, +.app-primary.from-left .main-enter-active { + overflow-x: hidden; + transform: translateX(0px); + transition: transform 300ms ease-in; +} + +/* exited positions */ +.app-primary.from-left .main-leave-active { + transform: translateX(360px); + transition: transform 300ms ease-in; +} +.app-primary.from-right .main-leave-active { + transform: translateX(-360px); + transition: transform 300ms ease-in; +} + +/* loader transitions */ +.loader-enter, .loader-leave-active { + opacity: 0.0; + transition: opacity 150 ease-in; +} +.loader-enter-active, .loader-leave { + opacity: 1.0; + transition: opacity 150 ease-in; +} + +/* entering positions */ +.app-primary.from-right .main-enter:not(.main-enter-active) { + transform: translateX(360px); +} +.app-primary.from-left .main-enter:not(.main-enter-active) { + transform: translateX(-360px); +} + diff --git a/old-ui/app/first-time/init-menu.js b/old-ui/app/first-time/init-menu.js new file mode 100644 index 000000000..cc7c51bd3 --- /dev/null +++ b/old-ui/app/first-time/init-menu.js @@ -0,0 +1,179 @@ +const inherits = require('util').inherits +const EventEmitter = require('events').EventEmitter +const Component = require('react').Component +const connect = require('react-redux').connect +const h = require('react-hyperscript') +const Mascot = require('../components/mascot') +const actions = require('../actions') +const Tooltip = require('../components/tooltip') +const getCaretCoordinates = require('textarea-caret') + +module.exports = connect(mapStateToProps)(InitializeMenuScreen) + +inherits(InitializeMenuScreen, Component) +function InitializeMenuScreen () { + Component.call(this) + this.animationEventEmitter = new EventEmitter() +} + +function mapStateToProps (state) { + return { + // state from plugin + currentView: state.appState.currentView, + warning: state.appState.warning, + } +} + +InitializeMenuScreen.prototype.render = function () { + var state = this.props + + switch (state.currentView.name) { + + default: + return this.renderMenu(state) + + } +} + +// InitializeMenuScreen.prototype.componentDidMount = function(){ +// document.getElementById('password-box').focus() +// } + +InitializeMenuScreen.prototype.renderMenu = function (state) { + return ( + + h('.initialize-screen.flex-column.flex-center.flex-grow', [ + + h(Mascot, { + animationEventEmitter: this.animationEventEmitter, + }), + + h('h1', { + style: { + fontSize: '1.3em', + textTransform: 'uppercase', + color: '#7F8082', + marginBottom: 10, + }, + }, 'MetaMask'), + + + h('div', [ + h('h3', { + style: { + fontSize: '0.8em', + color: '#7F8082', + display: 'inline', + }, + }, 'Encrypt your new DEN'), + + h(Tooltip, { + title: 'Your DEN is your password-encrypted storage within MetaMask.', + }, [ + h('i.fa.fa-question-circle.pointer', { + style: { + fontSize: '18px', + position: 'relative', + color: 'rgb(247, 134, 28)', + top: '2px', + marginLeft: '4px', + }, + }), + ]), + ]), + + h('span.in-progress-notification', state.warning), + + // password + h('input.large-input.letter-spacey', { + type: 'password', + id: 'password-box', + placeholder: 'New Password (min 8 chars)', + onInput: this.inputChanged.bind(this), + style: { + width: 260, + marginTop: 12, + }, + }), + + // confirm password + h('input.large-input.letter-spacey', { + type: 'password', + id: 'password-box-confirm', + placeholder: 'Confirm Password', + onKeyPress: this.createVaultOnEnter.bind(this), + onInput: this.inputChanged.bind(this), + style: { + width: 260, + marginTop: 16, + }, + }), + + + h('button.primary', { + onClick: this.createNewVaultAndKeychain.bind(this), + style: { + margin: 12, + }, + }, 'Create'), + + h('.flex-row.flex-center.flex-grow', [ + h('p.pointer', { + onClick: this.showRestoreVault.bind(this), + style: { + fontSize: '0.8em', + color: 'rgb(247, 134, 28)', + textDecoration: 'underline', + }, + }, 'Import Existing DEN'), + ]), + + ]) + ) +} + +InitializeMenuScreen.prototype.createVaultOnEnter = function (event) { + if (event.key === 'Enter') { + event.preventDefault() + this.createNewVaultAndKeychain() + } +} + +InitializeMenuScreen.prototype.componentDidMount = function () { + document.getElementById('password-box').focus() +} + +InitializeMenuScreen.prototype.showRestoreVault = function () { + this.props.dispatch(actions.showRestoreVault()) +} + +InitializeMenuScreen.prototype.createNewVaultAndKeychain = function () { + var passwordBox = document.getElementById('password-box') + var password = passwordBox.value + var passwordConfirmBox = document.getElementById('password-box-confirm') + var passwordConfirm = passwordConfirmBox.value + + if (password.length < 8) { + this.warning = 'password not long enough' + this.props.dispatch(actions.displayWarning(this.warning)) + return + } + if (password !== passwordConfirm) { + this.warning = 'passwords don\'t match' + this.props.dispatch(actions.displayWarning(this.warning)) + return + } + + this.props.dispatch(actions.createNewVaultAndKeychain(password)) +} + +InitializeMenuScreen.prototype.inputChanged = function (event) { + // tell mascot to look at page action + var element = event.target + var boundingRect = element.getBoundingClientRect() + var coordinates = getCaretCoordinates(element, element.selectionEnd) + this.animationEventEmitter.emit('point', { + x: boundingRect.left + coordinates.left - element.scrollLeft, + y: boundingRect.top + coordinates.top - element.scrollTop, + }) +} diff --git a/old-ui/app/img/identicon-tardigrade.png b/old-ui/app/img/identicon-tardigrade.png new file mode 100644 index 000000000..1742a32b8 Binary files /dev/null and b/old-ui/app/img/identicon-tardigrade.png differ diff --git a/old-ui/app/img/identicon-walrus.png b/old-ui/app/img/identicon-walrus.png new file mode 100644 index 000000000..d58fae912 Binary files /dev/null and b/old-ui/app/img/identicon-walrus.png differ diff --git a/old-ui/app/info.js b/old-ui/app/info.js new file mode 100644 index 000000000..24c211c1f --- /dev/null +++ b/old-ui/app/info.js @@ -0,0 +1,155 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') + +module.exports = connect(mapStateToProps)(InfoScreen) + +function mapStateToProps (state) { + return {} +} + +inherits(InfoScreen, Component) +function InfoScreen () { + Component.call(this) +} + +InfoScreen.prototype.render = function () { + const state = this.props + const version = global.platform.getVersion() + + return ( + h('.flex-column.flex-grow', { + style: { + maxWidth: '400px', + }, + }, [ + + // subtitle and nav + h('.section-title.flex-row.flex-center', [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: (event) => { + state.dispatch(actions.goHome()) + }, + }), + h('h2.page-subtitle', 'Info'), + ]), + + // main view + h('.flex-column.flex-justify-center.flex-grow.select-none', [ + h('.flex-space-around', { + style: { + padding: '20px', + }, + }, [ + // current version number + + h('.info.info-gray', [ + h('div', 'Metamask'), + h('div', { + style: { + marginBottom: '10px', + }, + }, `Version: ${version}`), + ]), + + h('div', { + style: { + marginBottom: '5px', + }}, + [ + h('div', [ + h('a', { + href: 'https://metamask.io/privacy.html', + target: '_blank', + onClick (event) { this.navigateTo(event.target.href) }, + }, [ + h('div.info', 'Privacy Policy'), + ]), + ]), + h('div', [ + h('a', { + href: 'https://metamask.io/terms.html', + target: '_blank', + onClick (event) { this.navigateTo(event.target.href) }, + }, [ + h('div.info', 'Terms of Use'), + ]), + ]), + h('div', [ + h('a', { + href: 'https://metamask.io/attributions.html', + target: '_blank', + onClick (event) { this.navigateTo(event.target.href) }, + }, [ + h('div.info', 'Attributions'), + ]), + ]), + ] + ), + + h('hr', { + style: { + margin: '10px 0 ', + width: '7em', + }, + }), + + h('div', { + style: { + paddingLeft: '30px', + }}, + [ + h('div.fa.fa-support', [ + h('a.info', { + href: 'https://support.metamask.io', + target: '_blank', + }, 'Visit our Support Center'), + ]), + + h('div', [ + h('a', { + href: 'https://metamask.io/', + target: '_blank', + }, [ + h('img.icon-size', { + src: 'images/icon-128.png', + style: { + // IE6-9 + filter: 'grayscale(100%)', + // Microsoft Edge and Firefox 35+ + WebkitFilter: 'grayscale(100%)', + }, + }), + h('div.info', 'Visit our web site'), + ]), + ]), + + h('div', [ + h('.fa.fa-twitter', [ + h('a.info', { + href: 'https://twitter.com/metamask_io', + target: '_blank', + }, 'Follow us on Twitter'), + ]), + ]), + + h('div.fa.fa-envelope', [ + h('a.info', { + target: '_blank', + style: { width: '85vw' }, + href: 'mailto:help@metamask.io?subject=Feedback', + }, 'Email us!'), + ]), + ]), + ]), + ]), + ]) + ) +} + +InfoScreen.prototype.navigateTo = function (url) { + global.platform.openWindow({ url }) +} + diff --git a/old-ui/app/infura-conversion.json b/old-ui/app/infura-conversion.json new file mode 100644 index 000000000..9a96fe069 --- /dev/null +++ b/old-ui/app/infura-conversion.json @@ -0,0 +1,653 @@ +{ + "objects": [ + { + "symbol": "ethaud", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "aud", + "name": "Australian Dollar" + } + }, + { + "symbol": "ethhkd", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "hkd", + "name": "Hong Kong Dollar" + } + }, + { + "symbol": "ethsgd", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "sgd", + "name": "Singapore Dollar" + } + }, + { + "symbol": "ethidr", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "idr", + "name": "Indonesian Rupiah" + } + }, + { + "symbol": "ethphp", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "php", + "name": "Philippine Peso" + } + }, + { + "symbol": "eth1st", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "1st", + "name": "FirstBlood" + } + }, + { + "symbol": "ethadt", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "adt", + "name": "adToken" + } + }, + { + "symbol": "ethadx", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "adx", + "name": "AdEx" + } + }, + { + "symbol": "ethant", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "ant", + "name": "Aragon" + } + }, + { + "symbol": "ethbat", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "bat", + "name": "Basic Attention Token" + } + }, + { + "symbol": "ethbnt", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "bnt", + "name": "Bancor" + } + }, + { + "symbol": "ethbtc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "btc", + "name": "Bitcoin" + } + }, + { + "symbol": "ethcad", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "cad", + "name": "Canadian Dollar" + } + }, + { + "symbol": "ethcfi", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "cfi", + "name": "Cofound.it" + } + }, + { + "symbol": "ethcrb", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "crb", + "name": "CreditBit" + } + }, + { + "symbol": "ethcvc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "cvc", + "name": "Civic" + } + }, + { + "symbol": "ethdash", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "dash", + "name": "Dash" + } + }, + { + "symbol": "ethdgd", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "dgd", + "name": "DigixDAO" + } + }, + { + "symbol": "ethetc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "etc", + "name": "Ethereum Classic" + } + }, + { + "symbol": "etheur", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "eur", + "name": "Euro" + } + }, + { + "symbol": "ethfun", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "fun", + "name": "FunFair" + } + }, + { + "symbol": "ethgbp", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "gbp", + "name": "Pound Sterling" + } + }, + { + "symbol": "ethgno", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "gno", + "name": "Gnosis" + } + }, + { + "symbol": "ethgnt", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "gnt", + "name": "Golem" + } + }, + { + "symbol": "ethgup", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "gup", + "name": "Matchpool" + } + }, + { + "symbol": "ethhmq", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "hmq", + "name": "Humaniq" + } + }, + { + "symbol": "ethjpy", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "jpy", + "name": "Japanese Yen" + } + }, + { + "symbol": "ethlgd", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "lgd", + "name": "Legends Room" + } + }, + { + "symbol": "ethlsk", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "lsk", + "name": "Lisk" + } + }, + { + "symbol": "ethltc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "ltc", + "name": "Litecoin" + } + }, + { + "symbol": "ethlun", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "lun", + "name": "Lunyr" + } + }, + { + "symbol": "ethmco", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "mco", + "name": "Monaco" + } + }, + { + "symbol": "ethmtl", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "mtl", + "name": "Metal" + } + }, + { + "symbol": "ethmyst", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "myst", + "name": "Mysterium" + } + }, + { + "symbol": "ethnmr", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "nmr", + "name": "Numeraire" + } + }, + { + "symbol": "ethomg", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "omg", + "name": "OmiseGO" + } + }, + { + "symbol": "ethpay", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "pay", + "name": "TenX" + } + }, + { + "symbol": "ethptoy", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "ptoy", + "name": "Patientory" + } + }, + { + "symbol": "ethqrl", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "qrl", + "name": "Quantum-Resistant Ledger" + } + }, + { + "symbol": "ethqtum", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "qtum", + "name": "Qtum" + } + }, + { + "symbol": "ethrep", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "rep", + "name": "Augur" + } + }, + { + "symbol": "ethrlc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "rlc", + "name": "iEx.ec" + } + }, + { + "symbol": "ethrub", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "rub", + "name": "Russian Ruble" + } + }, + { + "symbol": "ethsc", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "sc", + "name": "Siacoin" + } + }, + { + "symbol": "ethsngls", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "sngls", + "name": "SingularDTV" + } + }, + { + "symbol": "ethsnt", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "snt", + "name": "Status" + } + }, + { + "symbol": "ethsteem", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "steem", + "name": "Steem" + } + }, + { + "symbol": "ethstorj", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "storj", + "name": "Storj" + } + }, + { + "symbol": "ethtime", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "time", + "name": "ChronoBank" + } + }, + { + "symbol": "ethtkn", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "tkn", + "name": "TokenCard" + } + }, + { + "symbol": "ethtrst", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "trst", + "name": "WeTrust" + } + }, + { + "symbol": "ethuah", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "uah", + "name": "Ukrainian Hryvnia" + } + }, + { + "symbol": "ethusd", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "usd", + "name": "United States Dollar" + } + }, + { + "symbol": "ethwings", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "wings", + "name": "Wings" + } + }, + { + "symbol": "ethxem", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "xem", + "name": "NEM" + } + }, + { + "symbol": "ethxlm", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "xlm", + "name": "Stellar Lumen" + } + }, + { + "symbol": "ethxmr", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "xmr", + "name": "Monero" + } + }, + { + "symbol": "ethxrp", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "xrp", + "name": "Ripple" + } + }, + { + "symbol": "ethzec", + "base": { + "code": "eth", + "name": "Ethereum" + }, + "quote": { + "code": "zec", + "name": "Zcash" + } + } + ] +} diff --git a/old-ui/app/keychains/hd/create-vault-complete.js b/old-ui/app/keychains/hd/create-vault-complete.js new file mode 100644 index 000000000..5ab5d4c33 --- /dev/null +++ b/old-ui/app/keychains/hd/create-vault-complete.js @@ -0,0 +1,91 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const connect = require('react-redux').connect +const h = require('react-hyperscript') +const actions = require('../../actions') +const exportAsFile = require('../../util').exportAsFile + +module.exports = connect(mapStateToProps)(CreateVaultCompleteScreen) + +inherits(CreateVaultCompleteScreen, Component) +function CreateVaultCompleteScreen () { + Component.call(this) +} + +function mapStateToProps (state) { + return { + seed: state.appState.currentView.seedWords, + cachedSeed: state.metamask.seedWords, + } +} + +CreateVaultCompleteScreen.prototype.render = function () { + var state = this.props + var seed = state.seed || state.cachedSeed || '' + + return ( + + h('.initialize-screen.flex-column.flex-center.flex-grow', [ + + // // subtitle and nav + // h('.section-title.flex-row.flex-center', [ + // h('h2.page-subtitle', 'Vault Created'), + // ]), + + h('h3.flex-center.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginTop: 36, + marginBottom: 8, + width: '100%', + fontSize: '20px', + padding: 6, + }, + }, [ + 'Vault Created', + ]), + + h('div', { + style: { + fontSize: '1em', + marginTop: '10px', + textAlign: 'center', + }, + }, [ + h('span.error', 'These 12 words are the only way to restore your MetaMask accounts.\nSave them somewhere safe and secret.'), + ]), + + h('textarea.twelve-word-phrase', { + readOnly: true, + value: seed, + }), + + h('button.primary', { + onClick: () => this.confirmSeedWords() + .then(account => this.showAccountDetail(account)), + style: { + margin: '24px', + fontSize: '0.9em', + marginBottom: '10px', + }, + }, 'I\'ve copied it somewhere safe'), + + h('button.primary', { + onClick: () => exportAsFile(`MetaMask Seed Words`, seed), + style: { + margin: '10px', + fontSize: '0.9em', + }, + }, 'Save Seed Words As File'), + ]) + ) +} + +CreateVaultCompleteScreen.prototype.confirmSeedWords = function () { + return this.props.dispatch(actions.confirmSeedWords()) +} + +CreateVaultCompleteScreen.prototype.showAccountDetail = function (account) { + return this.props.dispatch(actions.showAccountDetail(account)) +} diff --git a/old-ui/app/keychains/hd/recover-seed/confirmation.js b/old-ui/app/keychains/hd/recover-seed/confirmation.js new file mode 100644 index 000000000..4335186a5 --- /dev/null +++ b/old-ui/app/keychains/hd/recover-seed/confirmation.js @@ -0,0 +1,121 @@ +const inherits = require('util').inherits + +const Component = require('react').Component +const connect = require('react-redux').connect +const h = require('react-hyperscript') +const actions = require('../../../actions') + +module.exports = connect(mapStateToProps)(RevealSeedConfirmation) + +inherits(RevealSeedConfirmation, Component) +function RevealSeedConfirmation () { + Component.call(this) +} + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + } +} + +RevealSeedConfirmation.prototype.render = function () { + const props = this.props + + return ( + + h('.initialize-screen.flex-column.flex-center.flex-grow', { + style: { maxWidth: '420px' }, + }, [ + + h('h3.flex-center.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginBottom: 24, + width: '100%', + fontSize: '20px', + padding: 6, + }, + }, [ + 'Reveal Seed Words', + ]), + + h('.div', { + style: { + display: 'flex', + flexDirection: 'column', + padding: '20px', + justifyContent: 'center', + }, + }, [ + + h('h4', 'Do not recover your seed words in a public place! These words can be used to steal all your accounts.'), + + // confirmation + h('input.large-input.letter-spacey', { + type: 'password', + id: 'password-box', + placeholder: 'Enter your password to confirm', + onKeyPress: this.checkConfirmation.bind(this), + style: { + width: 260, + marginTop: '12px', + }, + }), + + h('.flex-row.flex-start', { + style: { + marginTop: 30, + width: '50%', + }, + }, [ + // cancel + h('button.primary', { + onClick: this.goHome.bind(this), + }, 'CANCEL'), + + // submit + h('button.primary', { + style: { marginLeft: '10px' }, + onClick: this.revealSeedWords.bind(this), + }, 'OK'), + + ]), + + (props.warning) && ( + h('span.error', { + style: { + margin: '20px', + }, + }, props.warning.split('-')) + ), + + props.inProgress && ( + h('span.in-progress-notification', 'Generating Seed...') + ), + ]), + ]) + ) +} + +RevealSeedConfirmation.prototype.componentDidMount = function () { + document.getElementById('password-box').focus() +} + +RevealSeedConfirmation.prototype.goHome = function () { + this.props.dispatch(actions.showConfigPage(false)) +} + +// create vault + +RevealSeedConfirmation.prototype.checkConfirmation = function (event) { + if (event.key === 'Enter') { + event.preventDefault() + this.revealSeedWords() + } +} + +RevealSeedConfirmation.prototype.revealSeedWords = function () { + var password = document.getElementById('password-box').value + this.props.dispatch(actions.requestRevealSeed(password)) +} diff --git a/old-ui/app/keychains/hd/restore-vault.js b/old-ui/app/keychains/hd/restore-vault.js new file mode 100644 index 000000000..06e51d9b3 --- /dev/null +++ b/old-ui/app/keychains/hd/restore-vault.js @@ -0,0 +1,152 @@ +const inherits = require('util').inherits +const PersistentForm = require('../../../lib/persistent-form') +const connect = require('react-redux').connect +const h = require('react-hyperscript') +const actions = require('../../actions') + +module.exports = connect(mapStateToProps)(RestoreVaultScreen) + +inherits(RestoreVaultScreen, PersistentForm) +function RestoreVaultScreen () { + PersistentForm.call(this) +} + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + forgottenPassword: state.appState.forgottenPassword, + } +} + +RestoreVaultScreen.prototype.render = function () { + var state = this.props + this.persistentFormParentId = 'restore-vault-form' + + return ( + + h('.initialize-screen.flex-column.flex-center.flex-grow', [ + + h('h3.flex-center.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginBottom: 24, + width: '100%', + fontSize: '20px', + padding: 6, + }, + }, [ + 'Restore Vault', + ]), + + // wallet seed entry + h('h3', 'Wallet Seed'), + h('textarea.twelve-word-phrase.letter-spacey', { + dataset: { + persistentFormId: 'wallet-seed', + }, + placeholder: 'Enter your secret twelve word phrase here to restore your vault.', + }), + + // password + h('input.large-input.letter-spacey', { + type: 'password', + id: 'password-box', + placeholder: 'New Password (min 8 chars)', + dataset: { + persistentFormId: 'password', + }, + style: { + width: 260, + marginTop: 12, + }, + }), + + // confirm password + h('input.large-input.letter-spacey', { + type: 'password', + id: 'password-box-confirm', + placeholder: 'Confirm Password', + onKeyPress: this.createOnEnter.bind(this), + dataset: { + persistentFormId: 'password-confirmation', + }, + style: { + width: 260, + marginTop: 16, + }, + }), + + (state.warning) && ( + h('span.error.in-progress-notification', state.warning) + ), + + // submit + + h('.flex-row.flex-space-between', { + style: { + marginTop: 30, + width: '50%', + }, + }, [ + + // cancel + h('button.primary', { + onClick: this.showInitializeMenu.bind(this), + }, 'CANCEL'), + + // submit + h('button.primary', { + onClick: this.createNewVaultAndRestore.bind(this), + }, 'OK'), + + ]), + ]) + + ) +} + +RestoreVaultScreen.prototype.showInitializeMenu = function () { + if (this.props.forgottenPassword) { + this.props.dispatch(actions.backToUnlockView()) + } else { + this.props.dispatch(actions.showInitializeMenu()) + } +} + +RestoreVaultScreen.prototype.createOnEnter = function (event) { + if (event.key === 'Enter') { + this.createNewVaultAndRestore() + } +} + +RestoreVaultScreen.prototype.createNewVaultAndRestore = function () { + // check password + var passwordBox = document.getElementById('password-box') + var password = passwordBox.value + var passwordConfirmBox = document.getElementById('password-box-confirm') + var passwordConfirm = passwordConfirmBox.value + if (password.length < 8) { + this.warning = 'Password not long enough' + + this.props.dispatch(actions.displayWarning(this.warning)) + return + } + if (password !== passwordConfirm) { + this.warning = 'Passwords don\'t match' + this.props.dispatch(actions.displayWarning(this.warning)) + return + } + // check seed + var seedBox = document.querySelector('textarea.twelve-word-phrase') + var seed = seedBox.value.trim() + if (seed.split(' ').length !== 12) { + this.warning = 'seed phrases are 12 words long' + this.props.dispatch(actions.displayWarning(this.warning)) + return + } + // submit + this.warning = null + this.props.dispatch(actions.displayWarning(this.warning)) + this.props.dispatch(actions.createNewVaultAndRestore(password, seed)) +} diff --git a/old-ui/app/new-keychain.js b/old-ui/app/new-keychain.js new file mode 100644 index 000000000..cc9633166 --- /dev/null +++ b/old-ui/app/new-keychain.js @@ -0,0 +1,29 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect + +module.exports = connect(mapStateToProps)(NewKeychain) + +function mapStateToProps (state) { + return {} +} + +inherits(NewKeychain, Component) +function NewKeychain () { + Component.call(this) +} + +NewKeychain.prototype.render = function () { + // const props = this.props + + return ( + h('div', { + style: { + background: 'blue', + }, + }, [ + h('h1', `Here's a list!!!!`), + ]) + ) +} diff --git a/old-ui/app/reducers.js b/old-ui/app/reducers.js new file mode 100644 index 000000000..70b7e71dc --- /dev/null +++ b/old-ui/app/reducers.js @@ -0,0 +1,76 @@ +const extend = require('xtend') +const copyToClipboard = require('copy-to-clipboard') + +// +// Sub-Reducers take in the complete state and return their sub-state +// +const reduceIdentities = require('./reducers/identities') +const reduceMetamask = require('./reducers/metamask') +const reduceApp = require('./reducers/app') + +window.METAMASK_CACHED_LOG_STATE = null + +module.exports = rootReducer + +function rootReducer (state, action) { + // clone + state = extend(state) + + if (action.type === 'GLOBAL_FORCE_UPDATE') { + return action.value + } + + // + // Identities + // + + state.identities = reduceIdentities(state, action) + + // + // MetaMask + // + + state.metamask = reduceMetamask(state, action) + + // + // AppState + // + + state.appState = reduceApp(state, action) + + window.METAMASK_CACHED_LOG_STATE = state + return state +} + +window.logStateString = function (cb) { + const state = window.METAMASK_CACHED_LOG_STATE + const version = global.platform.getVersion() + const browser = window.navigator.userAgent + return global.platform.getPlatformInfo((err, platform) => { + if (err) { + return cb(err) + } + state.version = version + state.platform = platform + state.browser = browser + const stateString = JSON.stringify(state, removeSeedWords, 2) + return cb(null, stateString) + }) +} + +window.logState = function (toClipboard) { + return window.logStateString((err, result) => { + if (err) { + console.error(err.message) + } else if (toClipboard) { + copyToClipboard(result) + console.log('State log copied') + } else { + console.log(result) + } + }) +} + +function removeSeedWords (key, value) { + return key === 'seedWords' ? undefined : value +} diff --git a/old-ui/app/reducers/app.js b/old-ui/app/reducers/app.js new file mode 100644 index 000000000..8558d6dca --- /dev/null +++ b/old-ui/app/reducers/app.js @@ -0,0 +1,599 @@ +const extend = require('xtend') +const actions = require('../actions') +const txHelper = require('../../lib/tx-helper') + +module.exports = reduceApp + + +function reduceApp (state, action) { + log.debug('App Reducer got ' + action.type) + // clone and defaults + const selectedAddress = state.metamask.selectedAddress + const hasUnconfActions = checkUnconfActions(state) + let name = 'accounts' + if (selectedAddress) { + name = 'accountDetail' + } + if (hasUnconfActions) { + log.debug('pending txs detected, defaulting to conf-tx view.') + name = 'confTx' + } + + var defaultView = { + name, + detailView: null, + context: selectedAddress, + } + + // confirm seed words + var seedWords = state.metamask.seedWords + var seedConfView = { + name: 'createVaultComplete', + seedWords, + } + + // default state + var appState = extend({ + shouldClose: false, + menuOpen: false, + currentView: seedWords ? seedConfView : defaultView, + accountDetail: { + subview: 'transactions', + }, + // Used to render transition direction + transForward: true, + // Used to display loading indicator + isLoading: false, + // Used to display error text + warning: null, + }, state.appState) + + switch (action.type) { + + // transition methods + + case actions.TRANSITION_FORWARD: + return extend(appState, { + transForward: true, + }) + + case actions.TRANSITION_BACKWARD: + return extend(appState, { + transForward: false, + }) + + // intialize + + case actions.SHOW_CREATE_VAULT: + return extend(appState, { + currentView: { + name: 'createVault', + }, + transForward: true, + warning: null, + }) + + case actions.SHOW_RESTORE_VAULT: + return extend(appState, { + currentView: { + name: 'restoreVault', + }, + transForward: true, + forgottenPassword: true, + }) + + case actions.FORGOT_PASSWORD: + return extend(appState, { + currentView: { + name: 'restoreVault', + }, + transForward: false, + forgottenPassword: true, + }) + + case actions.SHOW_INIT_MENU: + return extend(appState, { + currentView: defaultView, + transForward: false, + }) + + case actions.SHOW_CONFIG_PAGE: + return extend(appState, { + currentView: { + name: 'config', + context: appState.currentView.context, + }, + transForward: action.value, + }) + + case actions.SHOW_ADD_TOKEN_PAGE: + return extend(appState, { + currentView: { + name: 'add-token', + context: appState.currentView.context, + }, + transForward: action.value, + }) + + case actions.SHOW_IMPORT_PAGE: + + return extend(appState, { + currentView: { + name: 'import-menu', + }, + transForward: true, + warning: null, + }) + + case actions.SHOW_INFO_PAGE: + return extend(appState, { + currentView: { + name: 'info', + context: appState.currentView.context, + }, + transForward: true, + }) + + case actions.CREATE_NEW_VAULT_IN_PROGRESS: + return extend(appState, { + currentView: { + name: 'createVault', + inProgress: true, + }, + transForward: true, + isLoading: true, + }) + + case actions.SHOW_NEW_VAULT_SEED: + return extend(appState, { + currentView: { + name: 'createVaultComplete', + seedWords: action.value, + }, + transForward: true, + isLoading: false, + }) + + case actions.NEW_ACCOUNT_SCREEN: + return extend(appState, { + currentView: { + name: 'new-account', + context: appState.currentView.context, + }, + transForward: true, + }) + + case actions.SHOW_SEND_PAGE: + return extend(appState, { + currentView: { + name: 'sendTransaction', + context: appState.currentView.context, + }, + transForward: true, + warning: null, + }) + + case actions.SHOW_NEW_KEYCHAIN: + return extend(appState, { + currentView: { + name: 'newKeychain', + context: appState.currentView.context, + }, + transForward: true, + }) + + // unlock + + case actions.UNLOCK_METAMASK: + return extend(appState, { + forgottenPassword: appState.forgottenPassword ? !appState.forgottenPassword : null, + detailView: {}, + transForward: true, + isLoading: false, + warning: null, + }) + + case actions.LOCK_METAMASK: + return extend(appState, { + currentView: defaultView, + transForward: false, + warning: null, + }) + + case actions.BACK_TO_INIT_MENU: + return extend(appState, { + warning: null, + transForward: false, + forgottenPassword: true, + currentView: { + name: 'InitMenu', + }, + }) + + case actions.BACK_TO_UNLOCK_VIEW: + return extend(appState, { + warning: null, + transForward: true, + forgottenPassword: false, + currentView: { + name: 'UnlockScreen', + }, + }) + // reveal seed words + + case actions.REVEAL_SEED_CONFIRMATION: + return extend(appState, { + currentView: { + name: 'reveal-seed-conf', + }, + transForward: true, + warning: null, + }) + + // accounts + + case actions.SET_SELECTED_ACCOUNT: + return extend(appState, { + activeAddress: action.value, + }) + + case actions.GO_HOME: + return extend(appState, { + currentView: extend(appState.currentView, { + name: 'accountDetail', + }), + accountDetail: { + subview: 'transactions', + accountExport: 'none', + privateKey: '', + }, + transForward: false, + warning: null, + }) + + case actions.SHOW_ACCOUNT_DETAIL: + return extend(appState, { + forgottenPassword: appState.forgottenPassword ? !appState.forgottenPassword : null, + currentView: { + name: 'accountDetail', + context: action.value, + }, + accountDetail: { + subview: 'transactions', + accountExport: 'none', + privateKey: '', + }, + transForward: false, + }) + + case actions.BACK_TO_ACCOUNT_DETAIL: + return extend(appState, { + currentView: { + name: 'accountDetail', + context: action.value, + }, + accountDetail: { + subview: 'transactions', + accountExport: 'none', + privateKey: '', + }, + transForward: false, + }) + + case actions.SHOW_ACCOUNTS_PAGE: + return extend(appState, { + currentView: { + name: seedWords ? 'createVaultComplete' : 'accounts', + seedWords, + }, + transForward: true, + isLoading: false, + warning: null, + scrollToBottom: false, + forgottenPassword: false, + }) + + case actions.SHOW_NOTICE: + return extend(appState, { + transForward: true, + isLoading: false, + }) + + case actions.REVEAL_ACCOUNT: + return extend(appState, { + scrollToBottom: true, + }) + + case actions.SHOW_CONF_TX_PAGE: + return extend(appState, { + currentView: { + name: 'confTx', + context: 0, + }, + transForward: action.transForward, + warning: null, + isLoading: false, + }) + + case actions.SHOW_CONF_MSG_PAGE: + return extend(appState, { + currentView: { + name: hasUnconfActions ? 'confTx' : 'account-detail', + context: 0, + }, + transForward: true, + warning: null, + isLoading: false, + }) + + case actions.COMPLETED_TX: + log.debug('reducing COMPLETED_TX for tx ' + action.value) + const otherUnconfActions = getUnconfActionList(state) + .filter(tx => tx.id !== action.value) + const hasOtherUnconfActions = otherUnconfActions.length > 0 + + if (hasOtherUnconfActions) { + log.debug('reducer detected txs - rendering confTx view') + return extend(appState, { + transForward: false, + currentView: { + name: 'confTx', + context: 0, + }, + warning: null, + }) + } else { + log.debug('attempting to close popup') + return extend(appState, { + // indicate notification should close + shouldClose: true, + transForward: false, + warning: null, + currentView: { + name: 'accountDetail', + context: state.metamask.selectedAddress, + }, + accountDetail: { + subview: 'transactions', + }, + }) + } + + case actions.NEXT_TX: + return extend(appState, { + transForward: true, + currentView: { + name: 'confTx', + context: ++appState.currentView.context, + warning: null, + }, + }) + + case actions.VIEW_PENDING_TX: + const context = indexForPending(state, action.value) + return extend(appState, { + transForward: true, + currentView: { + name: 'confTx', + context, + warning: null, + }, + }) + + case actions.PREVIOUS_TX: + return extend(appState, { + transForward: false, + currentView: { + name: 'confTx', + context: --appState.currentView.context, + warning: null, + }, + }) + + case actions.TRANSACTION_ERROR: + return extend(appState, { + currentView: { + name: 'confTx', + errorMessage: 'There was a problem submitting this transaction.', + }, + }) + + case actions.UNLOCK_FAILED: + return extend(appState, { + warning: action.value || 'Incorrect password. Try again.', + }) + + case actions.SHOW_LOADING: + return extend(appState, { + isLoading: true, + loadingMessage: action.value, + }) + + case actions.HIDE_LOADING: + return extend(appState, { + isLoading: false, + }) + + case actions.SHOW_SUB_LOADING_INDICATION: + return extend(appState, { + isSubLoading: true, + }) + + case actions.HIDE_SUB_LOADING_INDICATION: + return extend(appState, { + isSubLoading: false, + }) + case actions.CLEAR_SEED_WORD_CACHE: + return extend(appState, { + transForward: true, + currentView: {}, + isLoading: false, + accountDetail: { + subview: 'transactions', + accountExport: 'none', + privateKey: '', + }, + }) + + case actions.DISPLAY_WARNING: + return extend(appState, { + warning: action.value, + isLoading: false, + }) + + case actions.HIDE_WARNING: + return extend(appState, { + warning: undefined, + }) + + case actions.REQUEST_ACCOUNT_EXPORT: + return extend(appState, { + transForward: true, + currentView: { + name: 'accountDetail', + context: appState.currentView.context, + }, + accountDetail: { + subview: 'export', + accountExport: 'requested', + }, + }) + + case actions.EXPORT_ACCOUNT: + return extend(appState, { + accountDetail: { + subview: 'export', + accountExport: 'completed', + }, + }) + + case actions.SHOW_PRIVATE_KEY: + return extend(appState, { + accountDetail: { + subview: 'export', + accountExport: 'completed', + privateKey: action.value, + }, + }) + + case actions.BUY_ETH_VIEW: + return extend(appState, { + transForward: true, + currentView: { + name: 'buyEth', + context: appState.currentView.name, + }, + identity: state.metamask.identities[action.value], + buyView: { + subview: 'Coinbase', + amount: '15.00', + buyAddress: action.value, + formView: { + coinbase: true, + shapeshift: false, + }, + }, + }) + + case actions.ONBOARDING_BUY_ETH_VIEW: + return extend(appState, { + transForward: true, + currentView: { + name: 'onboardingBuyEth', + context: appState.currentView.name, + }, + identity: state.metamask.identities[action.value], + }) + + case actions.COINBASE_SUBVIEW: + return extend(appState, { + buyView: { + subview: 'Coinbase', + formView: { + coinbase: true, + shapeshift: false, + }, + buyAddress: appState.buyView.buyAddress, + amount: appState.buyView.amount, + }, + }) + + case actions.SHAPESHIFT_SUBVIEW: + return extend(appState, { + buyView: { + subview: 'ShapeShift', + formView: { + coinbase: false, + shapeshift: true, + marketinfo: action.value.marketinfo, + coinOptions: action.value.coinOptions, + }, + buyAddress: appState.buyView.buyAddress, + amount: appState.buyView.amount, + }, + }) + + case actions.PAIR_UPDATE: + return extend(appState, { + buyView: { + subview: 'ShapeShift', + formView: { + coinbase: false, + shapeshift: true, + marketinfo: action.value.marketinfo, + coinOptions: appState.buyView.formView.coinOptions, + }, + buyAddress: appState.buyView.buyAddress, + amount: appState.buyView.amount, + warning: null, + }, + }) + + case actions.SHOW_QR: + return extend(appState, { + qrRequested: true, + transForward: true, + + Qr: { + message: action.value.message, + data: action.value.data, + }, + }) + + case actions.SHOW_QR_VIEW: + return extend(appState, { + currentView: { + name: 'qr', + context: appState.currentView.context, + }, + transForward: true, + Qr: { + message: action.value.message, + data: action.value.data, + }, + }) + default: + return appState + } +} + +function checkUnconfActions (state) { + const unconfActionList = getUnconfActionList(state) + const hasUnconfActions = unconfActionList.length > 0 + return hasUnconfActions +} + +function getUnconfActionList (state) { + const { unapprovedTxs, unapprovedMsgs, + unapprovedPersonalMsgs, unapprovedTypedMessages, network } = state.metamask + + const unconfActionList = txHelper(unapprovedTxs, unapprovedMsgs, unapprovedPersonalMsgs, unapprovedTypedMessages, network) + return unconfActionList +} + +function indexForPending (state, txId) { + const unconfTxList = getUnconfActionList(state) + const match = unconfTxList.find((tx) => tx.id === txId) + const index = unconfTxList.indexOf(match) + return index +} diff --git a/old-ui/app/reducers/identities.js b/old-ui/app/reducers/identities.js new file mode 100644 index 000000000..341a404e7 --- /dev/null +++ b/old-ui/app/reducers/identities.js @@ -0,0 +1,15 @@ +const extend = require('xtend') + +module.exports = reduceIdentities + +function reduceIdentities (state, action) { + // clone + defaults + var idState = extend({ + + }, state.identities) + + switch (action.type) { + default: + return idState + } +} diff --git a/old-ui/app/reducers/metamask.js b/old-ui/app/reducers/metamask.js new file mode 100644 index 000000000..13ac9e611 --- /dev/null +++ b/old-ui/app/reducers/metamask.js @@ -0,0 +1,166 @@ +const extend = require('xtend') +const actions = require('../actions') +const MetamascaraPlatform = require('../../../app/scripts/platforms/window') + +module.exports = reduceMetamask + +function reduceMetamask (state, action) { + let newState + + // clone + defaults + var metamaskState = extend({ + isInitialized: false, + isUnlocked: false, + isMascara: window.platform instanceof MetamascaraPlatform, + rpcTarget: 'https://rawtestrpc.metamask.io/', + identities: {}, + unapprovedTxs: {}, + noActiveNotices: true, + lastUnreadNotice: undefined, + frequentRpcList: [], + addressBook: [], + tokenExchangeRates: {}, + coinOptions: {}, + featureFlags: {}, + }, state.metamask) + + switch (action.type) { + + case actions.SHOW_ACCOUNTS_PAGE: + newState = extend(metamaskState) + delete newState.seedWords + return newState + + case actions.SHOW_NOTICE: + return extend(metamaskState, { + noActiveNotices: false, + lastUnreadNotice: action.value, + }) + + case actions.CLEAR_NOTICES: + return extend(metamaskState, { + noActiveNotices: true, + }) + + case actions.UPDATE_METAMASK_STATE: + return extend(metamaskState, action.value) + + case actions.UNLOCK_METAMASK: + return extend(metamaskState, { + isUnlocked: true, + isInitialized: true, + selectedAddress: action.value, + }) + + case actions.LOCK_METAMASK: + return extend(metamaskState, { + isUnlocked: false, + }) + + case actions.SET_RPC_LIST: + return extend(metamaskState, { + frequentRpcList: action.value, + }) + + case actions.SET_RPC_TARGET: + return extend(metamaskState, { + provider: { + type: 'rpc', + rpcTarget: action.value, + }, + }) + + case actions.SET_PROVIDER_TYPE: + return extend(metamaskState, { + provider: { + type: action.value, + }, + }) + + case actions.COMPLETED_TX: + var stringId = String(action.id) + newState = extend(metamaskState, { + unapprovedTxs: {}, + unapprovedMsgs: {}, + }) + for (const id in metamaskState.unapprovedTxs) { + if (id !== stringId) { + newState.unapprovedTxs[id] = metamaskState.unapprovedTxs[id] + } + } + for (const id in metamaskState.unapprovedMsgs) { + if (id !== stringId) { + newState.unapprovedMsgs[id] = metamaskState.unapprovedMsgs[id] + } + } + return newState + + case actions.SHOW_NEW_VAULT_SEED: + return extend(metamaskState, { + isUnlocked: true, + isInitialized: false, + seedWords: action.value, + }) + + case actions.CLEAR_SEED_WORD_CACHE: + newState = extend(metamaskState, { + isUnlocked: true, + isInitialized: true, + selectedAddress: action.value, + }) + delete newState.seedWords + return newState + + case actions.SHOW_ACCOUNT_DETAIL: + newState = extend(metamaskState, { + isUnlocked: true, + isInitialized: true, + selectedAddress: action.value, + }) + delete newState.seedWords + return newState + + case actions.SAVE_ACCOUNT_LABEL: + const account = action.value.account + const name = action.value.label + var id = {} + id[account] = extend(metamaskState.identities[account], { name }) + var identities = extend(metamaskState.identities, id) + return extend(metamaskState, { identities }) + + case actions.SET_CURRENT_FIAT: + return extend(metamaskState, { + currentCurrency: action.value.currentCurrency, + conversionRate: action.value.conversionRate, + conversionDate: action.value.conversionDate, + }) + + case actions.PAIR_UPDATE: + const { value: { marketinfo: pairMarketInfo } } = action + return extend(metamaskState, { + tokenExchangeRates: { + ...metamaskState.tokenExchangeRates, + [pairMarketInfo.pair]: pairMarketInfo, + }, + }) + + case actions.SHAPESHIFT_SUBVIEW: + const { value: { marketinfo, coinOptions } } = action + return extend(metamaskState, { + tokenExchangeRates: { + ...metamaskState.tokenExchangeRates, + [marketinfo.pair]: marketinfo, + }, + coinOptions, + }) + + case actions.UPDATE_FEATURE_FLAGS: + return extend(metamaskState, { + featureFlags: action.value, + }) + + default: + return metamaskState + + } +} diff --git a/old-ui/app/root.js b/old-ui/app/root.js new file mode 100644 index 000000000..9fea85572 --- /dev/null +++ b/old-ui/app/root.js @@ -0,0 +1,23 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const Provider = require('react-redux').Provider +const h = require('react-hyperscript') +const App = require('./app') + +module.exports = Root + +inherits(Root, Component) +function Root () { Component.call(this) } + +Root.prototype.render = function () { + console.log(123454) + return ( + + h(Provider, { + store: this.props.store, + }, [ + h(App), + ]) + + ) +} diff --git a/old-ui/app/send.js b/old-ui/app/send.js new file mode 100644 index 000000000..e59c1130e --- /dev/null +++ b/old-ui/app/send.js @@ -0,0 +1,293 @@ +const inherits = require('util').inherits +const PersistentForm = require('../lib/persistent-form') +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const Identicon = require('./components/identicon') +const actions = require('./actions') +const util = require('./util') +const numericBalance = require('./util').numericBalance +const addressSummary = require('./util').addressSummary +const isHex = require('./util').isHex +const EthBalance = require('./components/eth-balance') +const EnsInput = require('./components/ens-input') +const ethUtil = require('ethereumjs-util') +module.exports = connect(mapStateToProps)(SendTransactionScreen) + +function mapStateToProps (state) { + var result = { + address: state.metamask.selectedAddress, + accounts: state.metamask.accounts, + identities: state.metamask.identities, + warning: state.appState.warning, + network: state.metamask.network, + addressBook: state.metamask.addressBook, + conversionRate: state.metamask.conversionRate, + currentCurrency: state.metamask.currentCurrency, + } + + result.error = result.warning && result.warning.split('.')[0] + + result.account = result.accounts[result.address] + result.identity = result.identities[result.address] + result.balance = result.account ? numericBalance(result.account.balance) : null + + return result +} + +inherits(SendTransactionScreen, PersistentForm) +function SendTransactionScreen () { + PersistentForm.call(this) +} + +SendTransactionScreen.prototype.render = function () { + this.persistentFormParentId = 'send-tx-form' + + const props = this.props + const { + address, + account, + identity, + network, + identities, + addressBook, + conversionRate, + currentCurrency, + } = props + + return ( + + h('.send-screen.flex-column.flex-grow', [ + + // + // Sender Profile + // + + h('.account-data-subsection.flex-row.flex-grow', { + style: { + margin: '0 20px', + }, + }, [ + + // header - identicon + nav + h('.flex-row.flex-space-between', { + style: { + marginTop: '15px', + }, + }, [ + // back button + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer.color-orange', { + onClick: this.back.bind(this), + }), + + // large identicon + h('.identicon-wrapper.flex-column.flex-center.select-none', [ + h(Identicon, { + diameter: 62, + address: address, + }), + ]), + + // invisible place holder + h('i.fa.fa-users.fa-lg.invisible', { + style: { + marginTop: '28px', + }, + }), + + ]), + + // account label + + h('.flex-column', { + style: { + marginTop: '10px', + alignItems: 'flex-start', + }, + }, [ + h('h2.font-medium.color-forest.flex-center', { + style: { + paddingTop: '8px', + marginBottom: '8px', + }, + }, identity && identity.name), + + // address and getter actions + h('.flex-row.flex-center', { + style: { + marginBottom: '8px', + }, + }, [ + + h('div', { + style: { + lineHeight: '16px', + }, + }, addressSummary(address)), + + ]), + + // balance + h('.flex-row.flex-center', [ + + h(EthBalance, { + value: account && account.balance, + conversionRate, + currentCurrency, + }), + + ]), + ]), + ]), + + // + // Required Fields + // + + h('h3.flex-center.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginTop: '15px', + marginBottom: '16px', + }, + }, [ + 'Send Transaction', + ]), + + // error message + props.error && h('span.error.flex-center', props.error), + + // 'to' field + h('section.flex-row.flex-center', [ + h(EnsInput, { + name: 'address', + placeholder: 'Recipient Address', + onChange: this.recipientDidChange.bind(this), + network, + identities, + addressBook, + }), + ]), + + // 'amount' and send button + h('section.flex-row.flex-center', [ + + h('input.large-input', { + name: 'amount', + placeholder: 'Amount', + type: 'number', + style: { + marginRight: '6px', + }, + dataset: { + persistentFormId: 'tx-amount', + }, + }), + + h('button.primary', { + onClick: this.onSubmit.bind(this), + style: { + textTransform: 'uppercase', + }, + }, 'Next'), + + ]), + + // + // Optional Fields + // + h('h3.flex-center.text-transform-uppercase', { + style: { + background: '#EBEBEB', + color: '#AEAEAE', + marginTop: '16px', + marginBottom: '16px', + }, + }, [ + 'Transaction Data (optional)', + ]), + + // 'data' field + h('section.flex-column.flex-center', [ + h('input.large-input', { + name: 'txData', + placeholder: '0x01234', + style: { + width: '100%', + resize: 'none', + }, + dataset: { + persistentFormId: 'tx-data', + }, + }), + ]), + ]) + ) +} + +SendTransactionScreen.prototype.navigateToAccounts = function (event) { + event.stopPropagation() + this.props.dispatch(actions.showAccountsPage()) +} + +SendTransactionScreen.prototype.back = function () { + var address = this.props.address + this.props.dispatch(actions.backToAccountDetail(address)) +} + +SendTransactionScreen.prototype.recipientDidChange = function (recipient, nickname) { + this.setState({ + recipient: recipient, + nickname: nickname, + }) +} + +SendTransactionScreen.prototype.onSubmit = function () { + const state = this.state || {} + const recipient = state.recipient || document.querySelector('input[name="address"]').value.replace(/^[.\s]+|[.\s]+$/g, '') + const nickname = state.nickname || ' ' + const input = document.querySelector('input[name="amount"]').value + const value = util.normalizeEthStringToWei(input) + const txData = document.querySelector('input[name="txData"]').value + const balance = this.props.balance + let message + + if (value.gt(balance)) { + message = 'Insufficient funds.' + return this.props.dispatch(actions.displayWarning(message)) + } + + if (input < 0) { + message = 'Can not send negative amounts of ETH.' + return this.props.dispatch(actions.displayWarning(message)) + } + + if ((util.isInvalidChecksumAddress(recipient))) { + message = 'Recipient address checksum is invalid.' + return this.props.dispatch(actions.displayWarning(message)) + } + + if ((!util.isValidAddress(recipient) && !txData) || (!recipient && !txData)) { + message = 'Recipient address is invalid.' + return this.props.dispatch(actions.displayWarning(message)) + } + + if (!isHex(ethUtil.stripHexPrefix(txData)) && txData) { + message = 'Transaction data must be hex string.' + return this.props.dispatch(actions.displayWarning(message)) + } + + this.props.dispatch(actions.hideWarning()) + + this.props.dispatch(actions.addToAddressBook(recipient, nickname)) + + var txParams = { + from: this.props.address, + value: '0x' + value.toString(16), + } + + if (recipient) txParams.to = ethUtil.addHexPrefix(recipient) + if (txData) txParams.data = txData + + this.props.dispatch(actions.signTx(txParams)) +} diff --git a/old-ui/app/settings.js b/old-ui/app/settings.js new file mode 100644 index 000000000..454cc95e0 --- /dev/null +++ b/old-ui/app/settings.js @@ -0,0 +1,59 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') + +module.exports = connect(mapStateToProps)(AppSettingsPage) + +function mapStateToProps (state) { + return {} +} + +inherits(AppSettingsPage, Component) +function AppSettingsPage () { + Component.call(this) +} + +AppSettingsPage.prototype.render = function () { + return ( + + h('.account-detail-section.flex-column.flex-grow', [ + + // subtitle and nav + h('.flex-row.flex-center', [ + h('i.fa.fa-arrow-left.fa-lg.cursor-pointer', { + onClick: this.navigateToAccounts.bind(this), + }), + h('h2.page-subtitle', 'Settings'), + ]), + + h('label', { + htmlFor: 'settings-rpc-endpoint', + }, 'RPC Endpoint:'), + h('input', { + type: 'url', + id: 'settings-rpc-endpoint', + onKeyPress: this.onKeyPress.bind(this), + }), + + ]) + + ) +} + +AppSettingsPage.prototype.componentDidMount = function () { + document.querySelector('input').focus() +} + +AppSettingsPage.prototype.onKeyPress = function (event) { + // get submit event + if (event.key === 'Enter') { + // this.submitPassword(event) + } +} + +AppSettingsPage.prototype.navigateToAccounts = function (event) { + event.stopPropagation() + this.props.dispatch(actions.showAccountsPage()) +} diff --git a/old-ui/app/store.js b/old-ui/app/store.js new file mode 100644 index 000000000..3bafdee11 --- /dev/null +++ b/old-ui/app/store.js @@ -0,0 +1,21 @@ +const createStore = require('redux').createStore +const applyMiddleware = require('redux').applyMiddleware +const thunkMiddleware = require('redux-thunk').default +const rootReducer = require('./reducers') +const createLogger = require('redux-logger').createLogger + +global.METAMASK_DEBUG = 'GULP_METAMASK_DEBUG' + +module.exports = configureStore + +const loggerMiddleware = createLogger({ + predicate: () => global.METAMASK_DEBUG, +}) + +const middlewares = [thunkMiddleware, loggerMiddleware] + +const createStoreWithMiddleware = applyMiddleware(...middlewares)(createStore) + +function configureStore (initialState) { + return createStoreWithMiddleware(rootReducer, initialState) +} diff --git a/old-ui/app/template.js b/old-ui/app/template.js new file mode 100644 index 000000000..d15b30fd2 --- /dev/null +++ b/old-ui/app/template.js @@ -0,0 +1,30 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect + +module.exports = connect(mapStateToProps)(COMPONENTNAME) + +function mapStateToProps (state) { + return {} +} + +inherits(COMPONENTNAME, Component) +function COMPONENTNAME () { + Component.call(this) +} + +COMPONENTNAME.prototype.render = function () { + const props = this.props + + return ( + h('div', { + style: { + background: 'blue', + }, + }, [ + `Hello, ${props.sender}`, + ]) + ) +} + diff --git a/old-ui/app/unlock.js b/old-ui/app/unlock.js new file mode 100644 index 000000000..4180791c4 --- /dev/null +++ b/old-ui/app/unlock.js @@ -0,0 +1,122 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const h = require('react-hyperscript') +const connect = require('react-redux').connect +const actions = require('./actions') +const getCaretCoordinates = require('textarea-caret') +const EventEmitter = require('events').EventEmitter + +const Mascot = require('./components/mascot') + +module.exports = connect(mapStateToProps)(UnlockScreen) + +inherits(UnlockScreen, Component) +function UnlockScreen () { + Component.call(this) + this.animationEventEmitter = new EventEmitter() +} + +function mapStateToProps (state) { + return { + warning: state.appState.warning, + } +} + +UnlockScreen.prototype.render = function () { + const state = this.props + const warning = state.warning + return ( + h('.flex-column', { + style: { + width: 'inherit', + }, + }, [ + h('.unlock-screen.flex-column.flex-center.flex-grow', [ + + h(Mascot, { + animationEventEmitter: this.animationEventEmitter, + }), + + h('h1', { + style: { + fontSize: '1.4em', + textTransform: 'uppercase', + color: '#7F8082', + }, + }, 'MetaMask'), + + h('input.large-input', { + type: 'password', + id: 'password-box', + placeholder: 'enter password', + style: { + + }, + onKeyPress: this.onKeyPress.bind(this), + onInput: this.inputChanged.bind(this), + }), + + h('.error', { + style: { + display: warning ? 'block' : 'none', + padding: '0 20px', + textAlign: 'center', + }, + }, warning), + + h('button.primary.cursor-pointer', { + onClick: this.onSubmit.bind(this), + style: { + margin: 10, + }, + }, 'Unlock'), + ]), + + h('.flex-row.flex-center.flex-grow', [ + h('p.pointer', { + onClick: () => this.props.dispatch(actions.forgotPassword()), + style: { + fontSize: '0.8em', + color: 'rgb(247, 134, 28)', + textDecoration: 'underline', + }, + }, 'Restore from seed phrase'), + ]), + ]) + ) +} + +UnlockScreen.prototype.componentDidMount = function () { + document.getElementById('password-box').focus() +} + +UnlockScreen.prototype.onSubmit = function (event) { + const input = document.getElementById('password-box') + const password = input.value + this.props.dispatch(actions.tryUnlockMetamask(password)) +} + +UnlockScreen.prototype.onKeyPress = function (event) { + if (event.key === 'Enter') { + this.submitPassword(event) + } +} + +UnlockScreen.prototype.submitPassword = function (event) { + var element = event.target + var password = element.value + // reset input + element.value = '' + this.props.dispatch(actions.tryUnlockMetamask(password)) +} + +UnlockScreen.prototype.inputChanged = function (event) { + // tell mascot to look at page action + var element = event.target + var boundingRect = element.getBoundingClientRect() + var coordinates = getCaretCoordinates(element, element.selectionEnd) + this.animationEventEmitter.emit('point', { + x: boundingRect.left + coordinates.left - element.scrollLeft, + y: boundingRect.top + coordinates.top - element.scrollTop, + }) +} diff --git a/old-ui/app/util.js b/old-ui/app/util.js new file mode 100644 index 000000000..3f8b4dcc3 --- /dev/null +++ b/old-ui/app/util.js @@ -0,0 +1,240 @@ +const ethUtil = require('ethereumjs-util') + +var valueTable = { + wei: '1000000000000000000', + kwei: '1000000000000000', + mwei: '1000000000000', + gwei: '1000000000', + szabo: '1000000', + finney: '1000', + ether: '1', + kether: '0.001', + mether: '0.000001', + gether: '0.000000001', + tether: '0.000000000001', +} +var bnTable = {} +for (var currency in valueTable) { + bnTable[currency] = new ethUtil.BN(valueTable[currency], 10) +} + +module.exports = { + valuesFor: valuesFor, + addressSummary: addressSummary, + miniAddressSummary: miniAddressSummary, + isAllOneCase: isAllOneCase, + isValidAddress: isValidAddress, + numericBalance: numericBalance, + parseBalance: parseBalance, + formatBalance: formatBalance, + generateBalanceObject: generateBalanceObject, + dataSize: dataSize, + readableDate: readableDate, + normalizeToWei: normalizeToWei, + normalizeEthStringToWei: normalizeEthStringToWei, + normalizeNumberToWei: normalizeNumberToWei, + valueTable: valueTable, + bnTable: bnTable, + isHex: isHex, + exportAsFile: exportAsFile, + isInvalidChecksumAddress, +} + +function valuesFor (obj) { + if (!obj) return [] + return Object.keys(obj) + .map(function (key) { return obj[key] }) +} + +function addressSummary (address, firstSegLength = 10, lastSegLength = 4, includeHex = true) { + if (!address) return '' + let checked = ethUtil.toChecksumAddress(address) + if (!includeHex) { + checked = ethUtil.stripHexPrefix(checked) + } + return checked ? checked.slice(0, firstSegLength) + '...' + checked.slice(checked.length - lastSegLength) : '...' +} + +function miniAddressSummary (address) { + if (!address) return '' + var checked = ethUtil.toChecksumAddress(address) + return checked ? checked.slice(0, 4) + '...' + checked.slice(-4) : '...' +} + +function isValidAddress (address) { + var prefixed = ethUtil.addHexPrefix(address) + if (address === '0x0000000000000000000000000000000000000000') return false + return (isAllOneCase(prefixed) && ethUtil.isValidAddress(prefixed)) || ethUtil.isValidChecksumAddress(prefixed) +} + +function isInvalidChecksumAddress (address) { + var prefixed = ethUtil.addHexPrefix(address) + if (address === '0x0000000000000000000000000000000000000000') return false + return !isAllOneCase(prefixed) && !ethUtil.isValidChecksumAddress(prefixed) && ethUtil.isValidAddress(prefixed) +} + +function isAllOneCase (address) { + if (!address) return true + var lower = address.toLowerCase() + var upper = address.toUpperCase() + return address === lower || address === upper +} + +// Takes wei Hex, returns wei BN, even if input is null +function numericBalance (balance) { + if (!balance) return new ethUtil.BN(0, 16) + var stripped = ethUtil.stripHexPrefix(balance) + return new ethUtil.BN(stripped, 16) +} + +// Takes hex, returns [beforeDecimal, afterDecimal] +function parseBalance (balance) { + var beforeDecimal, afterDecimal + const wei = numericBalance(balance) + var weiString = wei.toString() + const trailingZeros = /0+$/ + + beforeDecimal = weiString.length > 18 ? weiString.slice(0, weiString.length - 18) : '0' + afterDecimal = ('000000000000000000' + wei).slice(-18).replace(trailingZeros, '') + if (afterDecimal === '') { afterDecimal = '0' } + return [beforeDecimal, afterDecimal] +} + +// Takes wei hex, returns an object with three properties. +// Its "formatted" property is what we generally use to render values. +function formatBalance (balance, decimalsToKeep, needsParse = true) { + var parsed = needsParse ? parseBalance(balance) : balance.split('.') + var beforeDecimal = parsed[0] + var afterDecimal = parsed[1] + var formatted = 'None' + if (decimalsToKeep === undefined) { + if (beforeDecimal === '0') { + if (afterDecimal !== '0') { + var sigFigs = afterDecimal.match(/^0*(.{2})/) // default: grabs 2 most significant digits + if (sigFigs) { afterDecimal = sigFigs[0] } + formatted = '0.' + afterDecimal + ' ETH' + } + } else { + formatted = beforeDecimal + '.' + afterDecimal.slice(0, 3) + ' ETH' + } + } else { + afterDecimal += Array(decimalsToKeep).join('0') + formatted = beforeDecimal + '.' + afterDecimal.slice(0, decimalsToKeep) + ' ETH' + } + return formatted +} + + +function generateBalanceObject (formattedBalance, decimalsToKeep = 1) { + var balance = formattedBalance.split(' ')[0] + var label = formattedBalance.split(' ')[1] + var beforeDecimal = balance.split('.')[0] + var afterDecimal = balance.split('.')[1] + var shortBalance = shortenBalance(balance, decimalsToKeep) + + if (beforeDecimal === '0' && afterDecimal.substr(0, 5) === '00000') { + // eslint-disable-next-line eqeqeq + if (afterDecimal == 0) { + balance = '0' + } else { + balance = '<1.0e-5' + } + } else if (beforeDecimal !== '0') { + balance = `${beforeDecimal}.${afterDecimal.slice(0, decimalsToKeep)}` + } + + return { balance, label, shortBalance } +} + +function shortenBalance (balance, decimalsToKeep = 1) { + var truncatedValue + var convertedBalance = parseFloat(balance) + if (convertedBalance > 1000000) { + truncatedValue = (balance / 1000000).toFixed(decimalsToKeep) + return `${truncatedValue}m` + } else if (convertedBalance > 1000) { + truncatedValue = (balance / 1000).toFixed(decimalsToKeep) + return `${truncatedValue}k` + } else if (convertedBalance === 0) { + return '0' + } else if (convertedBalance < 0.001) { + return '<0.001' + } else if (convertedBalance < 1) { + var stringBalance = convertedBalance.toString() + if (stringBalance.split('.')[1].length > 3) { + return convertedBalance.toFixed(3) + } else { + return stringBalance + } + } else { + return convertedBalance.toFixed(decimalsToKeep) + } +} + +function dataSize (data) { + var size = data ? ethUtil.stripHexPrefix(data).length : 0 + return size + ' bytes' +} + +// Takes a BN and an ethereum currency name, +// returns a BN in wei +function normalizeToWei (amount, currency) { + try { + return amount.mul(bnTable.wei).div(bnTable[currency]) + } catch (e) {} + return amount +} + +function normalizeEthStringToWei (str) { + const parts = str.split('.') + let eth = new ethUtil.BN(parts[0], 10).mul(bnTable.wei) + if (parts[1]) { + var decimal = parts[1] + while (decimal.length < 18) { + decimal += '0' + } + const decimalBN = new ethUtil.BN(decimal, 10) + eth = eth.add(decimalBN) + } + return eth +} + +var multiple = new ethUtil.BN('10000', 10) +function normalizeNumberToWei (n, currency) { + var enlarged = n * 10000 + var amount = new ethUtil.BN(String(enlarged), 10) + return normalizeToWei(amount, currency).div(multiple) +} + +function readableDate (ms) { + var date = new Date(ms) + var month = date.getMonth() + var day = date.getDate() + var year = date.getFullYear() + var hours = date.getHours() + var minutes = '0' + date.getMinutes() + var seconds = '0' + date.getSeconds() + + var dateStr = `${month}/${day}/${year}` + var time = `${hours}:${minutes.substr(-2)}:${seconds.substr(-2)}` + return `${dateStr} ${time}` +} + +function isHex (str) { + return Boolean(str.match(/^(0x)?[0-9a-fA-F]+$/)) +} + +function exportAsFile (filename, data) { + // source: https://stackoverflow.com/a/33542499 by Ludovic Feltz + const blob = new Blob([data], {type: 'text/csv'}) + if (window.navigator.msSaveOrOpenBlob) { + window.navigator.msSaveBlob(blob, filename) + } else { + const elem = window.document.createElement('a') + elem.href = window.URL.createObjectURL(blob) + elem.download = filename + document.body.appendChild(elem) + elem.click() + document.body.removeChild(elem) + } +} diff --git a/old-ui/css.js b/old-ui/css.js new file mode 100644 index 000000000..21b311c28 --- /dev/null +++ b/old-ui/css.js @@ -0,0 +1,30 @@ +const fs = require('fs') +const path = require('path') + +module.exports = bundleCss + +var cssFiles = { + 'fonts.css': fs.readFileSync(path.join(__dirname, '/app/css/fonts.css'), 'utf8'), + 'reset.css': fs.readFileSync(path.join(__dirname, '/app/css/reset.css'), 'utf8'), + 'lib.css': fs.readFileSync(path.join(__dirname, '/app/css/lib.css'), 'utf8'), + 'index.css': fs.readFileSync(path.join(__dirname, '/app/css/index.css'), 'utf8'), + 'transitions.css': fs.readFileSync(path.join(__dirname, '/app/css/transitions.css'), 'utf8'), + 'first-time.css': fs.readFileSync(path.join(__dirname, '../mascara/src/app/first-time/index.css'), 'utf8'), + 'react-tooltip-component.css': fs.readFileSync(path.join(__dirname, '..', 'node_modules', 'react-tooltip-component', 'dist', 'react-tooltip-component.css'), 'utf8'), + 'react-css': fs.readFileSync(path.join(__dirname, '..', 'node_modules', 'react-select', 'dist', 'react-select.css'), 'utf8'), +} + +function bundleCss () { + var cssBundle = Object.keys(cssFiles).reduce(function (bundle, fileName) { + var fileContent = cssFiles[fileName] + var output = String() + + output += '/*========== ' + fileName + ' ==========*/\n\n' + output += fileContent + output += '\n\n' + + return bundle + output + }, String()) + + return cssBundle +} diff --git a/old-ui/design/00-metamask-SignIn.jpg b/old-ui/design/00-metamask-SignIn.jpg new file mode 100644 index 000000000..2becdb032 Binary files /dev/null and b/old-ui/design/00-metamask-SignIn.jpg differ diff --git a/old-ui/design/01-metamask-SelectAcc.jpg b/old-ui/design/01-metamask-SelectAcc.jpg new file mode 100644 index 000000000..239091a98 Binary files /dev/null and b/old-ui/design/01-metamask-SelectAcc.jpg differ diff --git a/old-ui/design/02-metamask-AccDetails.jpg b/old-ui/design/02-metamask-AccDetails.jpg new file mode 100644 index 000000000..d7d408ffc Binary files /dev/null and b/old-ui/design/02-metamask-AccDetails.jpg differ diff --git a/old-ui/design/02a-metamask-AccDetails-OverToken.jpg b/old-ui/design/02a-metamask-AccDetails-OverToken.jpg new file mode 100644 index 000000000..f26ff31e8 Binary files /dev/null and b/old-ui/design/02a-metamask-AccDetails-OverToken.jpg differ diff --git a/old-ui/design/02a-metamask-AccDetails-OverTransaction.jpg b/old-ui/design/02a-metamask-AccDetails-OverTransaction.jpg new file mode 100644 index 000000000..8a06be6b9 Binary files /dev/null and b/old-ui/design/02a-metamask-AccDetails-OverTransaction.jpg differ diff --git a/old-ui/design/02a-metamask-AccDetails.jpg b/old-ui/design/02a-metamask-AccDetails.jpg new file mode 100644 index 000000000..c37e0f539 Binary files /dev/null and b/old-ui/design/02a-metamask-AccDetails.jpg differ diff --git a/old-ui/design/02b-metamask-AccDetails-Send.jpg b/old-ui/design/02b-metamask-AccDetails-Send.jpg new file mode 100644 index 000000000..10f2d27fd Binary files /dev/null and b/old-ui/design/02b-metamask-AccDetails-Send.jpg differ diff --git a/old-ui/design/03-metamask-Qr.jpg b/old-ui/design/03-metamask-Qr.jpg new file mode 100644 index 000000000..9c09de42f Binary files /dev/null and b/old-ui/design/03-metamask-Qr.jpg differ diff --git a/old-ui/design/05-metamask-Menu.jpg b/old-ui/design/05-metamask-Menu.jpg new file mode 100644 index 000000000..0a43d7b2a Binary files /dev/null and b/old-ui/design/05-metamask-Menu.jpg differ diff --git a/old-ui/design/chromeStorePics/final_screen_dao_accounts.png b/old-ui/design/chromeStorePics/final_screen_dao_accounts.png new file mode 100644 index 000000000..805cc96b6 Binary files /dev/null and b/old-ui/design/chromeStorePics/final_screen_dao_accounts.png differ diff --git a/old-ui/design/chromeStorePics/final_screen_dao_locked.png b/old-ui/design/chromeStorePics/final_screen_dao_locked.png new file mode 100644 index 000000000..9d9e33930 Binary files /dev/null and b/old-ui/design/chromeStorePics/final_screen_dao_locked.png differ diff --git a/old-ui/design/chromeStorePics/final_screen_dao_notification.png b/old-ui/design/chromeStorePics/final_screen_dao_notification.png new file mode 100644 index 000000000..d56a5ce62 Binary files /dev/null and b/old-ui/design/chromeStorePics/final_screen_dao_notification.png differ diff --git a/old-ui/design/chromeStorePics/final_screen_wei_account.png b/old-ui/design/chromeStorePics/final_screen_wei_account.png new file mode 100644 index 000000000..d503ff301 Binary files /dev/null and b/old-ui/design/chromeStorePics/final_screen_wei_account.png differ diff --git a/old-ui/design/chromeStorePics/final_screen_wei_notification.png b/old-ui/design/chromeStorePics/final_screen_wei_notification.png new file mode 100644 index 000000000..3560c51ff Binary files /dev/null and b/old-ui/design/chromeStorePics/final_screen_wei_notification.png differ diff --git a/old-ui/design/chromeStorePics/icon-128.png b/old-ui/design/chromeStorePics/icon-128.png new file mode 100644 index 000000000..ae687147d Binary files /dev/null and b/old-ui/design/chromeStorePics/icon-128.png differ diff --git a/old-ui/design/chromeStorePics/icon-64.png b/old-ui/design/chromeStorePics/icon-64.png new file mode 100644 index 000000000..7062cf4f1 Binary files /dev/null and b/old-ui/design/chromeStorePics/icon-64.png differ diff --git a/old-ui/design/chromeStorePics/metamask_icon.ai b/old-ui/design/chromeStorePics/metamask_icon.ai new file mode 100644 index 000000000..27400c5a4 --- /dev/null +++ b/old-ui/design/chromeStorePics/metamask_icon.ai @@ -0,0 +1,2383 @@ +%PDF-1.5 % +1 0 obj <>/OCGs[5 0 R]>>/Pages 3 0 R/Type/Catalog>> endobj 2 0 obj <>stream + + + + + application/pdf + + + metamask_icon + + + Adobe Illustrator CC 2015 (Macintosh) + 2016-06-15T14:23:12-04:00 + 2016-06-15T14:23:12-04:00 + 2016-06-15T14:23:12-04:00 + + + + 240 + 256 + JPEG + /9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAADwAwER AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE 1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp 0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo +DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 FXnP5r/mvB5Tg/RmnAT6/cJyUMKx28bVAkf+ZjT4U+k7UDYuo1HBsObl6bTce5+l5X+Wf5t6jonm KZtfu5rzTNVcG+lkZpHilACLOAamgUBWC/sgUrxAzEwakxl6uRczUaYSj6eYfS9vcQXEEdxA6ywT KskUimqsjCqsCOoIObUG3UkUvxQ7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY q7FXYq7FXYq7FXln5rfnHb+X1l0bQnWfXCCs0+zR2tfEGoaTwXoO/hmJqNTw7Dm5mm0plvL6fvfO U889xPJcXEjTTzM0ksshLO7saszMdySTUk5qybdsBSzAl7R+Rv5ni0dPKutTqto5ppNw/KqyOwH1 c0BHFuVVJpTpvUUz9Jnr0n4Ov1mnv1D4ve82LrHYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq 7FUn1Pzl5W0yF5r3VLeNI9no4kYfNU5N+GY89XijsZC/mfkHIhpMstxE18h8ynCmqg7iorQ7HMhx 3Yq7FXYq7FXYq7FXjf5v/nG2nPL5e8tXAN9Ro9Rv039A7D04WBp6nUM1Ph7fFXjg6nU16Y83P0ul v1S5PAWZmYsxJYmpJ3JJzWu0axV2KuxV9Ifkr+Zq67py6FrF1y121+G3eUjlcwKtQeRPxyIAeXci jbnkc2mlz8Qo83U6vT8J4h9L1PMxwnYq7FXYq7FXYq7FXYq7FXYq7FXYqlN95s8t2I/0jUYQQaFE b1HHzWPk34Zi5Nbhh9Uh9/3OVi0Waf0xP3fex7UfzX0WEOtjBNdSCoR2AjjPgak8/wDhcwcvbWIf SDL7B+v7HOxdi5T9REftP6vtYre/mf5ouD+5eK0UdoowxPzMnqfhmsydsZpcqj7h+u3aY+x8Eedy 95/VTFdc803n1dptVv5powSVjeRmqx7IhNMxPEy5jRJPx2cwY8WEWAB8N0l8gRXnm/z/AKXazpXT 7WX65NCo5II4PjHqVrXk3FDX+btXNtodLETDqddqiYH7H1LnQPOuxV2KuxV2KuZlVSzEBQKknYAD FXhX5t/nOsyzaB5XuCEDBbzVoXZSSrA8Ld0I2qKM/foNt81+o1X8Mfm7LTaT+KXyeI5r3YuxV2Ku xV2KqtpdXNpdQ3VrI0NzA6yQyoaMroaqwPiCMINboIsUX1j+XH5g6f5w0WOcNHDq0I439irbqwoD IiklvTaux7dK1GbnBmEx5ukz4DjPky3Lmh2KuxV2KuxV2KuxVKb/AM2eW7CoudQhDA0KI3qMD7rH yYZjZdbhh9Uh9/3OVi0Waf0xP3fex6//ADY0OHktnbzXTKaKxpFGw8QTyb/hcwMnbWIfSDL7B+Pg 5+PsXKa4iI/afx8WO3/5ra9OJEtYIbVG2RqNJIo/1iQv/C5gZe2sp+kCP2n8fBz8XYuIVxEy+wfj 4sVvdY1a+FLy8muFBLBZJGZQT4KTQZrMmfJP6pE/F2ePBjh9MQPghMqbXYqler+YLPTgUJ9W57Qq en+se2X4dPKfuaMueMPewW+vrm9uGnuH5Ox2G/FR/KoPQZtYQERQdZOZkbL3L/nG7y8Y7PVPMEqj lOy2VqxBDBEpJKQSPsszINu6nNpoYbGTqdfPcRe1ZnuvdirsVdirsVeF/n1+Y96l1N5O04+lCERt Vn35uXAkWBfBOJVmI+1XjsAeWv1ec3wD4uy0eAVxn4PEM17sXYq7FXYq7FXYq7FU18seZNU8uaxD qumymOeKqsBQh0YUZCGDDceI2O+ESlH6TRYmEZbSFh7bbfmL5mubeO4iv6xSqHQ+lD0YV/kzVy7U 1MTRl9kf1Owj2XpiLEftP61T/Hvmv/lt/wCSUP8AzRkf5W1P877I/qZfyTp/5v2n9bv8e+a/+W3/ AJJQ/wDNGP8AK2p/nfZH9S/yTp/5v2n9bv8AHvmv/lt/5JQ/80Y/ytqf532R/Uv8k6f+b9p/W7/H vmv/AJbf+SUP/NGP8ran+d9kf1L/ACTp/wCb9p/W7/Hvmv8A5bf+SUP/ADRj/K2p/nfZH9S/yTp/ 5v2n9bHtW1/WtUeuoXTz8eiGioCNtkUKv4ZDNqsmX6zbdh0uPF9ApL8ob3Yq7FXYq7FWO695pW0d rWyo9wtRJKd1Q+A8WH3ZmYNLxby5OJn1PDtHmw6SR5JGkclnclmY9STuTmzArZ1xN7uhhlmmSGJS 8sjBI0HUsxoAPpwhiS+zvLGhxaF5e0/SIiGFlAkTOoIDuB8b0JNOb1bN5jhwxAdBknxSJ70zybB2 KuxV2KpX5o12HQfL2oaxNxK2UDyKjHiHkpSOOu9ObkL9OQyT4Yks8cOKQHe+Nr6+u7+8mvLyVp7q 4cyTTOaszNuSc0ZJJsu/AAFBRwJdirsVdirsVdirsVdirKvI2tmC6OmzN+5uDWEmlFkp03/mp9/z zX67BY4hzDm6PNR4T1Z5mpdo7FXYq7FXYqg7laSn33y2PJgVLJIdirsVWu6IjO7BUUEsxNAAOpJO IFqTTD9c81yT1gsGaKIH4px8LtT+Xuo/HNlg0gG8ubrs2qJ2ixzM1w3Yqzz8k/L66z5/s2kAMGmK 2oSAkgkwkCKlO4ldDTwBzJ0sOKfucbVz4YHz2fU+bd0rsVdirsVdirxT/nIzzWi2ll5ZtZ1Mkj/W dRjQnkqoB6KPTajli9D/ACqcwNbk2EQ7DQ49zIvB81zs3Yq7FXYq7FXYq7FXYq7FW0d0dXRirqQV YGhBG4IIxItQXp3ljWjqunc5Cv1qI8J1Xb/Van+UPxrmh1WDw5bcnc6fNxx35pvmO5DsVdirsVQ1 2v2W+gnJwYlD5YxdiqheXttZwGe4cRxjap6k+AHc5KEDI0GM5iIssE1fzBeakeB/dWw6Qqevux7n Nth08Ye91eXPKfuSzL2h2KuxV9If84/eVk03ys+tyEm51lqhSKcIYHdEArv8Zq3uKZtdHjqN97qN bkuVdz1PMtw3Yq7FXYqp3V1b2ltNdXMgit4EaWaVjRVRByZifAAYCaSBez418169Nr/mPUdYl5Vv Z2kjVyCyRVpEhIp9iMKv0Zo8k+KRLv8AHDhiB3JVkGbsVdirsVdirsVdirsVdirsVTPy7q50vU45 2J9B/guFHdD36H7J3/DKNTh8SFdejdgy8Er6PUYpY5okljblHIoZGHQqwqDmhIINF3QNiwuwJdir sVUrlaxH23yUeaCg8tYJfq2t2Wmx/vW5TleUcC/abtv/ACj3OXYsEp8uTVlzRhz5sD1DULm+uGnu GLE/ZX9lR/KozbY8YgKDqsmQyNlDZNg7FXYqiNN0+51HUbXT7UBrm8mjggUmgLysEWp7bnDEWaRK VCy+0tM0+307TbXT7YEW9nDHbwgmp4RKEWp+QzfRFCnnpSs2UThQ7FXYq7FXmX59ebIdL8ovpEMw Goauyx+mrFXW2U8pH2/Zbj6dD15HwOYmryVGupczR4uKd9A+ac1Tt3Yq7FXYq7FXYq7FXYq7FXYq 7FXYqzXyJrSem2lztRgS9sSQAQT8SD3ruPpzV6/Bvxj4ux0Wb+EsxzWuwdirsVadeSlfEEYhDE9b 8zwWLNb24E10pKuK/AhHjTqa9s2ODSme52Dh5tSI7DcsJmmlmkaWVy8jmrOxqTm0AAFB1hJJsrMK HYq7FXYq9S/5x+8qvqXmp9bkIFtoq1CEV5zTo6IBXb4RVq9jTMzR47lfc4WtyVHh730jm0dS7FXY q7FXYq+X/wA+dQmuvzGu4JPsWMFvBF/qtGJ/+JTHNTq5Xk9zudHGsY83nmYrlOxV2KuxV2KuxV2K uxV2KuxV2KtqrMwVQSxNABuSTirN/Lfl9LBVurhQ1626g7iMeA/yvE/R89VqdRx7D6XZ6fT8O55s tUggEdDuM1zmt4pdirsVYZ5s8s+pLJfWS0lNXmhH7fcsv+V4jv8APrs9JqaHDJ1+p01+qLDM2brn Yq7FXYq7FX0n/wA48to48kyR2cwfUPrLyanEdmjZvhiA2rwMaAj35ZtdHXBtzdRrr49+XR6hmW4b sVdirsVdir5I/Ne/+vfmJrs1QeFx6G3/AC7osP8AzLzTag3Mu800axhieUN7sVdirsVdirsVdirs VdirsVdirMPLHl8wAXt4hE5/uYmFCg/mI8f1ZrdVqL9MeTsdNgr1HmyXMJzEXatWOndf1ZVMbswr ZFLsVdiqGu13VvoOTgWJYV5o8vFS9/aL8O7XEQ7eLj28c2ml1H8MnXanT/xBi+Z7guxV2KuxVP8A yLf+abLzPZP5ZDyarI4SO3XdZVO7JKKgenQVYkjiPiqKVFuKUhIcPNqzRiYni5PsKIymJDKFWXiP UCElQ1N6EgEivtm7dCuxV2KuxV4P+Zn5i/m7o189tNbRaNYszi2urVBOsqEkD/SJAw5bV2VG8QNs 12fNlie4Oy0+DFId5eL3FxPczyXFxI01xMzSTSuSzu7GrMzHckk1JzBJt2AFLMCXYq7FXYq7FXYq 7FXYq7FXYqyvyv5fZWF9ex0IobaNvv5kfq/2s1+q1H8Mfi5+mwfxS+DKswHOdiqrbuVkA7Nsf4ZG Q2SEZlTN2KuxVTnTlEfbcfRhid0FBZcwYd5k8uNAz3tkg+rdZYl6oe7KKfZ/V8umy02pv0y5uu1G nr1R5MbzNcN2KuxVnH5Z/mdP5MuXjayhudPu5Fa9cJS6CAEUjkqoIFa8W2/1ak5kYM/B02cbUafx Ou76X8s+ZdL8x6RDqumGU2s32TLG8R5DZl+IUbi1VJQlajrm1hMSFh1GTGYGimmTYOxV2KqN9HZS Wk0d8sT2boVuEnCmIodiHDfDT54DVbpF3s+b/wAyfI/kCy9fU/LvmWzJZix0f1BOQSWJWF4OZXsq q6/N81efFAbxkPc7bBmmdpRPveZZiOY7FXYq7FXYq7FXYq7FXYqybyz5cMhjv7xaRD4oYSPteDN/ k+Hj8uuDqdTXpi5um09+osvzXOwdirsVdiqYIwZA3iMoIZt4pdirsVS9l4sV8DTLg1tEAih6YVYT 5k8vGzY3dsC1qxJdf99knpt+z4ZtNNqOLY83W6jT8O45JBmW4jsVZP8Alp5c07zH5z0/SNQd1tZz I7rH1f0o2l4V/ZDcNzl2CAlMAtOomYQJD65gggt4I7e3jWGCFRHFFGAqIiiiqqjYADYAZugKdGTa /FDsVdirHfNvkDyv5rjUava87iNGSC7iYxzRhvBhs1DuA4I9sqyYYz5tuLNKHJ4v5q/5x58xWBlu NAuE1S1G6270iuQCTtv+7fitN+QJ7LmDk0Uh9O7sMeuifq2eUzQzQTPDMjRTRMUkjcFWVlNCrA7g g5hkU5oNrMCXYq7FXYq7FXYq7FWR+XfLJuAl5eDjBUGKEjdx4nwX9fy64Wo1NemPNzNPpr9UuTMs 1rsXYq7FXYq7FUVavVSh6jcfLK5hkFfIMnYq7FUHdLSWviK/wyyHJgVLJoWuiOjI4DIwKsp3BB2I OINKRbB/MPl19Pb6xb1ezY713MZPY+3gfo+e10+o49j9Tq9Rp+DcckkzKcZmP5P3EsH5k6G8cTTM ZZIyqgkhZIXRm27IrFj7DL9Mf3gcfVC8ZfWWbl0jsVdirsVdirwr87POX5jaTqj6dFIdP0O4VTaX dorK8o6lXuDusgZTVUI+HrUHfX6rLOJrkHZaTFjkL5l4jmvdi7FXYq7FXYq7FXYqn/lzy6t8purr kLZTREG3Mg77/wAvbbMTU6jg2HNy9Pp+Lc8maqqooVQFVRRVGwAHYZqyXZAN4q7FXYq7FXYqvhfj Ip7dD9ORkNkhHZUzdirsVULpKoG/l/jkoFiULlrF2KrJYYpozHKiyRt9pGAIP0HCCQbCCAdiwTzD obabcB4qm0lJ9M7nif5Sf1ZttPn4xvzdXqMPAduT6E/Jz8tofLejx6pqMStrt+iyNzSj20bLtCOY DK9G/edN/h7VO+02DhFnmXn9Vn4zQ+kPSMynEdirsVdirsVS7zBoGl6/pM+l6nCJrScUI6MrD7Lo ezKehyM4CQos4TMTYfKfn3yJq3lDWHs7pWkspCTYX1KJMgp4Vo61oy9vlQ5p82EwNF3WHMMgsMYq MpbnVGKuxVvFXYqnnlvQDfSfWbhSLRDsP9+MOw9h3zF1Oo4BQ5uVp8HEbPJm6IiIqIoVFACqBQAD YADNUTbswKXYq7FXYq7FXYq7FXYqjoX5xg9+h+eUyFFmF+BLsVWyLyRl8RtiChAZewdirsVTjyfZ JeeZ9NidOarOkpUio/dH1Afo45mdnx4s8R5/du4faE+HBI+X37Pds7N4t2KuxV2KuxV2KuxV5Z+Y esC91gWcZBhsKpUb1kahf7qcfozke2dTx5eEcoff1/U9b2PpuDFxHnP7un62K5p3buxV2KuxV1Bi qFukowcdDsfnlkCxKhk2LsVdirsVdirsVdirsVRFo/xFfHcZCYZBE5WydirsVQEq8ZGHv+vLgdmB W4UOxVmH5WQCTzOzn/dFvI4+kqn/ABvm27GiDm90T+h1PbUiMI85D9L17OpeVdirsVdirsVdiqG1 K/i0+wuL2X7ECFyK0qR0Ue7HbKs+UY4GZ6Btw4jkmIjqXh000k0zzSsWkkYu7HqWY1Jzz+UjIknm XvYxEQAOQWYGTsVdirsVdiq2ROaFfHp88INIKAIIJB6jrlrB2FXYq7FXYq7FXYq7FV0bcXDeBwEJ CPylm7FXYqhbtTyDdiKfTlkCxKhk2LsVZ7+UduW1S+uO0cCx/TI4P/MvN32HC5yl3Cvn/Y6PtydQ jHvN/L+16jnSPNuxV2KuxV2KuxVhP5l60IrOPSY6+rccZZj29NSeI+l1r9GaHtzUgQGMc5bn3f2/ c73sTTEzOQ8o7D3/ANn3vOM5d6d2KuxV2KuxV2KuxVCXiFT6iqWB+1Sn8csgejEhBfW4/Bvw/rlv Chr64n8px4Va+uD+T8ceBWvrv+R+P9mHgVv67/kfj/ZjwK19cP8AL+OPArX1yT+UY8KtfXJfBfx/ rjwhU2s5Ge3Ut9rv/DMeYosgr5FLsVUL3l9WZlFWX4hX26/hkoc0FKDdSnwHyGZPCGKhZ6oLy3We CTlGxIBoBupKnt4jLMuA45cMhu1Yc0ckeKPJ6F+UmpSxapdQMapPGrGvjG1BT/kYc2vYs6nKPeL+ X9rqO3IeiMu418/7HsA3GdE807FXYq7FXYq7FXi/mfVP0nrl1dA1i5cIaGo9NPhUj/Wpy+nOF7Qz +LmlLpyHuH4t7jQYPCwxj15n3n8UlWYbmOxV2KuxV2KuxV2KuIB2PTFUDdWaV5caqe/cZbCbAhAy WjCpQ8h4d8tElUCCDQ9ckrWKpZrHmHTtKUeuxeY9II6F6eJBIoMztJoMmf6dh3nk4Os7Rxaceo2e 4c2Far5x1a+5JE31W3bb04z8RHu/X7qZ0ul7IxYtz6pef6v7XltX2zmy7A8EfL9f9id+R9d9WP8A Rc5q8YLW7kjdR1Tfeo6j2+WaztrRcJ8WPI8/1/jr73adh6/iHgy5jl7u78dPcy5RyYL4mmc+9GnN o1HK9iP1ZjzCQisrZOxVp1DoynowIPyOIKscl/dc+ewSvL2p1zNiL5NZNCy888na79QvDa3DgWlw d2Y0CPTZvDfofo8M67tfQ+LDiiPXH7Q8b2Nr/CnwSPol9h7/ANb2PytcvZ6rYSqwX96odu3FzRq/ Qc5fRZTDPEjvr57PT6/GJ4ZA91/J79A3KJT7Z2bxS/FXYq7FXYqk/m7VRpug3UyvwnkX0oN6Hm+1 V91FWzC7Rz+FhkevIe8/i3N7PweLmiOnM/D8U8azhnt3Yq7FXYq7FXYq7FXYq7FXEAih6Yqg54Ch 5L9j9WWRlbAhQeNHFGFcmChJ9b0DXL6ALpN8lt2kVwysfcSLyI+hfpzP0WqwY5XliZfju/b8HB12 DPkjWKQj+O/9nxYTe/l55tilc+gt11Zpo5VPInc7OUcn6M6XD23pSBvw+RH6rDzGXsXUgnbi8wf1 0Uiu9K1SzAa7s5rdTsGljZAfkWAzZYtTjyfTKMvcQ67Jp8kPqiY+8KNrczWtxHcQNwliYMje4yeX HGcTGXIscWWWOQlHmHrei39tqUMVzAQyMKuvdGAqVb3GcDqsEsMjGX9vm+g6bUxzQE4/2eSco3Fw 3gcwyHITAEEAjodxlLJ2KXYqx/X7J5UubeJgj3MThHaoVWcFakgHau+Z2kyiMoyPKJH2OPqMZnjl EcyCEB5f/LjSLBEm1AC+ux1Dbwqd+iftf7KvyGZ2t7dy5DUPRH7fn+p1ej7DxYxc/XL7Pl+tkDoI 3KqAoX7IGwA7UzUg3u7iq2fQWlzGfTbadl4mWJHK+HJQaZ30JcUQe8PAzjwyI7iiskxdirsVdirz L8y9S9fV4rFSeFmnxj/iySjH/heOcp25n4sogP4R9p/ZT1PYmDhxmZ/iP2D9tsPzSO7dirsVdirs VdirsVdirsVdiriARQ9MVQc8BT4hun6ssjK2BDdq1JCP5h+IxmNkhF5WydiqAu9A0O8Ltc2FvLJJ 9uQxrzP+zpy/HMnHrc0KEZyAHnt8nGyaPDO+KEST5b/NRsPLOlaYH/R0RgEn205u6kjvRy1D8snn 12TNXiG68h+hjp9Hjw2MYoHzP6VVlZTRhQ5SC5CJt5l4hCaEdK98hKKQVfIMnYqo3dstxEV2DjdG 8DkoSooKhp8jrW2mqJE3UH+XJZB1ChddLSWviMYcmJfQsESwwRxL9mNQo+QFM9BAfPyV+FDsVdiq jeXdvZ2st1cOEhhUs7HwGQyZIwiZS2AZ48cpyEY7kvD7+7kvL2e7kFHuJGkYDoORrQfLOAzZDOZk ept73FjEICI6ClDK2x2KuxV2KuxV2KuxV2KuxV2KuxVxAIoeh64qhZIjE4dd0B+7LAbY1SKBBAI6 HplbJ2KuxV2KrJI1kWh69jhBpBCElhaM77jscsErYkK8NwGor/a7HxyEopBV8iydiqhcW5kKyRkL Mn2GPT3ByUZVz5IbVDcyQLTizuI2U9mYgZZijcuEdWGSXDEnufQeegPn7sVdirsVYb+ZmqGDS4dP Q/Fdvyk6f3cRBp47tT7s0fbmfhxiA/iP2D9tO67EwcWQzP8ACPtP7LeaZyr1TsVdirsVdirsVdir sVdirsVdirsVWvJGgq7BR2qaYgEoQc2qW4BVVMn4A/x/DLRiKLVIbscAGQjbpWtPbtgMFtEJIj/Z NfbvlZFJtdil2KuxVogEUIqMUIWa3K1ZN18O4yyMkEKkFxyoj9ex8cEoqCr5Bk7FUTpEdv8Apmxe YqkQuYWmZjReIcVJJ2+z3zI0kgMsCeXEPvcfVRJxSA58J+57pnfPBuxV2KuxV5B531M3/mK4INYr b/R46eEZPL/hy2cV2rn8TOe6O3y/bb2fZeHw8A75b/P9lJDmudi7FXYq7FXYq7FXYq7FXYqoSXtq nWQE+A3/AFZIQJRaEk1c7iOP5Fj/AAH9csGHvRaFkv7t+shA8F2/VvlgxgLagSSanqckhVtY+UnI 9F3+nBIqjcrQ7FVRZ5V/aqPA75ExCbVUuwdnFPcZEwTauro32SDkCEt4pdiqhNbhqsmzeHY5KMmJ DoJzXhJs3YnDKPUKCr5Bk7FWd+RvOPp+npOoyfu9ltJ2/Z7CNj4fy+HTpnQ9k9pVWKZ/qn9H6vk8 92r2dd5YD3j9P6/m9CzpXnHYq7FXhnnLS30vzHeW4BWF3M1vQED05PiAX2U1X6M4vX4PDzSHTmPj +Ke00GfxMMT15H4fi0l5N4nMOnMdybxONK7kfHFXVPjirVT44q6p8cVdU+OKuqcKrZEEiFT9B8Di DSoB0ZGKt1GWgpW4q7FWwCTQdT0xVHxR+mgXv1Jysm0L8CuxV2KuxV2KqiXEq96jwORMQm1dbpD9 oFfxGQMCm1VWVhVSD8sjSVssSyDfY9jhBpSFkbsh4S9f2W7HCRfJVbIpdir0fyR5zW4WPStRci5A 421wxr6ngjH+bw8fn16jsvtTjrHk+roe/wAvf9/v58x2n2Zw3kx/T1Hd5+77vdym2b50TsVef/m1 pJktbTVY1FYCYJyAa8X3Qk+CtUf7LNH21guImOmx/H45u97Ez1IwPXcfj8cnmOc49G7FXYq7FXYq 7FXYq7FXYqpTw+otR9odMINKgiCDQ9csS1iqItI6vzPRenzyMiqLyCHYq7FXYq7FXYq7FXYq4Eg1 HXFVVLmRdj8Q9+uRMQm1UXETijinz3GR4SE2vRgopXkg6N1p88iUoTWNf0bRoBNqd3Hao1eAc1Zq UrxQVZqV3oMtw6fJlNQFtWbUQxC5mmMXn5w+TbYqYJbi8J7wRFeP/I4xfhmwx9i6g86j7z+q3Ayd sYByuXuH66ehfl//AM5Q+UtVuk0rzAH0mT4Y7XUp6GGToo9dgW9JjWpY/B1qV79Tp4zEAJkGQeX1 BgZkwFRe3wzRTRJNC6yRSANHIhDKyncEEbEHL2hC6xpcGq6ZcafOSIp1oWHUEEMp+hgDlWfCMkDA 8i24MxxTExzDwG5t5ra5ltpl4zQO0ci9aMh4kfeM4ecDEkHmHuYTEoiQ5FTyLJ2KuxV2KuxV2Kux V2KuxVDXMNayL/shkolKGAJIA6nYZNUwRAihR2yolC7FXYq7FXYq7FW1VmPFQWJ6AbnEC+Skgc0V DpGpzbpbPTxYcR/w1MyIaTLLlEuPPV4o85BEDy3rJNDBT3Lp/A5aOzs3837Q1HtHD/O+wq48pamR UvCPYs38Fy4dk5e+P4+DSe1sXdL7P1q8Xk+cj97cqp/yVLfrK5ZHsiXWX4+xql2vHpH8farR+Tog f3l0zDwVAv6y2Wx7IHWX2Ncu1z0j9quvlLTlIPqzVH+Uv/NOWfyTi75fZ+pq/lbL3R+39b5x/OyS VfzBvrLmWt7JII7ZDT4VeFJW6UrV5Cc2uk00MUKiHV6rUTyyuRYJmS4zsVfU/wDziJp/mFdA1bUJ 72QaC8/oWOnHiUNwqq00+68h8JRBxeh+LkKgHCgvoLFDx/8AM3SBZeYfrMakQ36erWlF9RfhkA8e zH55yna+Dgy8Q5S+/r+v4vV9kZ+PFwnnHb4dP1fBiOat2rsVdirsVdirsVdirsVdiqvaWF9euUtL eW4cdViRnI+fEHJ48Up/SCfcwyZYw+oge9PY/wArfMqQrdskahhX0ORaVK+KqD+GbQdkZjGzQdbL tnCDQstDybIrFJboJKv2k4EkfOrKckOxz1l9jWe2B0j9v7FaLyfbj++uHf8A1AF/XyyyPZEesj+P m1y7Xl0iPv8A1Ky+U9MBqXlYeBZf4KMsHZWLvl+Pg1HtXKekfx8VceW9G/5Z6+/N/wDmrLv5Ow/z ftP62r+Uc3877B+pXTSNLQUFrER/lKGP3tXLY6TEP4R8mqWryn+I/NWis7SI1igjjPiqgfqGWRww jyAHwapZpy5kn4q2WNbsVdirsVdirsVdir5U/O7/AMmdrP8A0bf9QsWZEOTRPmwbJMU28p+XL3zL 5l03QbIH6xqNwkAcKX9NWPxysq78Y0q7ewOKv0B8teXNJ8t6FZ6HpEPoafYpwgjJLHclmZierMzF ifE4WKZYqxn8wtFj1Hy7PMIw11YqZoHrSiggyj6UB28QM13amAZMJPWO/wCv7HY9l6g48wH8Mtv1 fa8XzkXr3Yq7FXYq7FXYqmOm+Xdc1Ir9SspZkbYS8eMe3/FjUT8cvxaXLk+mJP3fNx82qxY/qkB9 /wAubK9I/KjUpZEfVJ0t4OrRRHnL8q04D51ObTB2LMm8hoeXP9X3usz9tQArGLPny/X9zL9N/L3y tYgH6r9akH+7Lk+pX5rtH/wubTF2Zgh0s+e/7PsdVm7Tzz60PLb9v2sghhhhiWKFFjiQUSNAFUD2 A2zPjEAUOTgSkSbPNfhQo3NnaXScLmFJV3oHANK+HhjSQUovPKNhIpNo720gHwgMXSvuG5fgcrOM MxkKQ3fl7zBa1IjW6Qb8o9zT/V+E/cMgcZbBkCXNdCNzHNG8Ug2ZWFCCPHvkKZ2vW4gbo4+nb9eB VTFLsUOxV2KuxV2KuxVpnVBViAPE4q8U89flBq3mfzvf6yt/b2un3Xo8Kh3mAjhSNqpRF6pt8eWx nQa5Qsr7b/nH3yssai51C+llH2mjaKNT/sTHIR/wWPiFfDD178qfyf8AKnli6/Ttrp3p35jMVrcT SPI4jcDm4ViVUsNgwANKjocnC+rXOuj1DJsHYq0yqylWAZWFGU7gg9sVeBa/pbaXrN3YN0gkIQ+K H4kP0qQc4fVYfDySj3H+x7nS5vExxl3j+1L8ob21VmYKoJYmgA3JOICkp5p3kjzRfjlFYPHHt8c9 IhuKggPQn6Bmbi7OzT5Rr37OFl7RwQ5yv3bsp0z8o3qj6nfLQN8cNupNV9pG40/4DNli7E6zl8B+ v9jrM3bnSEfif1ftZlp3lLy5p9Da2EQdSGWRx6jgjuGfkR9GbbFosOP6Yj7/AL3U5dbmyfVI/d9y bZlOK7FXYq7FXYq7FXYq7FVKe1tbheM8KSgdA6huvz+WNKCkWoeSdNnFbVjav4CrqfoJr+OQOMNg yFILvylrlpVolE6AVLQtv16cTRvuyswLYMgSx5b23k9OZWRx1SRSp/GhyBDMFUXUF/aQj5Gv9MaV VW7ganxUJ7EYFVVZWFVII8RviriQBUmgHUnFUNNfINo/iPiemGlQTu7mrmpxVrFWReVfLr3cyXt0 g+poaorb+ow26fyg9a/LxyyEba5zrZneXNDsVdirsVYV538iXeuajBe2Uscb8PSnEpIFFJKsOIap 3pmo7Q7OlmmJRIG1G3cdndpRwwMZAnexShp35S6ZEQ1/eS3J2PCICJfcGvMn6KZDF2JAfVIy+xnl 7bmfpiI/b+plmk+X9H0lWXT7VYOf22BLMfYsxZqfTmzwabHi+gU6vPqcmX6zaYZe0OxV2KuxV2Ku xV2KuxV2KuxV2KuxV2KuxVRu7K1vITDcxiSM9j/AjcYCLSDSQ3vkbTpSWtZHtif2f7xfuJDf8NkD jDMZCkV55O1m3HJEW4UVJMR3FP8AJbifurkDAsxkCXjRtX/5Yrjb/ip/6YOEsuIK40PX5lANpKQO nIcev+tTHgK8YVB5S8wEf7y/8lI/+asPAUcYVU8ma4w3RE9mcfwrj4ZR4gRlr5EvfXT61NGIK/vP TLF6eAqoGSGNByBmccaRRrHGOKIAqqOwAoBlrSuxV2Kv/9k= + + + + proof:pdf + uuid:65E6390686CF11DBA6E2D887CEACB407 + xmp.did:d4d07395-aa96-47c2-a9e5-d0351947bb0c + uuid:c63c1031-e157-9748-9c58-86481308e954 + + uuid:1abccb90-0c26-4942-b156-fd2eb962e3e1 + xmp.did:58fdc1b8-1448-3a44-9e20-282d8ec1cf95 + uuid:65E6390686CF11DBA6E2D887CEACB407 + proof:pdf + + + + + saved + xmp.iid:d4d07395-aa96-47c2-a9e5-d0351947bb0c + 2016-06-15T14:23:10-04:00 + Adobe Illustrator CC 2015 (Macintosh) + / + + + + Web + Document + 1 + True + False + + 128.000000 + 128.000000 + Pixels + + + + Cyan + Magenta + Yellow + Black + + + + + + Default Swatch Group + 0 + + + + White + RGB + PROCESS + 255 + 255 + 255 + + + Black + RGB + PROCESS + 0 + 0 + 0 + + + RGB Red + RGB + PROCESS + 255 + 0 + 0 + + + RGB Yellow + RGB + PROCESS + 255 + 255 + 0 + + + RGB Green + RGB + PROCESS + 0 + 255 + 0 + + + RGB Cyan + RGB + PROCESS + 0 + 255 + 255 + + + RGB Blue + RGB + PROCESS + 0 + 0 + 255 + + + RGB Magenta + RGB + PROCESS + 255 + 0 + 255 + + + R=193 G=39 B=45 + RGB + PROCESS + 193 + 39 + 45 + + + R=237 G=28 B=36 + RGB + PROCESS + 237 + 28 + 36 + + + R=241 G=90 B=36 + RGB + PROCESS + 241 + 90 + 36 + + + R=247 G=147 B=30 + RGB + PROCESS + 247 + 147 + 30 + + + R=251 G=176 B=59 + RGB + PROCESS + 251 + 176 + 59 + + + R=252 G=238 B=33 + RGB + PROCESS + 252 + 238 + 33 + + + R=217 G=224 B=33 + RGB + PROCESS + 217 + 224 + 33 + + + R=140 G=198 B=63 + RGB + PROCESS + 140 + 198 + 63 + + + R=57 G=181 B=74 + RGB + PROCESS + 57 + 181 + 74 + + + R=0 G=146 B=69 + RGB + PROCESS + 0 + 146 + 69 + + + R=0 G=104 B=55 + RGB + PROCESS + 0 + 104 + 55 + + + R=34 G=181 B=115 + RGB + PROCESS + 34 + 181 + 115 + + + R=0 G=169 B=157 + RGB + PROCESS + 0 + 169 + 157 + + + R=41 G=171 B=226 + RGB + PROCESS + 41 + 171 + 226 + + + R=0 G=113 B=188 + RGB + PROCESS + 0 + 113 + 188 + + + R=46 G=49 B=146 + RGB + PROCESS + 46 + 49 + 146 + + + R=27 G=20 B=100 + RGB + PROCESS + 27 + 20 + 100 + + + R=102 G=45 B=145 + RGB + PROCESS + 102 + 45 + 145 + + + R=147 G=39 B=143 + RGB + PROCESS + 147 + 39 + 143 + + + R=158 G=0 B=93 + RGB + PROCESS + 158 + 0 + 93 + + + R=212 G=20 B=90 + RGB + PROCESS + 212 + 20 + 90 + + + R=237 G=30 B=121 + RGB + PROCESS + 237 + 30 + 121 + + + R=199 G=178 B=153 + RGB + PROCESS + 199 + 178 + 153 + + + R=153 G=134 B=117 + RGB + PROCESS + 153 + 134 + 117 + + + R=115 G=99 B=87 + RGB + PROCESS + 115 + 99 + 87 + + + R=83 G=71 B=65 + RGB + PROCESS + 83 + 71 + 65 + + + R=198 G=156 B=109 + RGB + PROCESS + 198 + 156 + 109 + + + R=166 G=124 B=82 + RGB + PROCESS + 166 + 124 + 82 + + + R=140 G=98 B=57 + RGB + PROCESS + 140 + 98 + 57 + + + R=117 G=76 B=36 + RGB + PROCESS + 117 + 76 + 36 + + + R=96 G=56 B=19 + RGB + PROCESS + 96 + 56 + 19 + + + R=66 G=33 B=11 + RGB + PROCESS + 66 + 33 + 11 + + + + + + Grays + 1 + + + + R=0 G=0 B=0 + RGB + PROCESS + 0 + 0 + 0 + + + R=26 G=26 B=26 + RGB + PROCESS + 26 + 26 + 26 + + + R=51 G=51 B=51 + RGB + PROCESS + 51 + 51 + 51 + + + R=77 G=77 B=77 + RGB + PROCESS + 77 + 77 + 77 + + + R=102 G=102 B=102 + RGB + PROCESS + 102 + 102 + 102 + + + R=128 G=128 B=128 + RGB + PROCESS + 128 + 128 + 128 + + + R=153 G=153 B=153 + RGB + PROCESS + 153 + 153 + 153 + + + R=179 G=179 B=179 + RGB + PROCESS + 179 + 179 + 179 + + + R=204 G=204 B=204 + RGB + PROCESS + 204 + 204 + 204 + + + R=230 G=230 B=230 + RGB + PROCESS + 230 + 230 + 230 + + + R=242 G=242 B=242 + RGB + PROCESS + 242 + 242 + 242 + + + + + + Web Color Group + 1 + + + + R=63 G=169 B=245 + RGB + PROCESS + 63 + 169 + 245 + + + R=122 G=201 B=67 + RGB + PROCESS + 122 + 201 + 67 + + + R=255 G=147 B=30 + RGB + PROCESS + 255 + 147 + 30 + + + R=255 G=29 B=37 + RGB + PROCESS + 255 + 29 + 37 + + + R=255 G=123 B=172 + RGB + PROCESS + 255 + 123 + 172 + + + R=189 G=204 B=212 + RGB + PROCESS + 189 + 204 + 212 + + + + + + + Adobe PDF library 15.00 + + + + + + + + + + + + + + + + + + + + + + + + + endstream endobj 3 0 obj <> endobj 7 0 obj <>/Resources<>/ExtGState<>/ProcSet[/PDF/ImageC]/Properties<>/XObject<>>>/Thumb 14 0 R/TrimBox[0.0 0.0 128.0 128.0]/Type/Page>> endobj 8 0 obj <>stream +HwVu6PprqV*234R04S32P4ճT(J +W*w6PH/H+X)Hwr.gK>W /@.ӊ endstream endobj 9 0 obj <> endobj 14 0 obj <>stream +8;W:dYmnJk$j=`^PKX*GV"-/6MPPhMW4o*jFegTA5n:ROqi. +8M?-(/t#IN>re.=TbIMqYWQK1D%b&pOLGa]H?hKs'8Gqa4A/k;[i&\e-=4:h!/H6BW;~> endstream endobj 16 0 obj [/Indexed/DeviceRGB 255 17 0 R] endobj 17 0 obj <>stream +8;X]O>EqN@%''O_@%e@?J;%+8(9e>X=MR6S?i^YgA3=].HDXF.R$lIL@"pJ+EP(%0 +b]6ajmNZn*!='OQZeQ^Y*,=]?C.B+\Ulg9dhD*"iC[;*=3`oP1[!S^)?1)IZ4dup` +E1r!/,*0[*9.aFIR2&b-C#soRZ7Dl%MLY\.?d>Mn +6%Q2oYfNRF$$+ON<+]RUJmC0InDZ4OTs0S!saG>GGKUlQ*Q?45:CI&4J'_2j$XKrcYp0n+Xl_nU*O( +l[$6Nn+Z_Nq0]s7hs]`XX1nZ8&94a\~> endstream endobj 13 0 obj <>/Filter/FlateDecode/Height 947/Intent/RelativeColorimetric/Length 90241/Name/X/SMask 18 0 R/Subtype/Image/Type/XObject/Width 880>>stream +Hoi@Hy&8_nyA'?6G3+ZHҥYakOj6gיoU GHII_AgK/EcF6LrchI 2$҆ԘU4w$5_7BQUm"Ť>&k2W$%Nib;Iߓuavտ,HJ \u.&1ٌ^₞@Ǥl_Lrs:#ј,32] IJ7d+65i1$Lb#d]G>&Y=g답*_/*:p.uʙcRIf") ˬ#q4Ό=sL&=(P{ HJ+b~n+cSFsm0'&&cܼXI=3zER,D#0)2=r +I Ә}즟 (9?l?ݳ;݃Q~twoo `41)"g476WxzGMݞx7hpqh{ƃn\ w Zᶂ37{M23>)25Eܩo|+>8q/8m y3=??~wL#I\dΕ/doޱ=Hh|d]ү$*wOc} yz<*\@~R/}}FRHxw G]as &lu9x")`m;=-Ƀ -O8Cmȑ{mG.&?){3];,V01o`it4)'ѭU, ]?b<ݳN=;.]Lں*_w6}hL[I$np+bdjlb46[ܩ0k`I{-ɯG_>]zt8rI_K}4јغOinӭng`HUN4ݛ|yRr #+x/>骞SyXAQȃękfUXDvE#&sBe< HQ%\Ωdg'sǟá:>xQ +!K +W<* '%Y%Vmao!ǩkv>w u{=Q<\ȃ*fƸmqY%ŏRpV{ ueW&)!)sE2Jݓ?ҋӆgohԎeɝiFGb}/g. +,%m.7'FX!TՀITV $y9Iפ?_ȼ0;Wi;h9:FQ]itB)`5yIe[j*lraպS"u 3$hۯNT´A}ٷO.ϡqˤ3!"Iڻkha˳J)@) iq1J٦oչrEIWt+>]hlrW9,-nr_}i#eR=椔 5 ](?"aIK9;z>g9d68 =FGY/Հ@@ 9ۋFJT2[̟~>:ekG<Q2B&M)}YƢ}\ekfeJ#.-3 +iHF'>hd,I#_ыTj~Q5cR`n:s e8 P/di]Ҩm +!g֝V=@nI${%3Tj[ԣ`Į;m$XOT4==Aŵ͆ޭ|hˑ"6XWvZY,{&y` wɵs/NٮMDz3z2 F^ęA r۝gB7hu ȲhI})CF +WWzٶ:lgl7ɃHiJ&/ Ӻg.}C'dD|V֪'9TL*4I]6 x74MVK%X T8ENZ!f8ah@&͚-AsׄOQ"2sO-ʃ#db-tgHIFHVj.Y!х@Cdҕ@2ǯeqyJΎC43nw0"D2ȥXiQϖJ'&:?Ed!ªGIKSيb$utõǭ2'}~dbNct`d K񕨈\29juC ڣy 5,ҧ9.~&g(r\&$zkddjd_&n,dk딝]|ڷт$lw)-H](H&, tHU4ѐxIE$\+Kl֓ȁI*?^^O/N*)iit<~O&=۠SZ0LK578hsZ?5ĬeV"k K +>#gV-?}= TjOK<>Nh auOBnY#qkB)fiQ@ 7@Olo-n 9 =)~erŗzC9z9Ilr&JO-NbW3Ӳh adR<+}D?NJiPJG%:?5pn2TI2v֋rBk &l f'<[wm}2I4KtwH r"!hͣ .:17f͝$Wq`Z Z 'R\%n~2/f|i|a*J&r>-fj@eRc}'yGBvr*'r +>|.WB~0ɱ{H ܌232ɤMRe7r!ic/_Ȗm͇OJ!dfH)OtE9#jԝj'C]aպWf+>KctȁL&rK%SͧH&1'ejuQA2p!Ϟ* UKW?-02hZ!nKO.? ZdzѤ٣wrLI*΍Sі2+TI,5N$6ぺ G7 whQXI4:?5ƫhq-Ǿ(v,vHz&.aKiݵdTOph2E ɤ0J>-zBb8,A6Mgd͝$K I,E[ 8ƶ0yTS rlS]|ѩ+&_9Ezb(Jr2h+ɓ)⇻A!_:۪.%ٱ4E3w~ sOq9F$~EH(M"0>"C|)4 {edUŭ߿/|}e.tD _(^u)TJ 8([E;ZgbDR!TY;g$÷=W__h8pü8SqO㠸*5:Mb)r2`Ny@:iXg*-X=zb-osW̟Y[V$J|!h|$p6V2LRwsU""YA(\A[u0#0j>k6NZ *P$Idv`;K?29G3@/)hqGaLH&)#f2ݥ:"@ +c1BuUU!hB +m?IXqBf=O-uS]*pb Lp=a d0 '%}QJ1kv-E&Y%͇ѓ!L6y֯-ZNſw@ME<V ++Qf1XGbu.AL}{;j:1XM;`m)ݒr2??bӥ^"T.4{7V:7cO n]&IIʴ׭]׳L&ټ~e?618qW 6$уS-J+j &HR#Y(u3C"vaVO qˤg/{Nd* w4~8`ਡODT +( ƃ(rVu6z0F|iU6_Up_ |7//y e26kaE9JTh<'| e\xy(7QQ1Z)7#5eoӈ0g+ۨwCxc XSg")-nkEJN[* FAKLLR7R.LBME#@* +~U݊tEEVOt7U콊ؾxԜ'isjf=O[ZO ((A>&]r"т|f0`A|0/2}+58{:!ELTǝuB1HzGQ0g[|Q_[VSor^Gy?lD$g=?ȩՕLN9 +K*RYģpu0%K'*- lpD ID2MnݾbL)OYׯR3OF"R j"iO8%{Pqs ?Hee}-XJNm\-H/}GϩZ&L/u>7&I wQ) /+P.bP"$N55B]={2`[Hnk?-s\粓y*dqP9I,1k[`^A/n3ՕcVna-_s%YSM{b FǠoZnkE%yt$mAs%Ev]JW^xA Xk0v_KӉ i$Fߪ/u( jLIO%k/Sr7B>Y,770ݙs)]ubQ9OΈL12$jn*2*쾊O&iV"sr+ 2LjȞCxҜJ 9:Jʌ H(hxA&xk i&Iu$6ԕj:.E Q\-^*%V@V;RM]dLW<}*w&Kߊ{-7@-&;. +C66 @9TBUfI[#v1r`,f/5n TLֹޤosIwT&\ߍ#UBXJ&uo6TE-EHLu[FUf +x謖Xz{FEr6qiVd>սl +\Uv^dKCR&p6kڄo@)ɛzxZZfBv5nFC `r{Lŷy7g2H&;x@kASYQC,29Wp +c!{)r*Rj!&#8ˁScM}Zi*H&Mf$\P +Ŵ\Id eDҐIЍF1|CeH ldԬ6i.2K8t׎&t(Q+ZfB*R&~?g4|W~ !$1[NIkqS(T['iͧ4*m~@?>KT)ΕJ3t +dEÀ."!|g_F>";,o)%OQ~Z2FBt-Ŵ=ݗJ)Rbd/}0i +3%f_,%.u;}oZ_`>19)ۂ֙Ĥ b- 2z[&;BEz1i6Cӯ!G9htj9'I#8ˁB!=*t-T:zTG\2z;F3}ZgLhHӍָ!fiVL:,N0EwHVsR I !-U֐L1#4zvB`V|u 4i$\"&^Xjbޟ mR q6H JER/-N&w',͌ƹӿ8!fI|1TBS?D%}35fW̊CȊ\!/5n:VC1@#&R&2rÚ!"H OS&c1[pUyuN'v96c9)Ӿ/I W%f<}*Gz{-/0D֧)T!LSXva?:n[ʜUX% *R&~o㹤w-dr>و'r*+*1=9)zKy$Sp$"ӔIWcQ@&~!AZۑ[W *'W|쌰95n}ăF.i(xyB [(58|i+&Yjhz>˜2m^?fA)\('N,1^{,gI&}<Ǿ dTVԀaI$7XUkt sU dl:OOٯ<2w)6E =Lq<{ hK|7%FE=ikA(#cia78Hw:;i'}h%Z^N^7VҺuQIHNcMft+ +0 '0$:HJ\ ;``pPL=NM.H1Eb~ԓvsK`TO=hwѓ7|GOYZaȎL7e Ջ[녤&Ɍ;b1lx"Iw!}9pXfv`7xgV~π\\zπD-/؁_~ɬebJz!QyrTS蕴.}?]$i;o"):F)(&ۂS^/Ǧ1IG )!bZ1 p8ĕT-@Kp +m crE?m}F!e_JRPF +7b1T}<x4zV,&읲yeTJ=q#cz>)Rv:5[QГO"5o) c^mXyTعT=%o-oK2U~c͠B>(h1*h|:6Ll' ޑ4 =ui7eGo{s͈KjDE1!3e00R,I %y)1]5ά>#Vgr|%vVV>&I5lS<v Z ;RLj/1'{uO +ؐsz( o?;I&mT@L>`|wdF[pY!=;Yk AR;o^2Lh ~_ٛ|GdO q/zRqcw_}9~eiq$i[?~$N%Y72zىSEx1,HDlEg3JJy}F}7)?'|(GoŤ*isFGO=`r3R8)p/MM$j٪u=9(&˜|m5(t75zM'O \]]ITٱ3u0Ǜe/$iF1Da*b1Tzz_W8/wzg'=srV~@?];(&0H1ʿ[P=kW˻zBf`d.d*XJZC^mt.'h V QLqr9wTҺ辣QEx=D19-d!}?d!}3Z#)nmDzly_|1^Nd`Q0l9'0NnbX9T0ZdWf˂8d=pJl#&BsԨA7FDqڇJZ*ﾚT=eSH'YTo4>doE|~ $#&1¾W` ڑ1)د6:'P}O࿠ne*Fرs|q +(iC4P+ $ +cT6^b-4je˷O|zS~?_qCjRr̖E˓>jEk.C-n#E<IO{vE5ӄ&EN& ݆)-:< I'%}8HwяV4d=Yv 1|Dh*; <Okr(Ny%*~*Yy&WA4!x2zsY-L"=\Le5ƔRFI%IF\3_87 0>hq x2`+IǙBh#R8-w*Ó1YeVO[x!mh?[ <$|`2s2l嚽O EҌX)#Z!Sр4Yoy?ªf8jO1O_9O"%z dy.nNY2u5UV\Q~ɲ|kxrd'?apK tE7s!m`jqZv[>hZ-%6}az,ڜdKɷGM)،xd"6T\l,&c<'Uf; +w&B gw)#„S]\QVQ>$I_jJX,\^YSd|'zD%{o1!䅇qx';qڈ>khYӷ@mwGyxbr ~=ͱ{9hsۈ!x2< !f!mf" e!ONYW,B-%'>,;} ^&CE"OtzK68]dGRfɈt}B)ILN-^3d[ɿ/3GlV&77ug#K1P)^I\D}&/o>߭SHh+<1Iy_uA^ +sMzC*d\'\z1zADd& +9$Y"?LtzK_14*Y|!ԯ)7$URyuf۲/ɖ$yhs:ڏa<#<(){;qSdLt&}ZHy$yyLܘ: ew}\yYj|aIQ%#?xCE"Oq1Nb5˵I~t֌ZcEb-%Շ8}@i?qqN~ Ndl'\z¤.o !جlݜ(B],YoSO&w"0fr +L&\Pby?ޓur!m FZKGbrΓͲc)eE+WqytT?w ]]}["֫K5Ez~J+T3YnO26hSEH'㷢MO$ta0?j9VuK'/K~CcζI-OV/KѸmkҡuΦ)"&㸔]LyĂX)cML=yn\Ω۬ crї'ma5r(E=pu7< + [rd{d7.`w(d;wr(M=zRy +7]＝!Ij9Cidy!NmSiǯƆX9r R:wP<+y^{᬴$eYn;ﷂ2^%)uũ Kw Eߊ. UxlidW)I5Ip΍y%gMGƔd Z9"~t]utڵɲ2E#{Xtp7 #i4i>f-2x jL?bGœ{y9k +AQש'=FE4b2&al6>` +hB");Is*QY9c"1鲒z2klvy0 7>`%JN dXn; ŘWO8@g,צ)_cvH$q\ѾM_@%Ƈ؛XBRcΜJcRΆ1xZU]è-9NEw'c뜠I=]c fi~>?!NI&ļfb2 Z8,W䥌e|a(!me?MQH'cMsY*+!\VuSLQ5Kp#}֓mj:SHú5\bØC)I0> jYn>_+c t57*pT̛6=nW%4EQ4z2~+ɜEO1$|T9c^Jt,Ύ9AŵK2Ɏ'+{,uCL/ڻAZ" +d֕MW.oBgDtʿv(uX4Kp}Gߓ-8,]o^ѓ[J^c(NY]$eo h9[ƣ:1vt᥌e| q'Kp4 b>HAB t2n{'ͩ(*rGOӡz>(-ɘ-d6=г.k؉NO&37{UGɓ*Ysgzҋ>XA[ &f.oqC󢔱gs.$e/;?n>.0&cT51}<;(*FOkE;a\.S+S=˖&EǗo3rLdA˿}yb/IE\E"*;pIыeCbuZ ){ٻ #=I_cN|k)rd@Q?h.3Ed^ts*g5 xQX욮&VO䩪(Idt1>ðh[[AEX̕ϺܓyK{./T˱^>xL,Mo'svy[/*|OJgC{::EQ1SDLk%>>Ѕ<I t -eo$7-gHIΆ(&-^^rs *BadVؓ-W*j͉IvHʞNLO:W%_31dӨXܸvH^|Tݓ+9/Hrdz_wq\e?@MQ̙ݙ"NuhEA(iK̙}v(AHQ"@D(WDUlMĎ-'Eyf&٦Q|~GV ?|mzR3|}pӬ3 QJoJpd\nc\7n,Aײmɏzs ޡ22JywoK2/X'& ځNJ* pbR3|w) A7ɤbrc )#f dp[M_&g][ه?@O*v'd5Ä-`˨[ GOFntLλ=95fPL +&!&;=@OK1Ŏ=5:2J.778&$k4RJGL*sͽ֨+IN,Iij&}`K闍sEvDRϿd}OIb_93Da`(r\|@O@Moߎ$gi)R~cb]_+$H!n~F]1GL*vZFi2T'{ z\ARFMbz~wb1Qe5+zRb25em-3_~Ȯ) ֧I/_Ox^JIQOyT=F9CW鉣)fʴRڴ1[Ig + &NA@Ot\ᏻNoV0[%dRїbۤARJwu oX7h4b0$m~a'U:냰6G8XГOГWuNVL1҅ Qp00bIe΍{֠ 6 =q(B:w6Ñrޯ[?^ORLRIv+/gRJ:A{MAOzIN0n/{Nac5H$,+ԓr~ ~OWllfC+0+ГwځZWBA9%gѓ-y唋w-GF)Uk(5?C%;=GLj/bIIzYw~<HיմFi1GL*t\۵ŤH5$gP!||5Y,_;$8hdẂHh C~aГʜ` 2$R 2-D=yq{IeMИJ)1 wT2#&:=FI'@L&ƥfZDRʲ2n%%AL)~(_"H1IW0J W'91S;nZk PJk3=) {=^)&/75fPOG3-#&7@.d{LO\ ~OywtALL%h//8IeN@7sbHbۼ1W2\jn} bRn@z4M6 +'?Ztw +٫0T?^Г" [od% I'{}q{LII6WeVgROS8 K@D\>&;sp6"l\Z= SԞ89c-|~ۘlr\iƌU?D'3&Haaőom“ߓ?wP9Ô"BH$&;m5wI'6WvyCi~tw g#̵͎.p9 FЧziۈ$)&$#})r%R+ [=ړ~t; ՛!Qײ^Gzr}\10Ouc+#C͂&(_HP(D +d!թXKtkcZ*yͅ (  w¯<\*Db,$=OVp'1K.:|/lӥ+i&o练Ɏ[UlL=t _wHY{D'C%A)Cyt)8tDzPˠ|!B!DDEg ̓~WF/Vs'A\U/! +.a{0Ç)zfnڛ>< +.ĕ#_uMLzb)ZOVfc+UA)" +4D')58=26L">^&Ư~nc#{Uҭ' T Z; $U:ri +_͒K 쳷x#LJ4K\4^mΔX][XVBf@)5:'7}OV2L=Piϲgc0Yh-8iҧVk6\o'Nq|$T($)y6Aߓg O"Hb1flsarEtku*F?L$ |)> R ѸoB(L7H>IwUhc}[3;/)go2qCJ= RHOY$BkѧJ6)b Fl{h-8թrbVyZgcF;HҢt@ʰߓŤA#v齌3BILODxRzI;e5 Rkw'w9OD)Ý$)Cy|O[X)7PG$E,̿6D\GLJ_VO,Zhֻ\/of>!Ç6A0ߓN(+MC d.ia1^j&VmXuw}q:ZLa\RM24Iaw ! +yš|%0KeX\vIِ)H{fZ;qRC{ /Dny]&OkꉥUS=l'凯Gw%)H3ct:BxO 3$0.e#PɶO +|XZE_\(ZODhғŔA-]%f.>nEѫpE/zT(ЄOJs-M*_*PEJ}{ Pm3\)W>[w*]d:@,wZ$IQ@97,aNEd$KeR,}jV]RDP($)]ߎccC$BhGlkFbRz@>ZVN|H[l$R=y:QE>HiϯFxbJjVV5ܮyR^ +rk'eG!% :W!G{DNhJ\9\wACl +wϱR>"j'3J)_PKwG&) wZtݠVwgc)ßHaO&nr#󬦲l'3yxY}fdKJdARH9E}%TTҌS4<zbtXG٧WgB'WVD1T}gLbi[wǚS$B Lٹ#VLXC+;ݪd #+oIA{0]ceR(d֙F3$Bxt@V IғVm̴dE!)yJ>D*:!Zy1Mz/PBIf0 Ҏɸ; Gځ*z͹6HOI`)\NW~㠧£aITVߓMӬ$B'ctL&ݪ\Ylik>Wccyh)GՋ`Ji\1W݅JHrmL*w@ʡxѲHzCx /+΅cf%&B_$Gc&/ ɴ.>)=yV`pB_5B#:ʹv't,;fs8KUeD 0p1>$Bhg91jILJup6ꭕ7k6$?:L2zקb`};=R=fyq($&jkeMkoxs9["L +UB.t/MO0tx!Dn}~yLҿV]=2f^CQ_uyp%(I͹䈬!I-yBs95kIAQnԩ{Sѯp篧Gm2=d7R&Ӻ4M 54;=NGc2ncRt`AJxw&ӷ4p#BΣ)Óe6y0)%L^_׫rhe{-G^O9&%4j2Q/ +LAHiL"CɇvMå)30PfۿՂXa0)QqVgsIV^UB~l׋ Gސp3 L4RI9&M?V !$)n+Ye6\V0YO'j Sm,u^)dw>R CҠ/eO 5`2 j'#=%JXHPe9zTw?pf}iTnQntwR)OX"pO%tT&Ϗ]3)$7ePf[pr޸||l5pndғ+ĽH9zK6]mŤ zͿR8!>u=oD!h`EE}^:zO)vNVB%Ϩtg13nՅvkj,2Y'@]>';qQ)dzٳbT O? :wu\hvߟ#zٜl]CV rneu&w{LJw'R-FE?!R/DJrI$d<12,REV%U<7g:fg^d`bcꩶ[:+7>VΫq ҴP+}coVD0+ [uBKZ~ RyUs.++3UgD0:=/mCԁ*#iU}$]9e88 ?N!"::-_:kúXQG9zչ'Iy\8R*KƸ/!~Tk4NFIʞ.9])3#ByoL>{cRnn[n7V>)WKRQY#UzO?'s=Рg]duC. R> +'}nMty!׸/0y([v7t%OZ`bsI=P'L'ol3{%RJ }&|DQ5M,$)KBcuq\B銞SV'Ofw57'H#RΘs9'R/)Ȗ1BrTk,pY +}+;B(Ř ɯGE'ts+ mF\wO;KlTȒ_SOcf@=-M//:GnW?qPgE9oO%`^ xm{5Hܞ^Ĕ™M:'Z!2Wƶ4ro+nopEfDjtKГAbk&V=Bj%ܡHIc8gRchJ\#YYZi\\h<]R]Q_^vЮPv7>>i <]NlskT?'P5mIF@OU)xUaT}#F;B@ =~_ `rm,Z="]H ?jjR*~yT TI*{zԢ,HF +W!DdUb;<޵s[#Vۦ-Q|_緍Thwr+PKR*B@E` kR.Itiai^ArȥkP_ڃbDJl2ˣfgIrlX?gw>X<}"W +*e Oh)5ЋPŅ]lxh7&\B{ԭxhvRzE,Y0C>yF UJA)_~D7DAA$;)Q&%AGt)K^y4ν* o{MO8pr\r@x"Bqبrۑ]JƾИk7lJ){'@oJMNJ"\ Fc}IJӴq%M d* ,l(:KU+͌'ᏏGJ)23,I#kLZ 9:F-G'\Aθnqޒ`w.kY=ʆ7 ?>:ϕJ1+4V(*il"K!ʓ2G9.]*ӱU@)[r7]>cےuLDMbV [FQ )zeK W2|2& %n0I]4ukǢYNfh;Afbke2$op푮^J2\2޴ )HR>}yRE*oyd } iAbI_ :KUli +d4<@{d΍b}rJ4E7l;|@*w&$!ϧUke2t-:] +,!߼l]}~ =oz{֤X5Q$>eL)Lҹא/] +Og6*beC>7WH+#bX&8)rXu$|RGmkÛVlR޼lURՙ+ڑB#0UIEKأ9~,bԲ surX`,Pvx#Er TUUnMt)NOsT,pa]~C@0 蓉-#$Z|f—)E\%.rolϛ͂ / ߍbE2yL{L& "t{~@C"a(R +tRuf:NReؚ3CQJXkl cfS,hICc=u0_Wfk>knL1ז^O> ~Q'tz`'#W xV +t`O=?7F{Nvfowvv*QJ*0 +D?ޙa B J_$<z;i{wF#e={\&C[r!7&'kn¼~Ѻ{]2 @ *n{Q^Qw+eǔwT>~',U)+DBGbe!z/E"-|tʌWXbvF<6NHP&?pdrA[_Wm_ +5?&PF1J'3p|R]]9M]9LL2 Q +LrHP<ɤv4ΒV^ZYv?`vFRB(M(  +H4JoէX)Ϣ G)<Ʈ@C*p&̟\q7H&5UQ^Z^u-R)E7?A|^u60H%LϐORКr{$$A@$n|^v$zn₰WSo_Z[sSrdRޛ>||R +% +X3J*%0|,ϙ"g,39!+\JdR"NtgQ^ҊRlr?R)i'a,P * Jycq?DVI1? IM<(.-i[-gb\~{ ֟!ɥOZ:,Ø9{ٵJ:36pVݕII- o޾Ѳcݷ85kk,K(;9g' 8r[a/#<4+, +:VInI(o d^r@ԛ/{w?p_&4(eDRcёD>]+Xkdqj22y{6pdRw S^yK RE)10Kҟ(. E6L, bT!ЕLnTνe%U-V* [}iIX+ٯUBT&C86OʳDP1[]\/&ְUڪKKjn#2LvɩO%JzQΎ~.' τ9+RTDL.tdR>"V+[Wo__w7B/W3 O.9+Sl>t]ӉO"oOB|r +VNͪ^32 X)mP ?sbֺVf{D0/#o`7ΒVm_Z_~ BpSETTzaLtZv2Z)8Jq%S&I?IHd:A7.ɲG=Pkɳ)?(_;YDlgO_!;FJ**e' )2H& zӏz,T=Y]=+eQ/0g"cb|蛲IkF $!YrڪKK4.»5Jj;>i:':nA){;,nXepx}P<4MXyd@=K?IFmr[ŬUT=Nr I!ԡ +b(9qarJans=Iu f'-'Lu,QJ RtRJHEx<'*\aOpw@ӣe nhzuFa·-T_~M2I<L3+vm n a`Vx|€q*&L:t+/,C&MXeUH8mL^UI2IV9{5)uR +ƏA)(#nao$<2cIGG&/Zw$Q ھފ}!iD_~ϾzdÈ40ɴb)+2 dtd}wCxkW 1  >U ~lUH&6(^q10Po=&L_v|ș$+Aer@B6.䉳:/ Jy'Qʹ sx7o}'oLO sSao^<I) -2 +$lWS/`_wt7U6?J)p0g%z*u#"#eDy ڔן8ȈggnW4c[4R~zŰ:,,G L}ʳAHLBoHxVۗ~,9ʛ;`:A)10C|E"Edxvۭ +tbX:OZ` RFyxQh$TIcz78'a0y&'2Yd̟L/b]U/`_w[Q|$wYKRwEWp =NdcTWd@gBDHvrPXx^`aL?$I&Q`OnfY)*͎LL cz$GD<Rѕ۳dIⅉvkLn{yL2U+»=J$FwB! LouM_9[ƵR`#JA }IlVk^ݍ[[$<9Z; z>I)E߆Eܘ&LiÐ/Q/|e0A EߊH&~ȑq?, TUt<d`_3MG*&􏩧w +H\A=xraOjVDEI`NI&Ό8隧ϗ7E69t}y^&+tz“/޽%vp\ԧ">AnB.WC(yS&rt+YHJ W"U|C~KJǬwRŔ!3c[1 FdI2qǐxCo)Bi)LN0&%6$5KL#xG;n䟴T%m8<9%S4o6 I@Kq=ow;Gnۊhх|!`Jd}<v,Yl6I&ozIki[іp뺤u13O*QL#dI'LH;, o+R1 ;ϝ DDX| R&K!R]?y;i'|WKCr0X,>{;P7`Hdt~ìsVBF *`V7'98QN;&Uqk¤Th:0l.0Ϲm>h7JmTEHy R}ӿ_J9pIcT~B{Lh"axov% L"%˛:0Nܮ7Jm7XۊdJY>;)E{d ;L*;[0&|X$Hl٘LD'qYTjd]#mcw%R/oSa~/؉0+ ^&? +\CD}#IgJE>Bm'Rӆ"ixؐcχn' =B3]LItf-"`*E'GI)\R&'vؒNK)¤V3,L*> E}o|| +Dң[+lvu,ޒfZ˭+G_2T$fvS3DJUzDJF+7$; S2[+K}t]aBz1e m л~> R"eΙFc!έ|F W"%FI O)KHrڰ8:3Rƿ$ %R$Z㼩{W"=q t)pmyۊd@}zY:3JJ[F,qB&$Haos\7h=$%L&8ͤj߹4n1ȡ3)틤 % +n^_G,hZm|R0e"<9XiI$O.>j<3!R i^L LrД/15D6ĖmEl6uA]W6<=H"Hk!.I4yIܬEKLj6#k[F|r1 [C YI2ܟ!M]t-u:~lDAVtĥ3LMU߬JI瑒:vT +Q$EmHfDSɼ߽4Z&Q0"v%Ls|'瑒PJV4 h0yd…F e3LV[җZ.)Hm^sH=10 H^;ly,pg/B~\:Ôi| ٘F,& z BF +&H㑒#RʆBl, m+ +L`ڪlѠ6~TK''W"y0i%#gL襔AOI,g~et)AAII(kWu%2?X[E"\NHZ[Ѯ&QPs/Ƞ)_bɆ+Z%\yѿ^% cG_ I҆)щ7dDo·=D >V`%^n_&|l!#Of!!e +D'a?t1<|)zXZgz9x;$"%v)i)юec^$RӔ/7hJd]kUҳg}qOb&3IYJD~Fە30k1.zmE[_=.FZA<#VNɁ.g*|Rܨ=ާ&Ir}dEGwL~F4ƤD&sQ> &nl.]bj` Džؠvuf|c0~̈ Dh_ne6v/r+.& -BcO"N*HsVpIzQ.h% P@ Oq-ko&zcǛwy4;k5$wxPѰ@cl.7x[:qΙPJ0${p!YKVb1`= 5Z-0~),ȸgG)OEI)[K@#$|=+qPODo[kVf'g1sg-gf"p]N@w 3߈%-Y,p|Zyǂiy1ո*DIOu=tNZací( (8s '%$!@6/cAѲ*e}Y>Qc33gC)CB2de 2 ?eGneel LY(Q4:]rD *l= aϼ/_-t쯥,vAh,XM}ow#$D筫3y(% t0b3F+d/O8 &d3cAjBtl/hA;];ICJQJJ d©o-Tz*iʉXF:72'zڬvaf@eJ;}3R=L3/NFL>tZyZb*UVf/9!l{JL@). d]h +V$*#%RJsci$—0R.dL@&@@R+Q,8+δqh_=DXq(%8wr⧟L ڼj,zIQ6ǃj\kNA[fk$^rθ%rď?;s +2 h"V <44^WGúZU6v=JIF. +ẅ́c=M~_ghf]Sɷϩ`6SVOVd-6秋1}ᓈ/U# ??I}G> ;9G'#~,CڹI9=3 z+{ak?qz8gd%$}Ye喱CBN=sXlQOO"~ɫ#旗Y[>}OM ʫߌON 6L_=>~|'ޙOFLYO9ϙ`hg&W$m=4óI@A3+YLYyrAg;5MWځL"~6r+WԻEI0 KVs[ dE-irB ʿy?oGxzt/DhG╯O]Ͼ0&ѽsg#>|Ȩɿ?+V / cAeò1?7|M<\ݷ.I[GK3Sԭ7.J|7ux纇>?<{_}d)*n?&LC+YСLmp$x>}QҘe1LWe^9RgΈ7QdDGp#oU]t;w%ǂF 09IJO"~Jh(^_^Tfm34{ɞ~{xyiIR'k$4; $hY4J D|suIng=UW'#4&+qDO8YuH&UY.q|2ho,J,4҂ک]zTe{lڼOM5ZI'1G+a#5!aa@ʉ͔*ڢGhs'io K0Hr$>,ffQֲm[lE:>"KVF={jٕm (hql!!&$ +g8& Dỷ^/Z,iUJ|β-d@[I$ٿ̀Uո*bw'C7|B4<});B/R^`|2&V溳CI7Rr}Ew `]iiJ @_hF65'7leDőh|[)v9|a6'E̊X @hF I>l'(kYӝeO"=~͌h_VDK#-JZ $zf@lO&F[uΨ \|]T-V~ +$HOkidm'W'sY37%{HVЀT)R04+q`8AW'v_+owQ87+PUOKi 4k ybk:jO"1ƥh_FiEIwsgh@jh)+ T㪨UEKc rI`KЀTOkpʊSK-*|aJȜ7xLO}iz,iU.O|ƂmXmSuF>Er$SMQ\M&> +<}!jqj!!GuW'g!$”P'/\FϩeI+T=FZH3'H~6aF50t +J)H ®A]T*Cp&NlLnfUYT*V%6a50C00D?Փ+os9ؿAtjJ|LGq'l/-~zG7 0OhAW\m5-2V*Z<!Q=dF-V"`R!ZZͿ |;?E*80K2HGܲ,K̡x9Ulu,hOҰUEĵ.d쑭J (h5iI5˾:b-#0o#%E?+IFxl'Qw`4smH*3Ͽ9b#|9.Ī:Id .2}'lY; {oCEM+>#XJ=5k vi-:ӿl-ŗ^ao}^ty`$u-ž+fg+jZб>mHȢ+[wQ>j`"!jU.ZF'GeXM)p_0D[߉+vhh5ֳҵPZyhRUhs|_Wm(ًz%QOC)MMrЫcK3;>;|z2 vA' F;Ͽҳ*G@ΩV,|oakh9> nI4E##ɋD\[4s"%6 *Ap'6Mrg> ^L* uKg>9ڜOя>5,)^I^4sKj[EYӸJSՔ$2;A9+[:hZyt>#kIw.=5-3(zv||Wasrx8qYOIM$Uwъ -k)>%`tsg^. +{0y=k=+78\ɲE*'k_k>1+m;QOD= `7twKKj"T,)'t_S>)yvtp2 v*(lKj"Y+ldTmNwv*'q$me -znh)2ҵ8'VfE">|ڐI0&`@6,{IMd(X\_IO"`ƾa߉'D# `7) ^*R[US$qrأsm`?opW.I]D6rh*s'dJ\^LEgoĬQ솖bsB!΂& +=Sb#VS2H'?]/},6P. +w0iO6si"=[Դ-=ұ7'#_Gp[rHsē%^ lJR +$EFj-3>YM#D?Vx

`t ~9:X%I$i(%@A-#kY>?v|:H$'GG߉ eZ$@QӪ[_O٢+X(z uȅ333dC%H#{0C&iǽ& F,N>y=?})'~fso l?3tb]L$kI;:֙OfVTN|I"qn蓉D>g^mboz%HKnX9`yi[EY2WԔȨc~xLtrId?Βw;}lUנV3'kiJ4'g~/W.$.p}蓉DJ[A`Y/>Cz%QOP +C#-%4 l0VE>љxH$D#=>D += $AYH\4:襑SO|#܊⟞={G.\?}|ٿS+Kڸ'Kz%QOC)JJ6sµ,LT&)Ъ?n8dU%璤䓉D[EJb_yv.`ti- {7͂^z6eBC4G?㙙SHO>u|tr/}A`~ +s}tHOFBx7q!D5z[Z_ϊGG77?EI#^x:{i:<.! |2뭧 oc4Ό lf`̈'苪RJmݒ؀9Ćv~JժR/zҶ `!Y`se睱6Cד< 3 e+vPa>z^dPϦ5%JiB(.vnBn=4f]WyFd~Usd/0_OUOJu"aǰm$%[/MJ(1M*%H Z {X1Ԯ(e4}K1%.ghjR^6'Kj'!f+-ubY?GOb< +8TSsm֕$+F".P(. +Źڬ6:TQߵO"4TJ͕Wr'x(9$ IO= XN=? ++38B0 gS[=%;ˋ/qUb'D}$C*,=\C8/C1ԮԊ@;mx""5r tHoN ekk+k1r#@`>vt[#™ƨ'KfM d'S|%3YBWR/YCDk'(κh +@S8e1[ gY4UrgI(9+ʝ'%ItuKkK8ӤDtT0|vƐ8{bRI6eGX(Z9-A:E1/'|Ŵɲnw4e驒/tDyC=nzu ^<CO / QL#8K&<'A˰ßɋ$;)rOt:D姻e3}lߛDObh{@Rbxi"/žI)(*~]xAp=q S͸CfT>|{1~05$Ia6e?*/W5;glkJ,h,v(uP}J>0:x)[KUW:Rc}?)% + JZ$O|v؟ _ +P 3>o tC, U͂d7; V %gI${r5Tpi`ԓNߛDObZjwW,[\{S󥐏D|~H՗(/)K$ 0"'?nLv$Nv;U 5K$tpvx~Oe=)N#|=!%0#\ vF +sS0Hb<)V:o(Ic\&zb2|1$m$;āko`\}|0O%_߁RȧEr |'Puqn9dԜ;x@߇uZH?Jm K]T{I.;aCk(9 +ji4.;Nꌒi2:dm\xLd>v`n+̿>.ҟTQy$K!߼>^U+qGp)gQ9ݔw6' $惩ڝ ^f{w>Ki8` _~\j07Yf;0,u8l'u:kn 7)0k ;]cwՁEiUQS7b`ޒ*0{򹌽v.ԮOUK)6tۉ-XnF+6bTj&ٓC5S6{;/$_"U2lh/qsH}_  +-vY`+Iѩ"[pi4agi.uR1Nɬ[x_zBRamOv KjbgHvPJQImHoT'iWB?ZF|2.u/S(rc*'}JJvfT"xL_?;Hɂ6eEk nU[_NdQaUJZkшvw1qR +5mYlQlDne6$@ڡO?wd[:(Ԛyo5bxpmZ >ū +VkkWX 2.$<y =VCyY_)*=)$OwJRozj?D?@h|8և77_!xK}rBv6!f'up-0mA J~̀|%G||RWqTmήtkC%n'OJɕXB"ÉMRd|Or i/@#5<֊@/wy |rayxU6E)|/Od^msN̸RvIٙ^pN}I-נ nvTSST>rOZq ,|2J}WB)mVJ`ٞ)ia K c=>r 6qvHBgzf;&_%\ai/^3# {a5U{-铚d; $څu&(ڻ(\'u'Q5ݪ7j}($TPR -)w.G#ʛT&){xf LZeG>ӁVͱBY*kR 3]+U73k[)g]'{0v,6~ ASyZɺAF̞{ cmcS°/f@g~R*ӖZ]I]|ׂO*q|rQd*I7ʞr3\mV""2)vY3Jqq Vs~k}b9EM +dKz9A|X|/㬶#/ÀR*b}LԦVӄd.-uךxge#V϶# &O +.KwfZiS痧2.&>)=bxIǫv|'QMMJ)vZRp_cVn-" aLJ pZe&9 +B/Gne^;͓SufuG%A}C<*xKVߜ('5froo? b,*^uZ vš\>k'_27ɼ<ņ$xt{]Y)V“>ʜ D 8Ҏ<'gy'G&zʃp}0c7ӳDo]BGr "$\x7533> +olMze[nw hyɞI>j[IJ)J"`>enX +EZU%RܨCRe]`&Q0,Oo2L~r ?L8vVS>'"+=r!cTVPv D)/n_) +YʙJ* Vلfتy&R'=KWnH'EUvHD7YIpB0/ZpmU-)BǙг[I_xQAvX Sٵ&($U%cں8$Ϲcشݾ`M% &Iv/ɦj*R2MUjkތ1yH3̐tUsJB˵WGWߗs~x < "<{`8LVѢ)QV)U<}BSTG{XØ~!7J~pOsW֗dy%#Qqdd=a딈('lHɟpL/8t y7>S{&JMa$ )38qf R$~,]r@#,O>LM%~[Mp ~a'N +,gGCO֗$Ħ223؍{UQ0!"z^"eT*'TмM9%Tkժ $e:;__r'8j)Iԫ.]k#8O +ϓpC`:Tjϓu4-ZCIOKÅV7~fyuJoyR]eJsDx2O-vGض^DDY? pUΞ*b6IYq oe Ӳ|x9 7}tp΅ƻDJҴ%-4BDe<7JZsOټጭҵ8q $DAiB<8DϜ9lJ.fO'AP `h);ă\A%vy^;ʀ'J RUa2yr ^njtH_@JÃ8؏'{$~rH\3NH?)4ij,2 Y7Os%Ӌ A1d]-k|p"hQ6ɣTaQYVeUjNo2&I <]HIx2dZ$"]E9H fN-OişbJ|NW~1ӷbS.J_rBP.Def>]0ICkަ1td'h4Xzl)<OR#dy xD}V^v[ZE?MP""arO:%[*/bIr΅~Js}},(:A1@7}| ؃3nhҩ"jeU +cA + 4"E(@cC㝣2H!:ovj'+j' *'nb`rZb$"24RrqpUwL%@`_FJYAZG̺>- Iy *Waq;zGh9 @^ ;[qPAC`5OjZU6EU3]i&IW +PJPpL>L:_HIWi͊ +5U +{2-nt IHR2{r,҉B܀1`u s% L^IJwM./?O¦x6yp8"SgQw%aTB6P!J.ԘsFbJ'\ :b҅E&VR]z94x I(3 <)1 )[*nE u$Eg`CTȠMz1+b;jAeF]/~\0B^j-ڃqK)Td9; KյIFCaH*J?!*@v<·=˄ǮjsFӍڬ Y8|vG=EO@b/FѵL~"a2?h.+ ؕt~ }A)4N=05@vI x2[[M<&^9ӳ^:$u두l$,) \ijāa&F=64Մ>?A_xc$L)vK2bs7u x́'SQ?qoLՅEqD;p +4OҋcHJ{2cr2l'5)Ry<8ϡ"dAqx-,On!LPP` ɦTO\RFr!~F 'cA￙c. ݆cʇ_{;:1kڸ9G(j2fV-9iL7j. ޓو[[E '-D ePv|&oo8>3}=y/<2!/#ړgme_ +./g MA~5xR/Ynne@=c$5!“?iHfUφ8Ucl3]\cZ$<%cat3jؙx2b^HHH"dPejHkX5!\;hGЅ(jO45qd=sQ"y$~zfp3kVyD7%s3/iȜLn +B~ri~?5c2 $HCDaAř$""WW$uwjfvvڭڣfv-P rprk췻!NBw߫OP <}- O[|'O#e#g`RJ13C_^SlFI?}I8nf`N$|@ e,ydMUn$9K1|N=@~{ 太7$ŻI_2FB"l3~n@♨z2|Rا:Dx|r])O03[<+$xa0.uN3zގZk`QS}m>@,5:,kQ0P~"@#!񰊿 ^)\3g%݋N0O|?Z}1I +DPÁ2$BGFťs>7gO` 伍r_`bc RJX䨙m^ CWۘZ=u[͂\ mRJݦֶ̗́{CG>0P KqQ>UD .ҐstӢSV6 &a!0ZtЄ~wQ>$bUI`5`SJ`qmN(`فX{VF)y}U|RWT"< b?<ɾRꑙ-O,_2"ƼZYk>sa8 o +r+9g[9mj6FO&@FZ{->9_b uR +'TYXSpmx5t1۪Od%N?`jb9nyƎDwOe$o>9lBރT1S G%įNL&6'$;ۘXMY L+`" |2;[2}r 3ye -/1 1JY+v"X꫟vC0d-1K$0(\.Uiiڗt ĒeBߎ(i&©Y) UjL6E+Ep%L \!@}co1q쳢VLѥϸy-e>La 9;\  :fYJYC=i[IqK=&\CkZn%a|Ju>~W-m(SJTӼ غdÄDl.탄<' ί".2rA Quj2&jBWb̌}2d.p! vGZb0#~6z`^[<3-;iP0Gne䝒_D*(ֻ)2Rh-܆Of ۳ådWዄ7<r7x9KrPTY'~a\ުPY\zllfLt'v"<:Rn|BrKbƊ%3˔[_Dr*#B}ĩR_!/ +]bfi"p~}SL<'(%Dp)"`G~) MĬ5lkz9o'hHpoW|>"WyxbjZꁣڍ&X?B{O¬V'u~` zb3Ta0AC.B@.9ȱjIdªH bAJ' +|;d!I쓻b0[K家т>Uʑjۀ͚Khw+VN-=ƨ_SgM 23Le0/!׽ѫx$#}k.b+9@BRJ.O-cv{e ߛI3㓐-—>UJ`J +Z\z服`/~κMTQ)=p HoJ b!Orw?tTŇC"b3L-E!r[FCWI_g4d`}]yyjIIddV&m?Ttwb`vTJ،96!=i,Ҟ;ƨqi T/8L\KJ`s:=ީ'z PG>9PF +tC9O皇WI=f~"Xu>:63;;n3>Њ<"*%,Z-.;гv`Vrʈ__:\?HO9S[sKf^p)UDxɡ +ꑙ&5Ԩ]U.D*K&NWl3|M7呜OTTO-Fx?֢hG bm f;M)a%5̮$y-5{.@&A)W8üܝj=P+?vu܉pHʷ)Sdœ t ԿE{RV \ܧw(xXEX5 ~OBHO鑚/دۧ;Й1sZiW*AY+,i)jʃ" +< ‹ng:w7}v:ӝo;l _');-T[L)AGuD5KO   wQ@L0Rj$vϜ$ 긣dV_𹒚- #l5VOJܗhr*-:*LW\VA_x#?(fouʊglkԖVRp0 [1Hv}#eQF5 òGRf!C1 HvY CMƜoG-4ƿR9үx'MwL?! +veGT +^txZ`vIr@ 1P^A]t3snZ9zO*O>q*eɍOB,0LfZmq'SVuǖ֡&Rj= =aٳәqG}'O>w`&mI6d`nāRid!`KaS^x{x/c瀵_]=ٲŨpqÙ_pN:XG`z·uIwEr?0OadmjV2D炝CnE:r\IMO"&udV01wJfrc"<Ò6ZDT ĔW1eqN8{մW~~'U'ږ-/xA*hxKrӓ6UGR;@!dFg0 CK-w@5%&ГlJբ>aՏD f7&'Hi NF-iWI77]>RYiyEEqYM +s_Iǘ'JO⾑[q#%O#V\/HRDa)dfhjoeN[CBy9zRM)`w>/ %I LwzÖ ⪟9p_x;ieeHuJni]tEJ Яxő&4'E {BvhZWyڌWM.ozil2rw#> ;YpQuϪ+>&ܿۗM[1gt,1湐Tjג"ela`F-xJI$-d2'1OuHd(0LNeEnrow"jS<$e:K ? (1hNpxI2i)̥]oU+Mdoa 񻸄16>)a?R%]E8)€TI=XVd) %EJVXp.idڌЛL&^ɇ9Fx 2)Fv_|d#΀xcrs̵sXd`6ҟ)fMÊWl!g۴{RۤQ (H=߶:(m/ 6)-DS9H`OJ SĤ +)AdH LXZwyøEKЛL'jjE/ &)6*sę|,$CJ`v1Rk݄'%$zRK='1L2)+wO"JSVs$'IO҆I65Gd 2cnx'udV/8<4_ &5RZCDOrJ8kcY)tFlEA hT9mr^9MO6MM{O +'?K6H2$li0gmN:Bk"%& +X8rKfãÒ2-wsh9Ȓ U6!KR<<^B>aBIk  >Ʀ%W*aKkջ)h7'k'G x>2Â{f*v@ReK쮨L@43Lzj Jyd/nj[C-=/$~$+1N>ۯ+u>?1Է: Z)g,'S(XJYO7!JI_s6R:L\,I9n?'CVOMN)iVK` d3ZA@)gY7QʷtۓIԢa仇>Pܟ&\f4+ѝtj>iyIJrcH>' vvƨb|#~z"!)7O(5SycPJjteO9C5n@)CɢH䓞j5-8 +oH\6_?৖ +AEdR r+TOnגRTY%rwͅJI_O,^cId(ʕɞNM[0r3 v;wŁJI⌎<*D +-QO^g*J= \gyhTԕh$y(VC)C;V7wͅJIΰEg|䓥m$|2 eS$`LW)w~RC!c)eJO)[i_)I554<|2䧂!zIݭ3UY3`CR̒$igC(𔲙/oi}rkQ{~C'FOpj|OR4SsՆGk}ROSIVƝT?N+ʱ"Td/ojd畒<]}u(k _m@>YI@&CPnF:zL= nJ9 ؉~82Rc\ʏ5:fe _Nz߶bKK>ڐ}^ʻ=`LE) +ոͩ.;'sRrO^)s2t"CwUuŲ^cN譛g^p9H*XxhyILa55GO ڻZwE6УS(a Ԝ瓿jT 'Hrf= Pŕ&KwR1rعW)ê"ƽr%>'7h$4)*DjDEd@v,7L *%MLո} ,8'AT)ͅo|-fR)],E|2 u'|Hꁻd?F_P)Տ|lwɲw6UJ}Э&mK'i*>83.āe(0 ČWJFm3;ǝ#~}G\J)m-:Yt%8'O_ pLW1Aabx +%RqY(%m~ apink_)%II_)9N2?'Kl[* |2%i/ytTw)2R)eatV?ͻ$tPJ1֓Mm\Њt!܋f˚+ ^\өX2e +LyY&SJ27.H+*1; ܏7JIAѷ~3lGy'=O;kd $JĻ쓝 %f +K@) IcUR#O|\);i(d= pm\ ?5Sy[@_R铕:AbR +۩D֢vV)rmjhg%dKJ *ھ{ @3RTThyYi(/H wg}Ma餔9ZcF^槕R$]?~RM~d2}23RD{S+q.4, _k#e;l˚HX~?+'Tr}0}\`JIP%ftW3"$LD $jlN9~O"2{U7!TQ.AsS%ftŝ +% opV 􁧔RnǙ3T6(ja?!%QO\m&@*(m;Uaq(e |qC?VEuN?,Fc.>rs3LcaH*tԥa ^{2mέ L͕+/ɀՆLSftq_o'ϻ+J ekO>ד>^~oGy2wg |2H%dVy[kzhr)~_f;wՇ,:J +X\H)iN/wp'*>'0+O6d݂5sP"H$jIcR.fC3˱Lh`z֢݇TJV)AWed~/\qHRepU?}m F+`y C_ycc.#1r[2iN}5ՌeszِŃLTr8Fk?#d kn'@R[<04.o)|rS2FOvqs[[ .ᓣ器+5rRJ$ApRH(uВ_MYro_bK;z'G&:DGz`F)iNPm?!R\KJ0}8ߙQJ\d%sSҕ*I>92k`͔8p^|{\!y"?jR1JYgsy5TRS"繝zi<\H|rtBբw].;7E,'I-?^?d AYJ)3إ;Hm[O(#B)vn-(eHbi@t9o (e<^/ﰭ)xGE.߅]/Q U[>>֛ +9qD`dIyPJR%)?cY> ePЅh5n 2$򞬯*`j?(9_dXcyf=7jO@*d7HOv!kRd9n-ҷG^/Fxs:91@~6mwQ$03 =-)AJy%kY~ӺOŘ^6$* N lsUU8p /#_ 'Q~PJK'9v:>үuNj#<2rǷH#-Y~65 ϺF,!?<A$~R۹t#̆\.hǔOӌ +Z֛HRzbۙa[]{Tх$5myS:~ I)3 jRg<$'IK4@Cxg9մ9 |=Y9~?$[PbXh IuŨkZbJKj-5S$OyaadƦPT+j_ȏߋ^4w*q^<}yy]=ܾ/pDΈḙRRkA){)&3rϛN?O'$HFW#ZRfG?-XĒps(eƯ&[ZjBe{#~FF/aX?d;3J igQ~h$8ZR܆z Nn{RC3?>i'~A׆~-o Hy}ٜt6Ccwg=730nyOEd).{7?*:20>쟕'JFZ[SH3I+q~w؛{4r@"= zb-<r{ojڪ(,E)P nդřIJFJkH(-Yj!h"~0qDT|ӞkJ=U +lÆHFO=Ac7RNk%7F֕FWE%Ώy!EL)Cwa)K>˓&e= Q 2@(!$xPCgۏ)v؄4& ~!vپtR3XY0vэQ'gv4 Ő<%{kJ|H; Α{F03ΈԾEiM +hT`HN90/,9cka َqvЅEqH#uۀ,X;: R>R嬢p?|,c ד02󖢨T ?/: IF{rgkazX,E^-)Ja"ŜHF}):^W{)zZ\i|wmL +ifɍIp q!,iT*X6},I[G"c59G6@BOvV E#)qeȿb;$[/p'g"]8WvJ:HJ;5)z֧b3C"Ͽb[S +ӭ?2g+XiT\$$lR_0(LʠRu_Nt)Hȓw8Qw0uL ӾEu=x43ȋ8Dq #9䘱3˵_ʷl ,qe}>l)+K  +JEFYxGðZڼp6//g}C՘(Y0vf8'ILp<B*ZQYK×{A "HILeOw8?^:'Ӿ|EuPG;'Iq;6'QdvTɝ9~dmֿ,,&.I#:YvRRiJQ@1)1ɹYIJ GQ}SC6`ȋ8//ۚ2Gɍ # l0BUq2,qܐ?u&<N";^RHyDR&MTs"巆aΚ}({u12< ߟh1Oz98L + ՘ X>egQQLeNVH Po$dzHa#f#YdEB- ߛCC*ƈi/ ,S;3KuiQFqo(u/ '%h԰՗ۛ()F+eȿb;3 9tl`ܚo*KERXv~KRB^((Cօ]ey R1^lfj_RШ 0/,9ckȵ^|~@,S,DXF@A ʒ7,MH2©VL59^{-iiǮbEB%۞fhHb{r؞DVx,1e79L,]g%_' bO2O"<,}u}<8_"ߗiE޿VO:ug몴S2ރ(+/+=m(x&P=K쳔| TqtDܹZ)Uw3ĤLIkAQbd-!*a^\0ٯ64Πg眝G[1vplK*ef]#!گ +F|Oo6riwȐhsv{ɓN-߳e9,1 Kp5$Lh@֤l ?ehZ)_$񗃺Z'ъ3T`0醴*,޿6툢,1rj]dQnpW?R g=r`0E$+HĞ0og NߵACFؙc}4sȏ;{l[D] +7DH;~аLf +Sf 6D~^#eAqnuMx!ruA<(`W8[eWha dڂƤ=uN2,.ۙ@JH3s@_n#HŐ8*kZd:B0("(.3Fp@*))߃eނe5I K0A)^)fgk|1LC0R3Kl[A9,1^_e4YZi^I7QL)'e+c4"Lwƥe*YT$(77׏ "%z{ 끚KPAI%!&H9j R*wzR*E};S΢Hy97D/oN8Xx˒MOlkx76)O ָ/wҦr.8=)ʅ))=_ j(DD-I N+5qT{{xRֈ@M~e/҃*)OJX_raJ,ϼA>0e@9|ϖ%# `paXa6`N=x?3z6|IHiH +}!ORԤ{6XrK H~P.A^ +㨨%Dx`U@4nrEʙrh߳஻ Re0; F +sr KU+m)7{biƬw"X,wrI 3 ak')jB= D;`)T (?et@T +Hhe/ 斗5~,(YΡoOrkW8:<}g7GQ_ކuC4,AtI0RH)úlgŅ\DWXAIIQL%A8>2IXbe)^0"3iC4f +<&)j#H9`za>(jrٰ,*QjL6t4.~XDʷYѓf(*RJ6N(Er>pCC_k٪AX⼙l0lzUh"0}\@vZhz@|?M&oyH9`V_?2WȆig HiQt ]5^#Ð$=ا 3~ͧ)RCx;< >rw ^K}~F;S-ϰĆFљ`oLJ²)j){^(̐ RRԤ{̴ `>aVWUكqT,[Uo 8/(9)ZykUjzOI֢sJFQn "ay#_? "t94_s]0R4R"BnqD%H=NJ%;dʩ|@yUМGr~#R23D_G\*ᠨD9"j 3i>ib8 qRͲ&kaҡ8m3ug=r`vu&r_}X<o8 pΠHY [-SE][5 +Rv! 6&uW,3t9Fw*ʃ{ٰuK8C0p%<'[i>vw& +s.}93e(;=aÇ.4s@_5 ``V +Y\e0I:T'%ybH͌HٽTۄ<BHD{(jJTPR2ϓ†eF7TKp8I9?ɌO3LL9Г9zi#8οvwIxΜːV6j+5UWizjWEj6UwەY !!`\CUO"c}Z. !m`n1$ߙ, ig`~W3g,j.,Xh#&HE׽^,eD8٤>fugy5sR宺_y(iMF2lnL^UKa+;*[.2cڙ%j>TyYI SKcJg)exJ_7HJ +sZG~58cL2a~ɁeRZXa PҖՄ _"!1aRDgT.c 5!`f#Mt'$>0r`9-E* 9 M;6НH')ZL>oVs* +MȺ6v1zDR>Փ.1|(aKvX.(Xfj"C>1L@d"'Fփ(W+ +J|=jR ? ~cU>H[09Dڄ°fX·82ӫ蒋1vJw[I{-NKnp6D`6KNsKv9g{,Ťu +N8W5@/32WP-;E/jRF- ,RFŃ/Zmҙ _lox `cGvȹ!#M4.cg)p31R'c&SA_ Z>&)Oü<<^HJǓ/3+a^<@߲Q |MwuR߹@7`X˅n(i0")K=S'Zs떚po!)1LWtxC 0V-T-vseGPq)]Z@z&3_x3Rj3yYO‰߽H7`+Ii +Mn-MHx .b[k`&]Oz5^B뿓1̳Tu1̻Ik*i!%)/a3Sw@w!f6rݗy.(JlI-e1$O7LpEsߣ?8I^3 g`A)ڭ•T#ud3"0LKWvӓcL50m fHwq`H)[?f l&}x?gr97 Ai3giۏSwOAWUFu2dmb$xj55LS 3R XoT .1v9&H#l1 {*mD:Wn[3Pk.#eI^{?/w%kI[[f(@r8\ td`%}sO:*+++ŹI~ڞJ <<\pZas``]j/OBlQ+jgc~mc?Go;cֿI5F2Ɨ+VRDm=7M +^jRV͉ao6pj#MNb(ޟ ,sT;T\K=('HJ!!8JngDoi rǘ_u* > r;U:;Pg^\Kô'V>ܨ~{{-Lu0lm JDr!pOw +{DJУj1 o + 娟C_+gO'Z%;0$l$SㄘQJ6)N5@A˹ߐwi^`r9._d 24-g"/=pn6 c:) {7lC+?WYz7@W*CUFUu <@#K@>#sDYR}t*xB;0fzH9@[o'#FM|*7ѩ z.njWMJX:|cKjg̓DJ8;|h9JoSBb)X^K=0j{6p;{mo%Ga kki!5q! ;>KI)s$#iM^# ?Z1̳ſt_X,W"b&)T=ej뱺0j ̀Nj'%R[ŏKJ}aVHZ㗙vJ;=aVe)2}.Ul +΅s#%a-ƲJdeJY>UJYIɁIiVaӽK 0;oU0m)Uc6VcΟ8W4վZ`(LiKmɴIai0iPsؒm|M(%@6`1i2+r8@6͸ϻ+ɒ6vw֫]iw0aDJ*W3e09StM+}E[%djj+bilLY=<&>!Ϭ*cF%>X7ɃaXrj]YORu6fat +`鰼!o@U-@ʁLFV{[De%:BgO<><9P>=aҦ)"0lZw6{`U ++ԗ֒oxػ*b R*ŰJId>a0 Q00`RYç=0l'jY"o߃*j2Mhm`)Z !)؍d~q3$ɟ#ؘqtO6  þ3$Aw]`q"6AQ7Soq%jo~<˚e%ɇHiTr|n=@K(aX4ݻ6iI Y'vaؔ*Fp.c+mnG֊j%˂zWߛi"o338n='/;@JI̜0R e-?iI#0,M 4GheEfh$9Z|%|Z#zihǛ= z/ptDLq9iY!Z9s-誴ZZ!/ů Ib(\fOq=m~0 ıJB7E3YW4-V޺,ݿ z?pd=jo^O&wݭjQ]ptysYГ< ΢EٓqR{d OQ zY2 e>8wI2m$G#i lZ| +bFoUpvhRJ_ß<ǕmNyjȸ+M5*+rgC<=bb?&&ޔ,/ iķQ]3d̓kxa0J1+Ŋ:A]՟&jK@]+ |mm>9s3^,_(yYHĨt5}ؐD ++e]iEOyXfA0Ko0,}jݳnҐ2 9ُ ace(Սbt#h)EZ|tQ-_zh|w۰zsrIjZ|]GcW(;Gq(>f13ƄdΓpa5IJ$*/ &ia'mI aXGK1h^b,]~ּYx8(6T.f\ m:X-=FPbZ4>ѓI({ndaبIb0$- Ű za 4ԍNc̈ۦS˗Kõ? }ЮsQ14z4]rO%pZ ĸlPbИ)7'$Vkf=94tb=x-/#n ȟ#YaNMJ4n#݊q\Kj 7C{9'n6\:Kwe'cυu1&)#z=i/ZN)t?|0 Linw )Z^u 8`ؔ*FG8 ( ]ֈqu%ڌgi Zx1\jxC{|7IDb^ϹC#JI J|蘄FA\/%L`cRIEZ8P>;Ma.;nI g"&1,mb:4:.11hLF(9juW. Zط*pd};]9_t|\<\:`9]&a46q=ԞV{ɡ":HJ Ib0\&p.e} ıs H4R74mk_׹|_|9w~\Y.Уբlp$iFaS\%2mg;wתk8wkQaDQgT +>BxFgydI=i{?~>IEؠud~iZ#L˄>IR@y-= rVrzl/fa1+xr[/|/PHݗEo8x45OD??чD(<<|4&cEGNk(j|٦8)$(ta}i\TŨQb"auTIFA) x;T xl_q_[yN꾄bo[N(`^a!q8ч-nwkQ?ߑFF򤮘LKI<$,/rV|Ơ(j86gA'!ٮ0W% ܞhKŕxr|f\AO*s]oDZrPVԸ莡KɍyraO2L wkI%~bUYg͟c~?}5$ ?+e?@%*Eaq41sCC*-\V|kW? fwJ|mFZv(`(Gt#p("1&0 `R=cSb{¡(jxȴ|,F[֯uUٴ] p:?en\ʄ!W _soR&uWb-qY2"Flo.;XPBԋG &W:GE'%pU8_euјF8,c$oô݀hgbqrts[/)p9;Ǥ*V+ +#*T4{U1^\F@Ejݨ?xU<6|Ѩ'gЏ8+=JulY+IP]* Y4Ba]l FbُC U/}G9RK}Yې1btrЈ9]MPDT1Ӫ>rziE-@Rt:%ȐS}l2GňhdЍU=ǔe[B,t5{uo}w.J=WŁ&a DbD+@c܍oIb'YI +Orx_GȓR, %.4>"Jc,mZ +Ew~=|ts||f|~7>򵞖ګˢ[lFF0Уq0w87OjEL <^*)a2FuⰊ_ua(Ƹ3-* r1?%b7Lb2&;ʑ \Prտ~Xk)/z0$ Fc!DD^6w9t$(RyRK`I6Or}"OR+T`E`zЪ@X\7XG##uEqf(%o O$|Q1^KsFi[끐Wցح~xA4)"O03Ƀ<X<^8,>bU=R86gy>Lj 暧_؅dRܘnۀhteOn}sOY[_{uI)?SWsfHa̭rѭޣ4%&H%gIH`I*ODIqZIS.EQΟc>&ŃfЪ,Ŕs)gShZcV[0ä.!W +^iFrLj.ub0 +2FC1=tGHȓ'SSg 33GL0>v9RZ)9H̳̚zhPhԔXS[`/gSk4N:S1T,uTKݗEOD̍{~0!vƚgE'!3 3|3 }R|?]S…f@>)2HBn.Y%"V"yЍX.}3\%\5T#x+{ B:p0%n8=XO@ąHh^ȓXbR}qxVaS-9VDZgä:.U tAt1b7#aܤݬ+tP{r.5{u -eRG'ychcg\R8E%C'- +&Lr{1Sb$E8oS\>N)BBU~PJ4h[WuhҤp~iRPB;qqbqǹlv9>vHy$&  y?z~>me)+qe~j$RZFJѤSkL=x@)v*bhbbLCI@W+6"~رN6;\ +\8ꁋ3!OSk?'険QI}VBa&5{R<)mM{F-E)[JO + D!H _E*߮h$l4.4/Y*ɥpEKXQX%QLȎ'/~7"m(. +V4 +^~q|zh=ԊtT|bzR'7RJk}>z&[`߾]ѽZ9aExS*)&|/?SQi]=µI45 O$E@cfg`{G=7fJf.VFai%@B͔O(1f]7NŮňnİ5=0)}OJl3 MIaf+1){rf{y nV B1/ױ㿛=ٿP1X"G#]B} 1<VLdP\YM VM̓k)hߪ6ʓa#pn2L +oiГL&chbP\bf»ӈ?b|eoϴTDZFaP0h'ꑹ$Iؓ)bİM_s۶mRxR"0 Up0PYՉ&C© R~wh\JJfa&YV,ͣ14%'ErX9qx[英 {glHu:{64|mN>*F>hhYa*JIكIvGRiaC(7oieR=~̭F32icInTIFYӉڭTGvĎvkцweÑΏC&aN;0(n>ab~ wht24.w#T +=j&Zy 7*ѓ.Vޣf3.W$dɏR~,׈"*&=?BD?o gދtԅ]gB?σ YE[ҟdJK hD7bJjF2L.)~bL6e=pl Ё'C{򓥚T&Yn(Z65?Mz.~wΞ=1:=BsK Ђ!(.\Tbf(F ,zR$ I)ѓh'1\$yzTݎ'j_"j"pt! ~;U(qb2@/Qh%Q=TIYI=3F"a>`$Rf*ɛU[F;sf]z봽n*x[c=d8}؀0'=]Qa:S' +!%Ub#$FOI P0E)yٚ0O +wՀǕ/}e_t8C7#F Vj휜@O$`$ݪ6ГEC^ݩ5-SrcRZ7dSI4`x]}Hi#oV)#1II1^mXX[vRF>C8vXp3AmeO;j vx%0l}Oj +uI >hߪ6'1%rbQuwkV("͑Lpɦ 09nt:),G:ݶqɾ+^;RCðuٺQ~~IZ|_ 1j[H!F^P6.u֬lRKֵ>12m{Ntuϱ%qr#ݝ=T'%X-Ap|{>"nyIꪢP(IQ&u:K`5ׄy)goX#!, n4O3FJaF؀1*|L`lq7v !GolN/[Xƈ[v#c}-) +eYJ'P2)v~MMsc5 sI,b>De?(lH\v8oq42֡.pW$VJޚ˼[K].pˉN.-Jp:.}Q(T}ZT +%쓂Ї5c*%R FF3I"LjC悈@2%%zZS-Y$+㕜az[Eǔ6v'"ީ-CBY{J'5*P2IYϚ[jRw7.]$g+#Y?1 LҀۦ_ݹd+F.;EVI&fE.c}|*`JR$࿌ty&"ɘ:)GPֆRI_a}RC{A\#PhRۜBg +_33̭f"&l_H&MwBhJo{^+HOPؕ>N\Q薶cu}? PP6'Eut Q*UBYP("lă|R1n41')wobC*UmȎ-CrS +)8[\ب+&|l  M!hO'qK]jH*P(I:g:FFTj~mpHR%z掯}h/̚쓒;du|R;kgz+eikwL,p/s d2pcn6klx=J-Lcc3MP@t2$yR({d=!5*B^UUQYRR1mٽ~G^<{̟|mgY,^AffQ5*yS(_FEtn%(&Lv!l2EgUq`j(\Iۢkbٞ.d- l:hr'"ީe%A'Eu $qHryEeٖe堔ۿ\g=z虧BˉglhKӖco*` /F=nW]9szv) *z 7A#L2۠Q_sL&+Kqo[_ّўNH:R/zt>vt%B5Bi,|PGRV(UUe[*|`cowO + r ADPoK8 I(φRedЭ̤yR rŗ^.F&k6|nq#R&ȨF~Q*|LA XX8o]Uet-S~|pkC2lsMǥ/P +(:F4BU] ƀF* ޯ?xgק;p} +8ǃ@B=d9a®36&w֬>Iٸd5Ks̭fuMm!X4>!pprl"&C6l|!:>?[tKNuOT6:랈xh$&b7)BG٣F#Q]UrR Vco{/'^=fwIm( b!S[ωWsn]*JhOf*Rr7oi/p3!!܀B +$$.VH+jsݴ$!^ ,4cO$>Ӻ)Hۍ$mzb+ϙuv$c;Gq{k_w9{*ֹsm6.e۲F6{1N&CxLjƬ1R+Dp GD _fS0%A,O ᓐɎ';N8ucǎ=zȑc>j~ ׿~zgu/5HHbih{hRY#caÝJ@&=頺(;\e(eil3DLUC#7|YgS>Ҋҵ>m![5UUu 녈 +,d"0 0&y9`-Ǽ!ˆ&Rp{GYNԯ3|䓟z)|{?zo]u:Oކ.!샓q1-Fuo|:q>ol3t 7\Ds$%+]UX%*̾zs'8NFWR=np\ZJ +PsmA?!3Ҙ~3C!۵$$ŸG'vr{_k (%& {v9 H0r?aL1ƬQ"65OmE8!En?0H&wK赑Fw?{FP?G"'3thq4RH@%< %mZp<aUPQVַ}1'fsLq\Qq0sܻ 44R\ر4Yu8d쳩Р\aFwSl*]#$ggq4< ?7 +uwcݽ\wқxZ|J^:/A0I8+0IfPC H#}1̵k\,#}9F*&TI[iwQ^?6@W[ɤ"U8_jhCoE$.ؓ=ǾʇAͦBŨWBaRPՉzxp>Z<Ơ"ki2YKQ"|Jٶ|9\2|Uτ›Wᒱ<2i߹`oh>FR=Qīy9 YW +pp*`z<&9Lj-}dr0\C d&)d"lc݄k^^sJ.YX#J l%DXיcu}mf9$~VTU52i\+FP;eF^9raKXe[hbO7.KG1ʂfzzDp4cA3 +M Zx2%d?3<]vK r>ak3Xrf%êG?$%r!!/J VEN\6c+PQHչ?H^@-yL%`2/i "ZDWJfS\r 96ܑ3Í`!0(qت2nRCRc%?ﻥnʹfضT^g3i~#l"RJnS'Tpa$ ,cۈb.WuxRi5!~5/M- +(,⠨8 dk{Wp^Uk}eiH6H,G:g"Ckg[9n9<\Ӆ^B,M$$Y}Э&l'DmP-XgR6ǰǪ0IC#_k?rvw؋;ZGmFRs1USG]XΦP1.gu%JCsh!nIr1vI biẆ=1z%ç{;WMdwE{O&!ﺤn & Q{ ᐤT 'E[o؍aV+UZR"" i6 NHJJp`sN>b'Ƙd}0vubh;{#UbgVV$ò?닳[9gK2ެRIҰG}d%^awXgڌT.yNG!b',*!㉓AR ,eY_dl5:*Yq&:c4/][J5[[H6Bp%^2c,I]uIM_B q񋠎6R~p' 8M/:xEnߝ<H2\RW2aFanfj lC|bR^4]^-hi^} ^W0$ |M#ߘ +s' w a/f8 +?|"tABeQF#m4^D8oMӋ 8A #1 ab/3.,rj}>Q6Y6qx fgan`˽2%w`лc}q<#I[[HښTqhN%y-'(v s0)EXVP<o9H"3`.'yoS)-lkT5+QL;(޸OڲFX6j&Xk,k`K IX3Q'd,_H M:ܽ=y|M÷'˪hH +"Щ$KyǒP=ԖeSլ{j{R2L|}qRO~V +XF6UMNJ$Iӭ-‹Yθo=^?=$^z›OnHAO',yr{Ԑw#2lE3R2dw'YC6JcL VNLD[ޠbQI.kL c$IqSn0B_ѓKK(Ey@vsLxf$uH/k)zw|f6sZ𲚎7)ɳg}u>QL#tu^F% wV[y;턩!<dsW !#1kA V( pT2Źp'] F͙., jMjng;- +/`n3vYZTu+jgwya6WSbF fHJ Z|_2 FE8`nT-e1> +S%̻Յd͊3*eϖeSclj'-U]VcEscqpZx<<%]9y1CM'$ez0OOmmà?L#cwπ*!Z2.*aUұFVf,y W\nVbcin{Eظ+[PW;%{ʥ*2tM491bB$v Ꭾ+5d!"0EXh(kfCrZD8#K`F&t%6E}6d:R2;UƴR}[U닳em'/{)+SI6aWgIhR fqy7'-]_$;aݴ ;2C<-rA ,RѐlDZOM# G3[fk lj{E- '<0 <7] ,?fziWSbCP_H$ rJC^^{9uw)IR8NF8֬DJT3ļZ(jT;5ڲWXVIv  c.IZ- +H1WI+=7 +"dGoO8($y4`0c?Y^&jdђFgeT6jV܅e2l Nfbk ɭ`P%kg]>/qWIضh6) t MRR^'#$u``>lGpf1)h2 |r3*2#C([N^-`˽-p@9b$L)KZ^BsWz着ՔؕS EXM <{𭳷xc0 +0"ꌭSIںsgtЊ Ll,5liA$oZ&<ZIYxIV@tI=A||"8򝺥T !#1DgU*` ېZLF*pOK J,|ǚ_[HnfS;ypxWSkV%qVGs%ɾV/Hy[Dl'AO;i=:ACb0al#KUrkmasCjϖ8/r%78_U7ڶ3hՋJ[cje怱f7؎RloY{osƬc_(@8o}m \;3 0h]34_ +뻉9'+||Ig5ȓr6I`Ħd* ճ뽳_wO^w@`0 w?[H$H#`J&R2%xYVB^X%,z +&\eb׀&`ͿX_Ƙo#b\CގJN'T 8Rҹjq0RnE\.$۳ZV.x%גߠ+ڶ젫To.[~Tg I+|kKpBL^(wѮ:A%TϏ{zM.L´Ur4d f`B)1pH 0e [0͵B*^DWfkIzt&]od^ʬQoL0YA h +X%_z7HJC }H{_|raf8! f0#~-5ogj˰2X9˹R6*%%d+z>ԼTtR Q53 9ҜAL[J_wݧr UvUUv鯺g$O;`0gv.,=Z Zv`Y2t$"–p&[DWf ϟR +.-mSc9sNRD nx[<@Fx^@=֒.k0RN'7?%nҋhzG0 fC)mpH6euA'-LZ>R0[H9ğ-$7z*vlsW1[(Z wZPa/y@OGoH8#OʷF#dCb˧.`0 YӼZ*wgCHm.߲e%lObz}ް^HçL|yMJMR*y3I0Rs۔#~b~!S+]Wj"#1-Hk A j6VIGZjQe!ؒlf7uaK`Y/$KJ&|K.%#X_`2d}0W}i}`&]W8rard?{~} `0:ҬXNGVf@S!!m[CJ& +n \r^¾SxdVZh^ _}H<)*$89C?## 'gwϛx.d$\/⇔۲k$$2{}9@˹R6M%SKaK fd5ՐUԥՈp5_N +#mq<  p`-$[7vL0`07XgAga U'HQA*JGG$RǼo@tǁ>y%F?$i;/Q!}B}fH [(MR=jAy}u.)T,,i-Us9_uፐێQ~FUݖs:@mudW#F^Ģ\ l+W`Qg I y (!ܔeZ 2 _(OA}G~mqܧC?z8#sdϫ|Ey~2! 3@R_,#0XWfr:Pm}[⸞O"3bCHKnƵ鼃-< <[tx~O!ECb0P4Eq:\FLAvu. Bey>kx={ɧ^ lc}yGMz\H PJ,=RƸtfPnidb0Tm쀴6({P.:HqNzl8lyh8@l۠#t§ |u!^1B6,7 6*t`%TUsqqsZ#;*9P$IzNp㡏N(L(ޡ gGoEFb0̇3PYf>[e"fQp}d"t`>q=#?Fnp㡟'py`]vOX koVqI( &&u ^K0@l b^۹uhc;׶4J+lC$Mz5Z'- Ǒ EQW56T@R]v*9lDʏd~VpK%U|nRlrg^2uL#)'(BNrv04gƱl %JL[[,)+n,E;B(/pc긿cl}mlss,1j|Iu)^75iN2$EQu~qΣTr۳`rtKg)1~ab%*.j`>Rkթ0Xr lWb=9Bt}l㞎 ȐBE8FÕD&&V.׵S;#>4_ EQԅ9|$= @聭 -"rͼs1dE3bD v*n5!̳?:5 ݻ$v{i,=F2’+d6N >nzw+v=WqhJo꣎i[H(Ҏ7H wI ASj.S1N7`M7TsbJ_ƕ6# +!Ü.Vimt«~P"Sg]C(]*yg?'Ckr晷,eB%e_ԩii@UʴY &X.n,/l0PP0Ca+.;zgu-,:b߄({gE؞((Tv&tMߑ̓~d;8A#D:GRUbpn5ەv긜RapI0&|hs}G-*"zƝ= JqnL^An5ԏ((TҷgW.&\[,/߄btb1>y@g-65ki8<DT =%; b h\1떹R+bkYJO)=*:REQEQ,Ym=z ms&< /.\2”۱>mJʱ:򆣇;:\ns3>4nһVL%cS3 +EQEQuFLXBʊ0&;|UnL2|TOH*1RbiQEQEQ0GOvcu)((9C7y(JREQEQE` endstream endobj 11 0 obj [/ICCBased 19 0 R] endobj 18 0 obj <>/Filter/FlateDecode/Height 947/Intent/RelativeColorimetric/Length 20505/Name/X/Subtype/Image/Type/XObject/Width 880>>stream +H pT/!&_aBA+ʄbJZDhjhb"SlSF[qvBP +P)-7Bd I&;=&_{{|!;Lsw9W=!ግPڇ#=^v^fV$Ax 6G<=\ k˰n3,- gGX+)G`{[-6t 8W{17# 8nz GJyH&AwB tTV \D06ns'Ab G.⬊FI8 dw AZ-hV7%\( "~,z2YlKA bYqM V&u8minO1"`y;A^[7`:58vԆw^Z"VPQ $A.c'nnJm4RD,8>F75RI8; pћ"AрMV7Q#(Ag^PD ,=A$ۂXtSADXtSZM#%A} '&3>A$ u]NgO Z,;ȘuS+\$Aǥ|Z⚠nƩnc; 6,n>DACƔaw 0CKDSDr * FVFw w? GM!Unٕ#A݊a2, CŮ~ :vW74g58hr׹Z܉&j,v&pu$A\ t_7%܆4R8g ?#n#N{1L9# KM?)Txԯm4Q eS/1uC&n>v3>'$x i} RBsNOuSnk GH1>pRfDݦJuS­LOEne9< +]J{X/-0GOKK;ֺW̷Baפ =R2XG8ciLaԾG\},Rԗ)2NZʄs$\Ed\1f9t]RE?%H7%$\QO>KUsj Á]Sb}X & q kR"D-JS2sO}Uj9(%INtSsR"=Hla|9.X@S0 ~}}?X;8bcG[ʇ +|f|k|njMV Ϙ0"# F‘~$K֦F`__C KsM]f[:pfMeVtmdkP!(2K g\^t4饝T7HAھHL%}eu]EȨ;\߸`@7s%\X:]{x~'a,Z=lcx⼑\†n Nd{pnqY8ҕ2rr(Km{i]ذ xx;?GuGƼ#Mo' _qScm5k?bަTpt57mbtSLg ("dw2{J0ۅ}.6DŽ'<20äFFD@pa=x]aO) 've_ pPY+EЦI7H8cdo x".@״lᛇUrB7mDy=D yrEcU'tf<'_21uMq!~pz7Gqc:{loP%ZH:kծJp_ky6\ME}ߍrAp3j Nk˃iqV(8dݔp$\Bk9~{6& %dngZ8A(S7WSdZg AZ=$7`&&X护M5*~Z${S:ƎVBLJ`Y+TH$\gR|%1닶43hXz4J w @(_R `_ g,]ƜrlY.8.lg;jȾX8w޸`oO:ݔpZDE-#*5D^A;LI56(VX 2"sAVãTl1qVx`L2% 4MTદpuwVUn2"`Cpٯ+ sAGETdTQXRP#m5)hՖg}Ԉ $!)f,Q*>ZEB ַG0ujEq@{usIg0ufs_7ZY_z_W9.Or?KSy/?X?'[Ư +q'+l魌~_$ۘ\zFܠ=F_.LkQG+Y I1ӠMå;o]syk.Z5׽FĖ .?Ǐ}Q$^k0p2E~L4Z ^b7k'7-Xx]#]Z\)߽+k"IJj~ނU7:>"p3{+P֬&Y}4cI,ҝ~eݣV_y{&!DqK;]F>pqO׳UQ+fRn r[mEeZv7a񺷛p^k͖wpR{YP^:y-[W!=AvZk^w7nquEٍ+y*+E/lͼn=XN|qڏۏ}kO*lXZu^{Nj7hk k!9n>JTO2A: 8A ߆xm8 Wgqys޾;[Y5kmx] ~G7K~ t"\ZjU\^y[sΜ ~lm}r~̜~=oT*ZKc2 J +에T{aku)\`f+Qg>q,^yײjv}5}_CC9?׍5py¸<{{n9ZFp699%D@7˚qDuX7MA +0PGDrz-oD]][,Sghۃ,o)ZOXSK[j_Md,o) =doٽ]w:I߭Vym: NQ)#5Pya:1Mda +0D3ܩIF) rv7u2Vysr5NZ_kWG,7.W1n*I'cT/#^ "DA7Yy#H^GN(JPysRn@ͽZWm$Bd8bnPy!X,o*%`b ͵vaDm9*k`U74\U䷌*G`R 7{~oỲIFAJYAj'c*ay#Pvs$^e#'$;#%#7Btu /]PY(n6 }j2%5JoN3o*(SQZ@{`%(n~̼*8_$75vQ89m}3e>F7 ȼ2v3NzeVoNƔ7?NFbW6]l' ׍H)Jt!N7i_o}2M\FtIXV:}w7Q{ER*2(D8d,#YV0 'n u vqﰼ8&2M7ew"ER"IuSQ{9'Jt շ틉@;7•#%,o,Hm7as^N~FNzp┷H~2(k'ÔH5 N;Ɉ&ˊD,o,0[$'o$-#4i'c`ck9-#4O N27BVֹ0qs!NokHv2Q{p.$Zb*7'?`y#`y +Nyʼ0 Nz$ 7k'{7uv!D P´vYsv.Jy3wh9#5P%(-+y#d^oɡ7B"Cd\¼2k'qIYiT!J}q#d!7'a/:$nVަ4A7'FٯX2>c:$Ok +a "TZKX3@-DL~sCBؚJRa#jdSaSB=Pj~>?7}uݼH:ӕ8Ps%!kQ}լ'0@5s7y1zޚ: ym184hR3 ̷݃]0@5O u |d TsZB tS%dN=ycՌyh :z˨oy:I9jJym TFM~V /ɡ@N#bnױMJo St>Ղ9G|hFqK>IEou_yvX' ]0@7[Trߦc44 Is(C= T79-fo1rq},*Z Я ଔIۤ t|b- A|i{o畤79ϑ(rq@3;z(e7M>)Y'QynAy: kN`rb$z + 6 ؿɨEqWMz -AYtQNÎz:wEny gI/#Mɯ7Hq|qAJn$ʅ "o47e !en&3_$Cr[Zd3 RQVtJş y8no ~IئɋݧA"<UnƘ8MsљGm gSD;[߳8s GUd'.z$H>#+?G&/j|_KbyBg*y3]p8r T6mܭϝ8st9 skw?"cb4G1k[[[i-rgClPN^P}ŝ A-)Kt[yS2Dl;/#7\QW{!cA2fSߠ*'<A)QB^AOʓj{_l*9u3Z0694zKɈ=kԦkgX5œC/Duj+du#j{\mT W5,\BBfTuնr5Uˮ&,ZcjnEqD5򑩕\F>>qPS,*@n[1⠆+Uyk8*;傥's$d#RS.[T 9Oￂ 56܈iOEqin5n:9 :b .lq6rX*! 75F0h3X*!/eu89~2*#6}ن~agoqԼ 8LޛUF;2ʼX>Y0R\£*C# ~}1@)kȄARl)U8t8ڏ(oEi`9sH ay|AS#3'yuwѼRR8^5xo.}?Y9GH }C/>?f69^ȣ5HWPNZ,2χP7 Uk]R'*_U|>{r Ns7RUVT J1Em(-'P6Κ#7%6FO%ɏrsλre֐e}^ݿŵQ,rm[%Hogqn 9U$Mw X~LI&M{.@;*BR"J _-e Ax!mX렯{.z?Xo˛t>g\q WIge9frBnI  Drpx+p77A,w41ތ Kc-6{3 dr+nY1@bUJ?ފYf9M2Vj_}*oR[vz[ `9N}n2}ox,7Ie;K{nR=θJBd^`rΫ"8<v{u.0me`BkX!8}x H3Cn  wzop e#8K!7*K%\X~@[AH}xe 8scs nyv6Pu fJ}WZ;I R@?G?| WJPѡ?z`A,oEoEps8zWhPyEFTj#wŕ!|o){n9@?O%ߙiͷr +pNUo1cpMCp?!;24 J9o[o 8)ur> 8ЩʏG7$8\)An^F=3u|lRbz=,p%s[ p}h{3t~7P$翛h{Ki1rM,oMbqEkoM/gi\ko e+1@[fha7Dݑ&5IPE8sְ x91JhiXGQ;AM.Wo ˹x7[J2byCs%Tz?X^]_417CcN9>$%C3W)B9fbo xD՛+N`R9`LυRd7P4w: J AIz&8CN7PJzMo =@+٥xz3t&PuuB0@-'-gi$.1@-'F˥X\JS7)JU54xoTWʢ-11@/ mn*G2 r斆L^pk鳄%s-2Ny(%-PR;: 7tHr]Ku'羷=Io*Z[L.;0@19Ul[B\xèЁK7P󰼷}DeP&-gh1fsK h e)L_o1@7#d5ԕw4}`~Yq?3;33n(Mj6J1zAŠ5P\`$1i0FBQ"4 mѴTUD:ҨW +5|k҆@1J NPlgƶfҟMTo8NV>P'z  y(ɘos|l]k^.dRgsНӟl Ut*P9bf p\&Q߰c3K"^ʉZK%ԛGk^T "zo>8nT2}Ǡ<7,$پ|Ypɸ͠RƛppgH}{%Uo9y/YkZ9T^gXaYqdQ+5e>(HOnorT,8CYR^LHꅽkzϦP: I0Mȏ\552\)uIheCkW5ToL2.fp=@3 '&r!M)4fQE655[\-G\Ћ{ZѪW +0N-8$_])yts\YOlӉX4bBoޅ tPp ˛…\sZ#N˚5[6iHom^=vh\gSr#7Г\`|tPߗQ߄VMc=-4$aykh؟uP څu4%ݔ|`Yͷě=J=>KzwR1j5L҄~[V\rg ;pmU +tR͡Ƴjlor7|HR̦z 7#ۍ@1J"9!wc,w{{j6PjޛGkNcQ[SԪloOu'70jb.7}{s~L4NZ)͡1IB>5[˺(Ǒ@sB.|m{si٫X'_yoDwb+H>Ų-9 +2/jyi$!C|.M{{ , }{si 7-"zt+XC|>mo.5:h.E<ձ7օj!'3x9܃ Grxu8{r}Ft#7G닩t<u!%ߑi,eAT.¥=_Kn$Hհ7J9#l>״7>2CIǣ_!q \>d\ͣx|ojV QuG1]{NU:3u]oy"7K7=i`bxSmIzhٛCu ` ]y$E򹛂}-I#B٭ш_o.M$XFoڝo݌|I06O5ͣ![$źiNϳ $X'Ro`FXGt!' #ycoN|HvK_~4w^62[o>8>ަ]oj˝^?NQȣ`Gp٩6kכKzIv^\* l$X4m^֬7Do`!ϔHͥI`%: V^9 @qi+X'Nt>7ݤUo.Eo`)՛GeMJx[ ެF>_1[uǿ A5lMeH:f` C.50ӦJij>d+ְrRqfP@&E~߷﹵\}=:sޯk'ΖZޑͦRR +X2q etӴ"ݓ +H9{I5+H7*Po|s -=z +N욾!yۙ7G~2o(1Ņ-ۅ U]Ϸ_tPZ;2"˻dPf^OZޡ%#UC3AW{2ZrC}آqN̼nY"9so۰A$B-Y(5Oe)D1o(7)FoLZMo(7w.Fo!詺ϷHF.aPr;[Ho(9?,Dov^>o) +qOƲJ~/(ȾUzC~R_9PvNɿXXμBkG ׬r +My9 +䝛W +꿖9-gPAwo7Tg["W*k3r-v&_HZ4&"Z{+Dʼ".38{;m`˲E*#aT~E2'pN:*+8;'傼}8'Q)^9CS|K7Tӭ%HF?d;P)N%rk*[fqtJd'Tw[,]XIo } .C?7 n>\PQ($ rNlkI߂d>$~g7TWP +ˇ6ͩߟB=$1(#ѴnҜtO*i=.71o'upL{y4]'|βhzĞG .Y=:$&KaLn٭0YpL9 pB,+kUpW](y"D?-qet@x<({aހt^erӳn2zށ{+[3А +(x@-Sz506{xgF?PP9"Q].Lpe۵g +ƣ .3ug[,< ӧ -V08]55刭4O镅Hj+ h x],ݥg0OXl\6 ˔AzK& Ɉ8(lf\"s8(Ƭs3 .3p@c^w? Pp|.<M8|DE88+'\"'=>}`E24tۧn{M9}dB}|? +PxqK~ h.][ '_Z` 8n$2yzZ`\u\$О5pe} ;]p|;I92'\,=qaT"YJo@>;b9q?prrEj^p@R7\8UNCL{ހV8XFhEpc߀<]w\"fY.D UNIȜW(681_⎂d}Z;[7\"(?&.u7Ʀk~o46X2Ercɸk_\,cW2p@E҂79[8]m U\"S_7}ܶ+RkkF,ڔNܺSǶ5q5舷py[Ge,$83VܫWgE-w%ЩwIZmfTzT1ӂki_Z6 +#Q˙AC?3 +"{QiL- s@7V&7;WǞq̓;Np@wgܚkM'.1孢k\\$=KlT\"6qP uFWc}KnL{^pjYV܋osd#XKȰ v@մ@ .8 +6qs-aJR_E!([>)ɰwȆAy9d 39p96J ^_ޤ7{}ݮNi еjz{ZyNM-[8K^׾jj&WAyIz{ӵSZ-)9(_QUw?啘 +$AQ#+X +>x4 "2h;NA* +% a)Pa HA) ;gY{w?;ݻ;{o4Hz%"ADo)E$8P"HH $9Lo8T98I"/!S9R{K[# #xVVX)Aȏ| NUl@p Po&vPfKo|& ]`M~.48qmX͡BQreI(6Lli-c%ob)IJ)70qDPQvm{uJ:7\* 6b 1X_5؁ L4X vb3{#$@D9Z}hp9L +8'%& {PnE$"4)m778&Lwnoepxo%?L,pn\㨷1Ln+5qtA7X]6%xPrɋ `(9gwre';ZvQ.Yt^T$ m7 +O!_k#5ݯ4cH $JIz j{.i&-y1%L.Vbp=ymAlzov>BQrEP̌"Eme^M?#K\ `4`z8YtЪ2:ʑn/qHw7&yU]T]5)ly=5HN\o'`9rsGn&=/l+洄nYMjJc!YC{쒀,J(`b__4߀vMdd`U,{7aZ~ҏ1r~En$7Ħ7ʯ<൦!x\oou~lQTlaboқ|La(L(pݳ2EFӑ-z]\ш`b;$B^4yV}["l{ e+Oã1 *-{#$@@Szj.l 6a䬮TΔa}ܫ)rQ i"eͿ?Ckĭ4z\*ʡۻgo`pSEo>gz>iJbӄzJ|1.ڛGS:qdT.D64b 6lκpy $Ey&ZI,OMUXjL6rw&ܖͻY{tL..]IyJ +sN/ߗs) K.|"T= Kz3H=7t}wjjC,"[_)ZzD%E_/bL!8Ӂ)R&x-wޏ/0rރn ʜT$2fRUWY.{j0y *674[*%gP[qlo.y &}XIFqcҡ53u tFZYE?W{>,Ɇ&q h!7!6Mh1/ԋE%&*z?M&yI]^ TUoeAP6g.$HlΉEy:i NF6{jwb[B?+fA4D{7bk}RLlN?TEgkaad \` Fr+b"ٶ!k=UŦ euɶ/@6UqM8`} ?Mcp̟@Qr3:-f:^$gvcVL.5`,;q(%Dr)g `yٔPZ fTY.3mqYH\[c)7-w'8W&?,Me"{7c Uqb*7(BT_|fUo)d"SVJ.0q!c~^6h D62t!Z4L $z3HE&Tp +Gmd aҲrJVʂ>l̘ n/Jj{Sư5B҇d[$g$;|gp\-AW-<>nT="8 ydt|C}aLÀkA܄3Q1.r?)xұ[V +h3 d t"=T͖ '[wFeK!) R6V +49{Yx} -m?zΛPQ;Fvw(97uUK6S7M^uJ.*cGׄ .$SF\ˌ_kD0;$c .gPBTs1h3NrMACD2<'jp!eOd(AA7cM(/Va*g_i)Wc֜c(k'ە(KԮzy$ 򏭢3C@$0?!vi! +%QSE@EXݒ?lVC]A Eإ +*hE`/ymiiݖ7ܙs?sWO.X}[2t6BmE`6NBnn l@) '?X>Y e ^#S?YB\ܑnƒskl_m^FPB-/+?faP!E2 .dup}R-Ԩg + Y1T.k'Ql o܅φoKll}aW%rɳ&$Rxؾb11ԁ'lO\)d9ҭ)>Mp]7Z‚G':u΀(q) +u$dlM +'wk S-| O;y] +1ԍ]7T5ھGOݸ$kTF`OV|PčM]tMcY }v,n \fcj{.)ٚUŠrLV$B@u*B7F6y2|rr;+\[ιrptrCx!r](P +g=c(1 fB8P +G]d i9++m'AUdQn3%ilrO8Ӫo+9ETOiSWhrFdw3:{ϣlW .6lY{ex!8t_xW>mΈȀ5{J=WFsLhPv$}_RMפ} +˴{Bzr5x.UI&${C[#Eqx(կa9EP\%wEOwS8q'^ӘD٢#AJSTY+v0ZGM0٪]lQm>Pvy$+^D & H}Bp8o/wo$_u.7Zհ 7D-z VwԼuYa0N@Ye囍 'cmt-ƗYkC#01*SuS,٩p܅[C_qbhjF Y.&L0W7O.(Uf?UʍlE0%ݹ@"qy*`@vyIy%YqpF$Xu{9"yFmNp*{BeQ-f^}szs>^D lZu4']G67TN@]6dA3$6(OY99Q#a9q 9\=Mx$U /> o$Co0:')8\٣!=zЎˋ5~Q6#]1rZ1O/h_ ~]e7yasrvlRB$@Ifs3FJ1!]Cmhykr-!إ?ns෣Ξr ONۯ0BBʆt/6ds;t>u>-.3oJM:h$c۶2kEȫ`KE9 +~&enc*wnjIcw5kΗ@,'k;}Y.Z.\\)+;=V~M+\`I)^*-O0 ! AB\u߃7%˵ .}w[<Ċsdr#Go?"Z-6K1 +$d/:0\}]7> +vTUC:ˉA€e>Ś>stream +HyTSwoɞc [5laQIBHADED2mtFOE.c}08׎8GNg9w߽'0 ֠Jb  + 2y.-;!KZ ^i"L0- @8(r;q7Ly&Qq4j|9 +V)gB0iW8#8wթ8_٥ʨQQj@&A)/g>'Kt;\ ӥ$պFZUn(4T%)뫔0C&Zi8bxEB;Pӓ̹A om?W= +x-[0}y)7ta>jT7@tܛ`q2ʀ&6ZLĄ?_yxg)˔zçLU*uSkSeO4?׸c. R ߁-25 S>ӣVd`rn~Y&+`;A4 A9=-tl`;~p Gp| [`L`< "A YA+Cb(R,*T2B- +ꇆnQt}MA0alSx k&^>0|>_',G!"F$H:R!zFQd?r 9\A&G rQ hE]a4zBgE#H *B=0HIpp0MxJ$D1D, VĭKĻYdE"EI2EBGt4MzNr!YK ?%_&#(0J:EAiQ(()ӔWT6U@P+!~mD eԴ!hӦh/']B/ҏӿ?a0nhF!X8܌kc&5S6lIa2cKMA!E#ƒdV(kel }}Cq9 +N')].uJr + wG xR^[oƜchg`>b$*~ :Eb~,m,-ݖ,Y¬*6X[ݱF=3뭷Y~dó ti zf6~`{v.Ng#{}}jc1X6fm;'_9 r:8q:˜O:ϸ8uJqnv=MmR 4 +n3ܣkGݯz=[==<=GTB(/S,]6*-W:#7*e^YDY}UjAyT`#D="b{ų+ʯ:!kJ4Gmt}uC%K7YVfFY .=b?SƕƩȺy چ k5%4m7lqlioZlG+Zz͹mzy]?uuw|"űNwW&e֥ﺱ*|j5kyݭǯg^ykEklD_p߶7Dmo꿻1ml{Mś nLl<9O[$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! +zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km endstream endobj 5 0 obj <> endobj 20 0 obj [/View/Design] endobj 21 0 obj <>>> endobj 12 0 obj <> endobj 10 0 obj <> endobj 22 0 obj <> endobj 23 0 obj <>stream +%!PS-Adobe-3.0 %%Creator: Adobe Illustrator(R) 17.0 %%AI8_CreatorVersion: 19.2.1 %%For: (Zachary Mitton) () %%Title: (metamask_icon) %%CreationDate: 6/15/16 2:23 PM %%Canvassize: 16383 %%BoundingBox: 98 -140 188 -44 %%HiResBoundingBox: 98.7919746568114 -140 188 -44 %%DocumentProcessColors: Cyan Magenta Yellow Black %AI5_FileFormat 13.0 %AI12_BuildNumber: 147 %AI3_ColorUsage: Color %AI7_ImageSettings: 0 %%RGBProcessColor: 0 0 0 ([Registration]) %AI3_Cropmarks: 79 -156 207 -28 %AI3_TemplateBox: 180.5 -120.5 180.5 -120.5 %AI3_TileBox: -163 -488 449 304 %AI3_DocumentPreview: None %AI5_ArtSize: 14400 14400 %AI5_RulerUnits: 6 %AI9_ColorModel: 1 %AI5_ArtFlags: 0 0 0 1 0 0 1 0 0 %AI5_TargetResolution: 800 %AI5_NumLayers: 1 %AI17_Begin_Content_if_version_gt:17 1 %AI9_OpenToView: -39.6666666666679 23.666666666667 3 1419 866 18 0 0 -5 38 0 0 0 1 1 0 1 1 0 1 %AI17_Alternate_Content %AI9_OpenToView: -39.6666666666679 23.666666666667 3 1419 866 18 0 0 -5 38 0 0 0 1 1 0 1 1 0 1 %AI17_End_Versioned_Content %AI5_OpenViewLayers: 7 %%PageOrigin:-220 -420 %AI7_GridSettings: 72 8 72 8 1 0 0.800000011920929 0.800000011920929 0.800000011920929 0.899999976158142 0.899999976158142 0.899999976158142 %AI9_Flatten: 1 %AI12_CMSettings: 00.MS %%EndComments endstream endobj 24 0 obj <>stream +%%BoundingBox: 98 -140 188 -44 %%HiResBoundingBox: 98.7919746568114 -140 188 -44 %AI7_Thumbnail: 120 128 8 %%BeginData: 22554 Hex Bytes %0000330000660000990000CC0033000033330033660033990033CC0033FF %0066000066330066660066990066CC0066FF009900009933009966009999 %0099CC0099FF00CC0000CC3300CC6600CC9900CCCC00CCFF00FF3300FF66 %00FF9900FFCC3300003300333300663300993300CC3300FF333300333333 %3333663333993333CC3333FF3366003366333366663366993366CC3366FF %3399003399333399663399993399CC3399FF33CC0033CC3333CC6633CC99 %33CCCC33CCFF33FF0033FF3333FF6633FF9933FFCC33FFFF660000660033 %6600666600996600CC6600FF6633006633336633666633996633CC6633FF %6666006666336666666666996666CC6666FF669900669933669966669999 %6699CC6699FF66CC0066CC3366CC6666CC9966CCCC66CCFF66FF0066FF33 %66FF6666FF9966FFCC66FFFF9900009900339900669900999900CC9900FF %9933009933339933669933999933CC9933FF996600996633996666996699 %9966CC9966FF9999009999339999669999999999CC9999FF99CC0099CC33 %99CC6699CC9999CCCC99CCFF99FF0099FF3399FF6699FF9999FFCC99FFFF %CC0000CC0033CC0066CC0099CC00CCCC00FFCC3300CC3333CC3366CC3399 %CC33CCCC33FFCC6600CC6633CC6666CC6699CC66CCCC66FFCC9900CC9933 %CC9966CC9999CC99CCCC99FFCCCC00CCCC33CCCC66CCCC99CCCCCCCCCCFF %CCFF00CCFF33CCFF66CCFF99CCFFCCCCFFFFFF0033FF0066FF0099FF00CC %FF3300FF3333FF3366FF3399FF33CCFF33FFFF6600FF6633FF6666FF6699 %FF66CCFF66FFFF9900FF9933FF9966FF9999FF99CCFF99FFFFCC00FFCC33 %FFCC66FFCC99FFCCCCFFCCFFFFFF33FFFF66FFFF99FFFFCC110000001100 %000011111111220000002200000022222222440000004400000044444444 %550000005500000055555555770000007700000077777777880000008800 %000088888888AA000000AA000000AAAAAAAABB000000BB000000BBBBBBBB %DD000000DD000000DDDDDDDDEE000000EE000000EEEEEEEE0000000000FF %00FF0000FFFFFF0000FF00FFFFFF00FFFFFF %524C45FD24FFA776FD75FFA04A4AA1FD73FFA04A754A75A8FD71FF7C4475 %4A6F4A6FA8FD6FFFA04A754B754B754A75FD6EFF764A6F4A754A6F4A754A %76FD6CFF764A754B754A754B754A754AA1FD69FFA8754A6F4A754A6F4A75 %4A6F4A6F4AA1FD44FFA7C9A075A8FD1EFFA8754A754B754B754B754B754B %754B754ACAFD3FFFCFC9C299C1997476FD1EFFA76F4A754A6F4A754A6F4A %754A6F4A754A4B4AFD3BFFA7C99FC198BB98C198754AA8FD1DFFA8754A75 %4A754B754A754B754A754B754A754B6F76FD37FFC9C99FC198C199C199C1 %99754A75FD1DFFA74B4A754A6F4A754A6F4A754A6F4A754A6F4A754A4A76 %FD31FFA8C9A0C1999998C1999F99C199C1746F4A4A76FD1CFFA1754A754B %754B754B754B754B754B754B754B754B754B6F7CFD2CFFCAC9C89FC198C1 %99C199C199C199C1C1C175754B754ACAFD1BFF7D4A4A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A6FA8FD27FFCAC9A1C2989998C199C199 %C199C199C199C199C16E4B4A754A75A8FD1AFF7C6F4A754B754A754B754A %754B754A754B754A754B754A754B754A75FD24FFC9C99FC199C199C199C1 %99C199C199C199C199C1C1994A754B754A6F76FD1AFF764A4A6F4A754A6F %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A76A8FD1DFFA7C9A0C1 %99BB989998C1999F99C1999F99C1999F99C199C199994A4B4A754A6F4AA8 %FD19FF756F4B754B754B754B754B754B754B754B754B754B754B754B754B %754B754A76FD1AFFCAC299C198C199C199C199C199C199C199C199C199C1 %99C199C199994B754B754B754A7CFD19FF764A4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A99FD04C199C1C1C199C1 %C1C199C1C1C199C1C1C199C1C1C199C198C199C199C199C199C199C199C1 %99C199C199C199C199C199754A754A6F4A754A4A7DFD18FF7C6E4B754A75 %4B754A754B754A754B754A754B754A754B754A754B754A754B754A754BFD %05C1BBC1C1C1BBC1C1C1BBC1C1C1BBC1C1C1BBC1C1C199C199C199C199C1 %99C199C199C199C199C199C199C199C199754B754A754B754A754BFD19FF %754A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A4B74C199C199C199C199C199C199C199C199C199C199C199C199 %9F99C1999F99C1999F99C1999F99C1999F99C1999F99C1994B4A754A6F4A %754A6F4A76FD18FFA14A754B754B754B754B754B754B754B754B754B754B %754B754B754B754B754B754B754B7599C2FD16C199C199C199C199C199C1 %99C199C199C199C199C199C175754B754B754B754B754B75A1FD18FF4A4B %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A75 %4A6F4A754A6F99C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C199C1 %99C199C199C199C199C199C199C199C199C199C16E4B4A6F4A754A6F4A75 %4A6F4AFD18FFA16F4B754A754B754A754B754A754B754A754B754A754B75 %4A754B754A754B754A754B754A754B75FD16C199C199C199C199C199C199 %C199C199C199C1999F6F754A754B754A754B754A754A7CFD18FF764A754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A754A9999C199C199C199C199C199C199C199C199C199C199C199 %9F99C1999F99C1999F99C1999F99C199994A6F4A6F4A754A6F4A754A6F4A %4A7DFD17FFCA4A754B754B754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B754B754B7575FD17C199C199C199C199C199C1 %99C199C1C1994B754B754B754B754B754B754B754BFD18FF764A4A754A6F %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A75 %4A6F4A754A4B74C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C199C1 %99C199C199C199C199C199C199754A6F4A754A6F4A754A6F4A754A6F4A7C %FD18FF754B754A754B754A754B754A754B754A754B754A754B754A754B75 %4A754B754A754B754A754B754A754B7599FD13C1BBC199C199C199C199C1 %99C199C199754A754B754A754B754A754B754A754B75A8FD17FFA04A754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A754A6F4A754A7599C199C199C199C199C199C199C199C199C199 %C199C1999F99C1999F99C199C174754A6F4A754A6F4A754A6F4A754A6F4A %6F75FD18FF4A754B754B754B754B754B754B754B754B754B754B754B754B %754B754B754B754B754B754B754B754B754B754A9FFD14C199C199C199C1 %99C199C175754B754B754B754B754B754B754B754B754AA7FD17FF7D4A4A %754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A4B4AC1C1C199C1BBC199C1BBC199C1BBC199 %C1BBC199C199C199C199C199C16F4B4A754A6F4A754A6F4A754A6F4A754A %6F4A75A8FD17FF764A754A754B754A754B754A754B754A754B754A754B75 %4A754B754A754B754A754B754A754B754A754B754A754B7575FD13C199C1 %99C199C1BBC16F754B754A754B754A754B754A754B754A754B6F75FD17FF %A84A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A754A6F4A754A6F4A754A6F4A754A4B74C199C199C199C199C199 %C199C199C199C199C199C199C199994A4B4A754A6F4A754A6F4A754A6F4A %754A6F4A754AA1FD17FF76754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B754B754B754B754B754B754B754B754B754B75 %9FFD11C199C199C199994B754B754B754B754B754B754B754B754B754B75 %4B75A8FD16FFA86F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A75 %4A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A99C1C1 %99C1BBC199C1BBC199C1BBC199C1BBC199C199994A754A6F4A754A6F4A75 %4A6F4A754A6F4A754A6F4A6F75FD17FFA74A754A754B754A754B754A754B %754A754B754A754B754A754B754A754B754A754B754A754B754A754B754A %754B754A754B754AFD13C199754B754A754B754A754B754A754B754A754B %754A754B754ACAFD16FFCA4A6F4A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A4B4AC1BBC199C199C199C199C199C199C199C1996F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A754A75FD17FF7D6F4B754B754B754B75 %4B754B754B754B754B754B754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B754B7599FD10C19F4A754B754B754B754B754B %754B754B754B754B754B754B6F7CFD17FF764A754A6F4A754A6F4A754A6F %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A75 %4A6F4A754A6F4A754A7599C1BBC199C1BBC199C1BBC199C1BBC199C1C199 %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754AA8FD17FF75754A %754B754A754B754A754B754A754B754A754B754A754B754A754B754A754B %754A754B754A754B754A754B754A754B754A7599C199FD12C1994A754B75 %4A754B754A754B754A754B754A754B754A75FD17FFA8754A6F4A754A6F4A %754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A7599C1999999C199C199C199C199C199C199 %C199C199C199994A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A7CFD %17FF75754B754B754B754B754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B754B754B754B754B754B7599C199C199FD13C1 %99994B754B754B754B754B754B754B754B754B754B754A7CFD15FFA8754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A754A6F4A754A6F4A754A6F4A7599C199C199C199C1BBC199C1BB %C199C1BBC199C1BBC199C199C199994A6F4A754A6F4A754A6F4A754A6F4A %754A6F4A754A76A8FD13FFA84A754B754A754B754A754B754A754B754A75 %4B754A754B754A754B754A754B754A754B754A754B754A754B754A754B75 %99C199C199C199C199FD0FC1BBC199C199994B754A754B754A754B754A75 %4B754A754B754A754AFD14FFA14A4A754A6F4A754A6F4A754A6F4A754A6F %4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A75 %75C199C1999F99C199C199C199C199C199C199C199C199C199C199C199C1 %99754A6F4A754A6F4A754A6F4A754A6F4A754A4B4AA8FD14FF7C4A754B75 %4B754B754B754B754B754B754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B7599C199C199C199C199C199FD11C199C199C1 %C1754A754B754B754B754B754B754B754B7576FD12FFA8A151754A6F4A75 %4A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F %4A754A6F4A754A6F4A754A4B74C199C199C199C199C199C199C1BBC199C1 %BBC199C1BBC199C1BBC199C199C199C199754A754A6F4A754A6F4A754A6F %4A754A757DFD11FFA14A4A4A754B754A754B754A754B754A754B754A754B %754A754B754A754B754A754B754A754B754A754B754A754B754A7575C199 %C199C199C199C199C199C1BBFD0FC199C199C199C199754A754B754A754B %754A754B754A754A4A75CFFD10FFA8754A4A754A6F4A754A6F4A754A6F4A %754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %4B6EC1999F99C1999F99C1999F99C199C199C199C199C199C199C199C199 %C199C199C1999F99C199754A754A6F4A754A6F4A754A6F4A754A4A4ACAFD %11FFA8754A754B754B754B754B754B754B754B754B754B754B754B754B75 %4B754B754B754B754B754B754B754B7575C199C199C199C199C199C199C1 %99C199FD11C199C199C199C199754B754B754B754B754B754B754B754ACA %FD13FFA87C4A4B4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A756EC199C199C199C199C199C199C199 %C199C199C1BBC199C1BBC199C1BBC199C1BBC199C199C199C199C199754A %6F4A754A6F4A754A6F4A754AA7FD17FF75754A754B754A754B754A754B75 %4A754B754A754B754A754B754A754B754A754B754A754B756FC199C199C1 %99C199C199C199C199C199C199FD11C199C199C199C199C199754B754A75 %4B754A754B754A76FD13FFA8CA7DA176754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A4B6EC199C1999F99 %C1999F99C1999F99C1999F99C199C199C199C199C199C199C199C199C199 %9F99C1999F99C199C198754A6F4A754A6F4A754A4B4AFD12FFA87C4A4A4A %754B754B754B754B754B754B754B754B754B754B754B754B754B754B754B %754B754B754B7575C199C199C199C199C199C199C199C199C199C199FD11 %C199C199C199C199C199C199754B754B754B754B754A75FD14FFA8754A4A %754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A4B4A9F99C199C199C199C199C199C199C199C199C199C199C199 %C1BBC199C1BBC199C1BBC199C1BBC199C199C199C199C199C1994B4A754A %6F4A754A6F4AFD16FFA8A14B754B754A754B754A754B754A754B754A754B %754A754B754A754B754A754B754A7575C199C199C199C199C199C199C199 %C199C199C199C199C199FD11C199C199C199C199C199C199754A754B754A %754B6FA7FD18FF516F4A6F4A754A6F4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A4B4AC1999F99C1999F99C1999F99C1999F99C1999F99 %C1999F99C199C199C199C199C199C199C199C199C1999F99C1999F99C199 %9F99C1754B4A754A6F4A6F4AA8FD17FFA1754B754B754B754B754B754B75 %4B754B754B754B754B754B754B754B754B754BC1C1C199C199C199C199C1 %99C199C199C199C199C199C199C199FD11C199C199C199C199C199C199C1 %75754B754B754AA7FD15FFA8A14B4A4A754A6F4A754A6F4A754A6F4A754A %6F4A754A6F4A754A6F4A754A6F4A756E9999C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C1BBC199C1BBC199C1BBC199C199 %C199C199C199C199C199C199C174754A6F4AA1FD17FF4B6F4B754A754B75 %4A754B754A754B754A754B754A754B754A754B754A754B754AC1C1C199C1 %99C199C199C199C199C199C199C199C199C199C199C199FD11C199C199C1 %99C199C199C199C199C175754A76FD18FFCA4B4B4A6F4A754A6F4A754A6F %4A754A6F4A754A6F4A754A6F4A754A6F4A6F4A9999C1999F99C1999F99C1 %999F99C1999F99C1999F99C1999F99C1999F99C199C199C199C199C199C1 %99C199C199C1999F99C1999F99C1999F99C199C16E4BA8FD1AFF756F4B75 %4B754B754B754B754B754B754B754B754B754B754B754B756F9F99C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199FD0FC1 %99C199C199C199C199C199C199C199C1A1FD1CFF4B4B4A754A6F4A754A6F %4A754A6F4A754A6F4A754A6F4A754A4B4A9F99C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C1BBC199C1BBC1 %99C1BBC199C199C199C199C199C199C199C199C198CAFD1CFFCF4A754A75 %4B754A754B754A754B754A754B754A754B754A754B9999C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199FD0FC199C1 %99C199C199C199C199C199C199C1CAFD1DFFA84A6F4A754A6F4A754A6F4A %754A754A754A754A754A6F4A99999F99C1999F99C1999F99C1999F99C199 %9F99C1999F99C1999F99C1999F99C1999F99C199C199C199C199C199C199 %C199C199C1999F99C1999F99C1999F99C199FD1FFFC299C1C1C19FFD0FC1 %99C1C1C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199FD11C199C199C199C199C199C199C199C2FD1EFFCABBC1 %99C1C1C199C1C1C199C1C1C199C1C1C199C1C1C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C1BBC199C1BBC199C1BBC199C199C199C199C199C199C199C1A0FD1EFF %FD18C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199FD0FC199C199C199C199C199C199C198C9FD1DFF %C9C199C199C199C199C199C199C199C199C199C199C199C199C199C1999F %99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1 %999F99C199C199C199C199C199C199C199C199C1999F99C1999F99C19999 %A1FD1DFFC9BBFD19C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199FD0FC199C199C199C199C199C199C198 %C9FD1DFFC1C199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C1BBC199C1BBC199C1BBC199C1BBC199C199C199C199C1 %99C199BBA7FD1CFFC9FD1BC199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199FD0FC199C199C199C199C1 %99C199CFFD1CFFC298C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C1999F99C1999F99C1999F99C1999F99C1999F99C1999F %99C1999F99C1999F99C1999F99C199C199C199C199C199C199C1999F99C1 %999F99C1999F98C1A8FD1CFFFD1EC199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199FD0FC199C199C199C199 %C199C199FD1CFFC9C199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199 %C1BBC199C1BBC199C199C199C199C199C199C199C199C199C199C199C199 %C199C1999999C1999999C1999999C1BBC199C1BBC199C1BBC199C1999999 %C19999989999999899A8FD1BFFC2FD1EC1BBC199C199C199C199C199C199 %C1999999C1999999C1999999C199BB99C1999999C1999999FD0DC1999999 %C1999999C1999998C9FD1AFFC998C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199999899999998999999989999 %99989999999899999998BB999998999999989999C199C199C199C199C199 %C199C199C199999899279998999999A0FD1AFFC2FD23C199C199C199C199 %C199C199C199C199C199C199C1999F515299C199C199C199C199FD0DC199 %9999C1992E4BC199C199C2A8FD18FFCAC199C1BBC199C1BBC199C1BBC199 %C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C199C199C19999989999 %99989999999899999998C175510528057598999999989999C199C1BBC199 %C1BBC199C1BBC199C19999989927286FBB99C198C9FD18FFC9BBFD25C199 %C199C199C1999999C1999999C1BB994B2E0628272E279999C1999999C199 %FD0DC1BBC199BB992E282E99C199C1A0FD18FF9FC199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C199C1999F99 %C1999998999999989999BB98752706052827280528279998FD0499C199C1 %99C199C199C199C199C199C1989998990528054B98C198A0A9FD16FFCAFD %29C199C199C199C199C1999F7552282E272E272E272E272875C199C199C1 %99FD0FC199C1752E062E51C1BBC199FD17FFC998C1BBC199C1BBC199C1BB %C199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199 %C199C199C199C199992706052805280528272805280528989999C199C199 %C199C1BBC199C1BBC199C1BBC199999951057699C199C1999FA8FD16FFFD %2AC199C199C199C199C199A07576272E2728052E2728272E277599C199C1 %99C199FD0DC199C1759FFD04C199C199CAFD15FFA7C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C1999F99C199C1BBC1C1C1999F7575272827280528057598C1 %999F99C199C199C199C199C199C199C199C198BBC1C199C1999F98BBA7FD %15FFC2FD2EC199C199C199FD0BC17576512E27C19FC199C199FD0FC199FD %05C199C199CFFD14FFCA98C1BBC199C1BBC199C1BBC199C1BBC199C1BBC1 %99C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1999F99C1 %999F99C1BBC199C1BBC199FD05C1999F99C199C199C199C199C1BBC199C1 %BBC199C1BBC1999999C199C1BBC198C1CAFD14FFC2FD31C199C199FD11C1 %99C199C199C199FD0DC199C199FD05C199FD14FFA8C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C1999F99C199C199C199C199C199C199C199C199C1 %99C199C1999F99C199C199C199C199C199C199C199C1999999C199C199C1 %CAFD13FFCFFD32C199C199FD15C199C199C199FD0FC1BBC1C1C199FD14FF %A0C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1 %BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C199C199C1BBC1 %99C1BBC199C1BBC199C1BBC199C1BBC199C199C199C1BBC199C1BBC199C1 %BBC199C1999999C199C1CAFD13FFC1BBFD33C199C199FD15C199C199C199 %FD0DC199C1C1C1C2FD13FFC998C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C1999F99C199C199C199C199C199C199C199C198C2FD13FFFD52C199C1 %99FD0DC199C1A1FD12FFA7C1BBC199C1BBC199C1BBC199C1BBC199C1BBC1 %99C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1 %BBC199C1BBC199C199C199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC1 %99C199C199C199C199C1BBC199C1BBC199C1BBC198C9FD12FFC2BBFD35C1 %99C199C199C199FD17C199C199FD0DC1C9FD12FF99C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199999899999998C1999999C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %98C2FD11FFC9FD31C199C199BB99C199BB99C199C199C199C199FD15C199 %C199FD0BC1BAC9FD10FFC2BBC199C1BBC199C1BBC199C1BBC199C1BBC199 %C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C1BBC199C199C1FD0499 %98999999989999C199C199C199C199C199C199C199C1BBC199C1BBC199C1 %BBC199C1BBC199C1999F99C1BBC199C1BBC199C1BBC198C9FD0EFFCFBBFD %2BC199C1999999C1999999C1999999C199C199C199C199C199C199C199C1 %99FD11C199C199FD0BC1BAC9FD0DFFA0C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C19999989999 %99989999999899999998FD0499C1999F99C1999F99C1999F99C1999F99C1 %99C199C199C199C199C199C199C199C1999F99C199C199C199C199C199C1 %98C9FD0CFFC299C19FC199C19FC199C19FC199C199C199C199C199C199C1 %99C199C199C199C199C199C199C1999999C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C19FFD0FC199FD %0CC1CFFD0BFFA79999C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C19999989999999899999998999999 %989999C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %BBC199C1BBC199C1BBC199C199C199C1BBC199C1BBC199C199CFFD0BFF99 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C1999999C1999999C1999999C1999999C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C19FC1BBFD09C199 %FD0CC1CFFD0AFFC2989F99C1999F99C1999F99C1999F99C1999F99C1999F %99C1999F99C1999F99C1999F99C199C1FD0499989999999899999998FD04 %99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1 %999F99C199C199C199C199C199C199C199C199C199C199C199CFFD09FFCA %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %FD07C199FD0CC1FD0AFF99C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199999899999998999999 %989999C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C1C1C199C1BBC199C1BBC199FD04C1 %FD09FFC999C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C1999999C1999999C1999999C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C1C1C199FD07C19975754B27A8FD07FFA8C1999F99 %C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C199 %9F99C1999F99C199999899999998FD0499C1999F99C1999F99C1999F99C1 %999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F %99C199C199C199C14A27F827F805F8F8F852A8FD06FF9FC199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C1BBC175270027F82727272027F82752FD05FFCA98C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C1999998999999989999C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C198BB98C198C199C199C199C2A0A0A0 %C9A127F827F827F827F827F827F8F87DFD05FFC299C199C199C199C199C1 %99C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C1999999C199C199C199C199C199C199C199C199C199C199C199C1 %99C199C199C199C199C299C199C2A0C3A0C9A1CAA7CAA7CAA8CAA8CAA8A8 %2727F8272727F8272727F8274BFD06FFA0BB999F99C1999F99C1999F99C1 %999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C19999 %98FD0499C1999F99C1999F99C1999F98C1999998C198BB98C1999F99C199 %A09FA1A1A7A1A8A1A8A1A8A8A8A7A8A7A8A1A8A7A8A1A8A7A8A127F827F8 %27F827F827F827F8A8FD06FFCF99C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C29FC199C2A0C9A0C9A0C9A7CAA7CAA7CAA8 %CAA8CAA8CAA8CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA8CA27272027272720 %272727F852FD08FFC299C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C1989998BB99C199C199 %C2A0A0A0C3A0A7A1A8A7A8A1FD07A8A7A8A7A8A1A8A7A8A1A8A7A8A1A8A7 %A8A1A8A7A8A1A8A7A8A1A8A7A8A127F827F827F827F827F827A8FD08FFA1 %C199C199C199C199C199C199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C199C198C2A1C9A0C9A1CAA7CAA7CAA8CAA8CAA8CAA7 %CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8 %CAA7CAA8CAA7CAA8A8FD0427F8272727F82752FD09FFCF98C1999F99C199 %9F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999F99C1999998 %BB98C1A0C9CAFFAFFFA8A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7 %A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1 %CAA127F827F827F827F827F8A8FD0AFFC299C199C199C199C199C199C199 %C199C199C199C199C199C199C199C199C199C199C199C2C9CFFD0AFFA8A8 %A7A8A7CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CA %A8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8A8FD0427F827F827F87DFD0BFF %A8C199C199C199C199C199C199C199C199C199C199C199C199C199C199C1 %989999C9A7CFFD10FFA8A87DA7A1A8A7A8A7CAA7A8A1A8A7A8A1A8A7A8A1 %A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1CAA127F82727 %5252767CA1A8FD0CFF9FC199C199C199C199C199C199C199C199C199C199 %C199C199C199C199C2C9CFFD16FFA8A8A1A8A7A8A7CAA8CAA7CAA8CAA7CA %A8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7A8527D %7DA8A7CAA7A8A8FD0DFFC998C1999F99C1999F99C1999F99C1999F99C199 %9F98BB989999C9A7FD1CFFCFA7A87DA17DA8A1A8A1A8A7A8A1A8A7A8A1A8 %A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A7A8A1A8A1A77DA8A1A77DA7A1A1 %A7FD0EFFCAC199C199C199C199C199C199C199C199C199C199C2A0C9CAFD %23FFA8CAA1A8A1A8A7A8A7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CAA7CAA8CA %A7CAA8CAA7CAA7A8A1A8A1A8A1A8A1A8A8FD10FFA0C199C199C199C199C1 %99C199C199BB98C199C9CAFD29FFA8A77DA7A1A77DA8A1A8A1A8A7A8A7CA %A7A8A1A8A7A8A1A8A7A8A1CAA7A87DA8A1A77DA8A1A77DA7A1FD11FFCA98 %C199C199C199C199C199C198C2A0C9CAFD2FFFA8A8A1A7A1A8A1A8A1A8A7 %A8A7CAA8CAA7CAA8CAA7CAA8CAA7A8A1A8A1A8A1A8A1A8A1A8A1FD12FFCA %C198C1999F99C1999998C2A0CAA8FD33FFA8FFA8A87DA77DA77DA77DA77D %A8A1A8A1A8A7A8A1A8A1A77DA7A1A77DA7A1A77DA7A1FD14FFA0C199C199 %C199C1A0FD3DFFA8A8A1A8A1A8A1A8A1A8A1A8A7A8A7A8A1A8A1A8A1A8A1 %A8A1A8A1A8A1FD15FFCA98BB99C2A0CFFD41FFCFA7A8A1A17DA8A1A77DA8 %A1A77DA8A1A77DA8A1A77DA77DA17DCAFD16FFC9A7FD49FFA8A8A1A8A1A7 %A1A8A1A8A1A8A7A8A1FD04A8FFA8FD66FFA8CAA8A8A8FFA8FFA8FFFFFFA8 %FD12FFFF %%EndData endstream endobj 25 0 obj <>stream +%AI12_CompressedDatax$&?d& C;\;fJ-n[[YUZ(xd&,f #+3q98OxOq< ?wo ~7_{ˏ~/&G4M~Vۯ߼LG{4?oqwo^_^ޡݻ篞g/PWnC} 4`e߱=&7Ô?L/ޣvu&3%Co^|O߾yq7/߼W?>y~^|0;qv~c7/o^a|t/_/tqzWw0R<3ٯOaC)?l/Jo|ۿi[Lݘج{K̬̂1??J[x?~W~NguG|˻FѤS7_ܽD/ H1oɦ >Kz3 3y}vgӭw2IM~?WyOtҺ2!Lj}.6(^{_G<Ѽb |aoSl߿DŽkѽ_bٚO1';=I~R4!o;H]cձW?y=5w7_j|ӷR}To?~_^bqQ>mŃߔ?뿏 Bӛ{U>}|CsL!޽zn +!}Ho_wg߾܎Ͽzz_~˧ߩO n_|=w.̙/|ܿ8~_xNuTOX[˷Zߥfi>$_>ksP3|q-y=?F?!]϶j~xx7/~tS/>\?߿cwwI|+r;鳶|0e> loq\߼3L/pba,H=;0?)vU\) ߀%%Ӧ\ \܌x[f`*nU-LDIo^iSi.繜5Jz7ѵ][*FAiUU*'-VmӯVuY[a^^Zd]fU͛V+ebe7g]k;la]/WkdYԬU)۵Z)*և:YeXtMe@CY#չk)7ܲԓŗYUeLIɭ̍zʵؔF2 ssλɝP-Vx>'O[L .C +S +p7v v)esUsSʧ|o-&7 LNyni̕W*^rdNONtemwp|:[l6#ut}>_\ތXwoM7 usnnnn#n1aoz^m7r*U9զL _^*qSªUq 8R$l!z7M9kӪ\ʴ*ySҪU M*vU̪KS>_֣_WENf]Z%. bXv 2ʌd)v64o򬡙R&)$%JR\)vWL%Ϫ?')WLRr)8K R|)%Ѓֵ;zeY eeگed&G/fdndbN2yw|Q^Z^Jd^Fq``2Ϡ[W_t,yP5 j>H73_J F1aoטt@H tr@x#HuN D;x;p{{@}w & +D5CpqnX. K׌ucq7g\DW);2UnC|Ey x;Rٙ-خv8Pz? gx'H˗v؅0ܮH *`Cld!2r.y 9&*w"6`ټ.b/+>P,"eXalX~PdS }bٛ2<duXE3Ϩr;.E9J\d('}(bs=U-l4W=9"}ZӬYAL6%Ts끼VJ{OX 2=ye[3UCwD翇d?Sԇos<;XԵ?ʏOBF7mLE߰s8҆+ H$" (" tAy\( !DʢJBFǭH|! ,DiȪ4$uN"e(rE"R,RQш‘Q ,e$JI OeSB%'ЈjFĥkK(2Qhؔ|J5t[듖|97nI?FյX4̲P,~)uuxIx" ?4 Qs E6< KCvD1l4맕aýE|r.VOoGEq3- -U +ͪLTTJэEUZ*mXM]JY\9UDi%%2r5=Ҵъ %s(It8i4fCT +a);12y?Ӌ+[ @c&*PV5m\86 ŸV+-7bU[#w)Zf{% 0<@jXp1frb=]9It=G9 [>EXy+3KoJO+ï~QQ0:1L<98Ilj> -Ѿ8Jl+u!3)]Hh% \hB#ڸLo{[Z&qk"fÊmIWCv8x}i؎u'^{߇qmCIJϞ=c@09Bk۱iccwt6sM&;XݸCI1TQoZ@,qx)G7?}HH|5FPH!H58RZ$n҇U}|OV#pDnyu:q/#7I0c (0 ++tǵl⟿Z +R>qV#6Cxji7~zQfd @,zv4./_bS;;c4`&# 4؜6%0ySIRм m{=jP]||s|<:@> lm/zr._S  +_rUXBa3|!<4S<0< Sy+De&W@AAr-^uUjKTˈXōuXᒗe?#uFnfVŜzQ27sPf'z3 mdq<9+r>3_;ug{YʪHNEa십]ԕd1U w]<[ )8c(bb<;]=),IȥId,v+POD QuVoʬ*rk$V_ba_U[X.}7IʲC#rOL,lEkY, En%ʦ"ƞD1V] ֯$XJ:vl`{6VY=+2ҡYAnVط6{;,Y ugeV^am|O;>ͩ3/Յ8/+w J.zꓨW|٘X \bU鵧_o(r = wxw<}e|m>rz|/GTy/Ҡ `+0{ط>WG|/\,O_{ُF-I}34Yݵuw}\&vřTi: }S͍2.",W(^QFl~34mٷ!,ԅl#AiEqڐ9,%#s֡%bn#'g=<r9?3:Iq?:?'3{T|ʞ:/yE X0=QnEk Zi:EBm9Ɍ \:H͕}g02x˩yj4>/=?S=w טiąYpo8&joEI'Oo>sQcb J"cTՎb&)xEUܔ&`dgFzv%ś9rJAKqj6Myt a\~ا~+7^ݽJhgyus]j/iR:SnBL%4#Kq _ KX*8^Kz\e>l/ư7TVrǩ0 7U/ޅA[lH8$&qOTqʅZ%.B5!% KJ)@(|GY:>LBaK\NKyUoItfm6ŭݐ\¦?)NUWe6>%BE6Q%J>q唚mWCyZy"obݮuc*qj+}ZX9>p,JͫoD Dޤ$;;mXGƕl_f#2-dpeQSEN[cnm4;h\; Vymff g,Ju}o14Q$:i\-.ns8ič+9m6VkϚ|['hZzvvAuaG`}t`}YhG_:m8GN84hu*, _ CkA|,|aGWuw#my{"Vފݹ(|مavWJů9jZ~,wr Ez_dxZ_KY˻JR EV 襠qwU)y@R޸0fwnxQ4;9LAǦ6 +wz·2_}q|t0>\v,нe| +(Cq7o]ͷ`['sثj[d˧1rQNت8 ETԑ<}>S|efk Hʾ_>Ctu;,0D9,'%CS9 .N[ZcqaO΃q5Ovi7bE@Om>nzw)6>FaCmq$8I?I7 ,BԽMٻ +M^A*V*#9Փi]nLʼnigLìQ&[,_?5@'Q +oDT7 F\'uY6@  ,[eh>O*r.V+÷h#exZ:i0$3QN +ߑ6V<ϒ^XEH92kV'jX\+KdP8SGYр3ɡeNqV1 e'%:U9J1џP:vlu{L[5*F6Ԯ/+B ƪ-; eфaǓJږ߶<' Oo_KM ]"\EkF0EDϤE Ȕθϔog|VUu^v)H! {'xT:UjCITҒآ(ZJ(Z4KY薮lZJa\"6Bi(D9P{i{::6KOyíO0i5*alX!X%RK努Q>E(c4,Zۙ;^o;r%( />1]3HJW.=Cq Q; JliJB%۵C^ײҫjL[ExDZ䤵 nI˴~ԻzMj,v8'2<9> Oo_êD Oس&F$(0SNeb + +0jhMMop-~v*fPj0<м4A͗ƪ]\ /0)zdp[_bݫjZL]kmrkX6ָ՚.XƬuɨ1i=d.LYO^IS)exZ 2< NO' +O' +xm7?a>Ykpi>d8$\09 f‡B'zgFxqO/e⎭cT1;ɸC0tmojj{ (qp͂C@z Nim)x?NvU!qnܺ//rvEi]ŧMi|T3ٷO'ؤ\L+u6u&٦|t,JtѲK]j=?Q`%֜k,pHyTak5u1'@IQAl P8MJ&7nJiQ<YOdF0DG3yvhCx/ew9ˣ/h-UPhnu&rSwOfc[x^$؝lxqq}csnٖIİX#!uDmw2<@7[I%~d<>WMeuv]a v2K%ѳ.ڟsq\\40Ž[Ѭ 7A 7_,~bN|v#n`^E.'[dՊ>R: ^G=,>($&K}id5VZڨpk ,ٴ 0 JJTgb60rOd`WIj>Q)3G^<-g@GpAYj,D9&# n-ƄA2 m2v'}2(W]c~TQ9oXVͨt?{<% rv 3nl=ثcvL !crU8+}Nߓ%@q+%ǭ$"~(2^ +Ma\Qݙ>Y+|Z[1z[gz[1Ԙ۴mJUr5Y|Vnodw`xNRKisl\7P΍||TGYugnKE$%V`t +6>+j::T\Phel銻PnC%oS5 +YSh +fWX1V *:I2SOBI44!eVk?xܓ'cOLj4-oKYuUh% JLfd-ytu<+qeYmˇ_CUVN`7(<ˌpaN ƍ]崂v + 6<žr[D\,-9n^$ D8aw2\0[ԡz*--ZLTFh7@K`nQ@밆#^MnRD_yrwQvpѹჲpb?McCa7Mt;HsM8)4y%qi$!wb-jqo1Pm+?:W]:HC'tJ!v\Y"fzw)n.(RD +K gѢ_ \߹D!˔] bjQ"#ΐSm2a+|;rudȼ]A>Q?ulR0Ԝn`uEss9 +Q37fQ;NLthp) n)n6WZnE*:]yu}; ӕdqYJZ,=*SZ< JӐH~[͎csߥ ÅR$Azae+̬䜽)Ò)SA$ZܬKV׬q:k)=As<2mS/LtMo@] ?}S>wihx9{JgU|>i?)D=:Kb%5ީ xyN$ȫik. ~s>4P}h/=vY@M~ ƽ#j&btan"k9hj/$s.!OE8]O$opLs*~$neqb:<7BB.oN4;rN/+"V}ZC^2TX5wb!xS`*ffs9 : i.!JUfQ?H*F!uV[6Nա$ͲWa⇰0IRnJ:'hp!bBY +`E;p8O +n2 ;aN(FXg `ᡭXbmZbw k7ax-(ÅS[/|um*][Wm!n;2._=11i8cT]#w-ՇI~ݔ÷Q~^/CQJ Rz$-Hi[Ȥ"k?hR{W5qn UVi+~ + +whpC=C~ӷݿOVrbXݽ} ?9DaSt~;X43a{GOl6O2+o:O?1'?O}t+T>:oZv{{~ywo^?ïD{ӛ7/1y)wo>;=WL?ܿ{݋w8w|ȯZ>@ȒgEYkpZtSacBM~˵)\Y$gq81A`EtY5$fL!Lzv#`!1<5ق6$CkG9`g9A&0=޲;z|ŏM?!0}<&|;t> C0/6R[¾3>8bx 7鈹3]Gg #.6ÄJ*1*ɁDݡ ؚ#{6+#Xu<*ln[T8lǀ`!k_&.GN΄bia&P,. G_;3GxbcY16TCG)D[^6Wc,d:ɓGd1IN'LH0%@;K'Y(G(MO#6%] @PbsO' d$S߆d-J4Rwg4udo+qo5!|~lb>Y Vg= !9P`W^éȝGV` jTZYBؓuZuvd1elYSg#n +}[Ϲ0qufۿdf7_/ ʃs7_ٛ? ojõL{آ!TfEbѝ(xL(2f㴸˸$n +,L"C"zJЄ \7T[ʤd + 6vBoeW]!DW1oHwm%H2kdRq'CՎXZ[i;Fx#B޵] yoeNl3_cD9D/*m% +dބSy]- u•HJbcx[ w?* rYrBʟ:3̑nsS.eUdSik3G>fT9i\h?qsiC;+x#@E:PlXJŽKun|ƛy$ 8C(A]Z0Oׄm x{\F0TOEȓHfwaaJ@Cr`%@|R%RU#>Lo;yp"MfP"0=Xpn |9APr- +23A(LOř\'"Dӂ3 +|=g>/ݡR҉Ѩ#3'7=.{&a1[f^qɷb!qVxT,@m gS+ + ~ +gZh+6,QYޚYռ9>sǹ %ґ?l mm]㽃)Lp轑ChM + SI8\Յ<%44.i+഻2>=ρo?Rݵ41?U58?!Yި&2qňLeLf9m#p\ Kdve~e K¶#}0UOe$|xA*4>:Q[# + LTU$ ֎&&4yr($bx(5M0Ɉprwݗ#-F6<_fn.(`wy|nME&ڑFȄ/;b)q&L{30D>fL4Z$.H=%7}+.Xl Vnp4s. .N:іDkP'_C:QӍŪNT)/#*tNN."PtHݼBsEn>nlG؊ TV7SBH`dp,d kEڴqƑ-@#v∣ؔfAR !D^Kh׊309Pd.WjZQJ`t-vߩkNM7nv[y=Anu =U^d*NIq<4Q) +4֣VԻs9)߲zNWQFm;-:ϱ?3RONYϹ4wJ?Y1F7lֵ, F8J\oY}68j @)7TەTEਟ +ic c&N-pdd?ѭLc̍w0SkY~x;(&68`d]@i U}q@3ŭOʨ4|nނ, xʀ1MO#iڸ&H-nqdq]$v0qTɣR;{#OR?WjJ'$q+M[1MFU7$#C tm!NLa\h{:ldneMq @G׾QKr>2k;AMx_}puB^C?1*!jT-tC"GӰ׏-8`Ǹ;EN/ik0C?* RFnvn~Uh:}|KCpބTmOM4{ޭ8Ix!@cnY`LXV@--4%"Epj|E$GΈdɄx%hkQQomh=mCQoOwN $. +4"Fj0Z̝eHӐKaDcJj{ eY[El]lB8y@A;^|Dڋ(@\▃@:usFtΐ"hνIB/>RzH#wm=Y sΈr ̎\DK墿8 W&:nХb%uV7K$3)ގI^c_SroT#xCAa#4[So+8ո{|*&D +l0;ut0ۙ\L2(D/qpoTWF\ n6!XH/@]/"#RBեx9D +1 fEh5X1FHXPIX X|5^ɓIr=t]F3}7Q0Yuoe%D>9tɆ/Ge#* BBu Vѫ!-W'0rǺ~,!^iTvtItu:+! H{D>GYƕn\/ iǩ'+z&;vʈ!5p O| ߩw{$${b[BPO;y,Ͼ YKfa5;-gLP>]yl?w"CuQ*v>ͫ֋БGqE{'{: +豛ɗWi+vwf7V'˒Qv]j.gT쒑hL~^eY݄6:oCت(^@Úd7^_y“-]- T?Q{jԿYgOcV/ɂ3xo]:y_~lukjȣ^}V%/VQ92RඈPūV Xԓ;Nev=ϻJbOӪwCi֠cû3P.v^z:p}:5I /P'U`fxX;Eu} e?HS߼N"7m&E&<0A4۴-fRny|WF$C2KaR`/v&ӋKD?:\ + DLsL^:~"r|ws5mn%n!#\ +얍y09ġxJxI&0!Sl <ཽAz#௑(k$2JS` L%NO;/< &*0yf0 +XOV:GKoe'o/^wDFFWfn +8ݱ ɉ)Z\ɹxf#~2`gWuSq!nH "74w`>`ő<`z*Po1գguΐ!?穋H#o1)g 5k78'*%PbNHj2pWFpJO^6GA0SXb;VF h=Yt՘‡Ob4Q4d1VTGKN,"6ΜF %3a-W3e^\ zr] Ki +/ƺ7EN)(ꦑ6~,VE VSӢRfn~:}t0%GQ Dj[1"FQQb3Q]?h+&@zLYB +,%Mw'Ia$ Q=uYsTB -ݓU g&TQLQLgyiP6Ǝ}]7iR^!FKBᦢ5Jd2Ɲ:qu#U +H)4v-@BN ifSeO>I"Ntl?Us*Oi4K;!ql%1- "%(ѥܹLoSSᕝm( +֌ܪ+sFFWod,QbdB(*dtI$  F`3fP"0 }̼aiටkp=YS‰7-b$'186h^H6 +Gbgy@h <):o^i&망n( +"deA53cK^3C"xfB+DuŅ*MfHV@ cX=dԥ bkug(]ꓚVI`4f !m :Ez8ӿR@LM7P[y=A + D T C׊Vc}jxɠj)BН+e <*%2.Aܖnb;_G韬蓺VɕVv,]ߠwjڵm?cDtp4Gb@ +(•<j"y/R;θ:Q4rS%f6tw"zSv[NC*FJ""9XvZ4OZYե洣ԏ8^/\NMe4c ݲ +X dp> .hۈ~$t$kUeGʀ<K^ԷxQ$d B(^먭ŞBע}*M694O +XΛ +u,_w-/ߢZ {[;=qUZ*Qu஺/[etl mѾQZ7nv`܆EU vY};ڏ %^VDoɻ^taecDX)pÉꮅm3׭8mP d\K 6oѼЋaNt43ҌGS!xzFж^pݴt3zT9BET"C ":] È@:~$@":$:Jz^.8DׁCt|8D8D5lסD0};-^_  $C@"*_ 1CAB~-D *.D*`Pwa*&`P;P P6Cp~` U-.C:Eoha;px( .N8ZH] P"ҷ~~۱tk(M+%X8ag$ ٿQBT'z7[e 'bh3PW$PfOVtE9JF;z␙q@2\!"y҆Dp-T>jhGV,J;#[4oajRAq膂i_-􍚉ick4>ْ`86:~rѴcu{BXX,VR0HP]0OθN*E >eat <~*6Gۑ"ok ԯLpǖǻ*L{U8HJtRFmKr }#B;Ӷ > +|\oa\=y)t3!-m߈7p@y7E:B޵Ҕ=׼{R?G|?Va$T1Oب*Ed\5!soD 4@.3b$nJ{Us8^}]U~9)-ר>M!:4iR#e6ݏiXeiig#[%.hb7Ϡ=[/abrQkG0^3Y'{: Ė: virwb+VUcն$4M?ʼӽP짠<-1$[&mI1_VbFVcF2i@TkʸLŰA[#4S~^Ʀ5u<4O>NJE(پv +s.MCoELIənܶx`;(VLG+qv^BdIkQdX佗ak4Y|X;;iӍ4h|^3\ĺ&qeߩiQfn~:\l(neGQj~ZߊU!n+*Z3Vbk%Iu3f퀴$݇ϢzYTW$Kn_ $\VbE Xnfa}\":*K5*Z z*[^ŕb:Qw3H`P=)I`M]aU +3ryDgQMtz8EECẠ~ +E{,6A2 xA @ɹkAv*«;- dCBDn}'dхt_"1chFZ@*̓dZި\yřLb +---8 "d/]T̴t>PI(v u 4O8oub){4W`Chr)8E h`hK}LZ*hE4i[4gcj#;DKeuk#i[Ni9sR ,i@`-~k9N.mm]+[Tɹ@tWiߣķϩ{@:Kg~LAǴB_y22O8:}UaFE#b)#N( + ,0+\10WsZpyt{˵ jD$}4E} o~߼}wwᗿynovw_^߿~ֿgx۷o^_:7_m]iFϻ/ٛw n޽}qR0Y߾y|YڛgWqn^QпOw_޿./GEQ ɺQ1FF>gg|p4smYn^۬Ù߉|@c5eD!'1ծ뀑V+Fky>٩* ~ y#ogclJ)+J&H4 +f`E +ZT:УRS9@3%O,#/hF1CvU@uyPk%dK0^;:#x#vbΜ%gǤ_YR'$MhAܖFJÒI_G5@T0{7+\Τ7710 0@,n&V 0RUBn>GRW9E&?Y#Њ +lJFIVE [VW}-^pG|L8Mo F&ЃP=c0a`oM }8&\&)x,l'PX&8gc`RIM$h8t8*sȘV<$XzUAtDTTK{K(f@Z`@Nb}Koiٗ.F|ȀGԈ4тk ɳ`KZ9M5XXI3m"3'!Dk:$$'5A:ы;I0ђ#Hs9虙x3$f +TىVl K+nKv b@LjHE# +&4240=#%sM9I $Q,*WNXYI*J GFO%]POH(ߢTseѲWT<0ƬF&v +FB&?iRa}4J[1Ez.GLLĞ=ܻͻqt[ C5>N]d`Q8nvr-[2o5ȓo";fQlk=V1s!&imI*VpdJ11GA[.T¨heg4UȔ(1qK2g ] D`~K+U։SSZcIӚ\ܬu>B|59F$x8X3=,'(SOHc\|(6sZ3ʕqpǒ:Uh!v%,z8)Js [1I9(zdŅvj>i"eې4NRcy ;j@6WIF})Gbc-I * ̜!+(+oe#BC]Ѧ K*`R/}Wq 9W|.<(8"d譙PɕLU+Y/|d^+¬[I,$ےB L +W aҏe + +/AxC!A]U8VwC !oOsᓗCj%\B[.|&HpxQ3t+d`X)dVǩ +4+GNIeΥ3I bDI `xV4HE=sJeg %h>g8H\;nZne3ٙYL4tR9%\UصءIT|>T~>T*YIxYq;gn0+)["|=8:W4nDL_BQI>lC$;w$tд;#/%~ԥbœoG_0;hAr^9\o'“ +QWT &?H8 5`RoF9Hl Iev#Y B\j'ADUÒCTG|z!VXV."=X>w 8Fi$RJ[JW|_poe-v8GO| !v6*,W`-eIMu_HBRg_T]$:߆6P8|!= +IEmla˴Rvg *t-#dD| n1w81ge/$R`i qE8+e^2e[5ע>)~-~(i"^Yш*W#CJ '~L#?ϸKOՀhJu38IL/EQYɭ@E'R]3D"8Y!.=cVL7I/n[s .O99s}?B8AMQ2z݋RYajQ2u?Oύ}$)%M*CE[Br3:[!Q䗩rd(0-.J9*&rcDC +R1cţߑt0w7E%IKMj7؄^hqIj!HBT (M)j@%$q)dFF! TSF&7DaSGT'S= k +!#.ZUzZi)Vy ~TD܄tYx w &:GX~i+;$2d9&Ee'i! VAY)VQAEṑHTjŭQaW]2Ĭ HdffT7G2ydVgVZ*=IHyt 뢹rq=*7 ~&\jYP0ⓖE +j/P݉2L8zt?PsiFOIqK&W'5!4ĥj(YQ( +XվUPdlV@Dw<%ߜbF=EQ30YUJY9A}7 +jO*ijI[9p>;2U%Dc&ƴ0'NˎcyB *¥$ @k[ _K@(w˚fIP},PǼ(gn$:PIc㘊O0gT@t;)-",$U 1=ȗN/m3x6i^dMf., &b HdIЊQHğ5\j"Gs`c~\|P$=Dz8N4jsM$PJq^GY׈Ҡ4ptkO +} +%EEWg8չƩA]xnY!gŐIYW)¨{D*$q F'wc2xL=h+)WXQ/ Gf[4%XCJ損Pa^04yB +3ٙĊL$-8hRdwrzjsKlWMxI)v3d>J3CnYvܼhv 9z|`1m +`N_7y:x5uQO`̚($C#Q&fMΆuEXRQ`L{Y2gI@a!cհѧK-Kdr08OOQ[ptNL]6,J`I#ĕu=ADQL/@^I|ſGc!qʦL{>ggf0.JR]rOԸR]w 5{i, X]ź G+)%k\i"5(&)TJ' P^f/E Qԍ:5Kk5gPﲑFL55[!_DhXW] ă'$^υyt!D8 +YOlOEa)J2jBޘgA^($p$轕dpeՊłd ec9d_ +PHEw21hH#u;(DMv,ٓ-  ;IdgzW{8C@_al=0` eC<+ܟkR<0pg3"L2bgCh49r0GGu'x,Z0y2jLղ=;(fnzӸWl88@-aF`"Z̵I6$py30ܚ8oDXr82Ռ~Zq&nMDt 0ng=ܞq) l  {Fn^ +4Zc[,kl\bI+(5Sgw!9~qpT40c/[FbʞaRE7kg~D8ࡉ1`V aKb%J*c9dм(=L N7"Lbu9%6W`_ +2Ar+Pj#؂\͍i&YS~IY6e mCۨjk!atZ=x9[m5{z`fyv>C',|du2M JOjߑfI b಴^˥ǐ%0~VjA`Xl_nZCu$ (f_Ŝr}A'V e쳄mgB+ |%v1_#NjJم10tfW +'-L#!<؍IMMΪn0ǟ` cu + n-K#!!?FT 4ISiAKXZ^!TztAwJ6:7~:*GCb!1; 8[]>mS*|)겍@ .(W <:; :զ3 +h8qML(=\2)@xYȫ3{!n ؿ? +mD=ߞ+#QZ)N,czA-\7t6lN B{7qes P)|ïMCcK-8>4 34Lh=^Q HW,7)ӣ3?P8 +!FRd% Hi&v * r*Y6zELS "XG}v `ͿMA7R-̫{f4-?BEf/3~bpGhvcPS|]rߘd 2J9|J6 +m!Dr< K9o)ζ !~H㓃6-$ж|PN *>q<QRpQU?9/amK,?hca&ť6htKwO- G +U!|j l_p$7G:j'Rdq! U~~־ Em;np A*&<8'cQiTr[LmG@^J).bf_yXz|+ǞaV'%Sf'\<]1)fv=%LVe%wb$T*돐Cʉ뱉|^@r|,9Ff g*;7;v-n9,Vl(Z5420 2( νD͗8Q)XE4}<ZM7Jh]5y曲71RddYl=yEpw_L!;!N?P Gk6H~)H$(Ңa~=ЋorUO _7t~o }\vS)uIMaSw }҆߇ORޞ @1Bʰ'p PےZ(<A[lg ym <FumI ! ~mm.?pٓ~4袽H 22w΍kDSRꢺP)a戀~>$4B;>P_]{|WG(tϐf(r>Rǜgˎڵko +nSVfNMԴG<qҘ<35\Ҏ]5ۖt0ɰB;/1'YV4%AN$ErrR:u`+R_.5luG&Bv.̯iUsh_jә!f?PzE2U|\WFU:wX#= +ψ5vW=JEאd;3]助Q2ztN+_`}{"}4*T*QГB~_d)봳4Fړ{f) $yضi9ؿ`W@hMZ,[P B0@Z,a$|3Y4st(?~N!$s0 ͵ +ku{aR9'tv5e +K'S>!1=@tPWfl;Mu8Z]oTXó.?@i d30P^6@(AG`Se'.`+V]ˠ^B|,r:ҢcI]^_T6 tzU{9S5L-H AFce5GiH x7)G~9ї{>&0 +?:2˴elX,&6IGt&s۠qJr6:Z$Q6D0N{+X POM#; +g +2㧢Ѓ^Nω*0sʤ>G VrljIfmP%YU, yB h;+bPi,hvC%5x,=V_Kdt5첷f0L6OL:l[Wk"qƼre̋899C!)Bqpu»!^ҵ HAbB?Ww7 lgHH BW3|[(@"UZK!餍m=V̥Wx`p}{]$B~EjQf9!jBt<ފI \=)GW(fKQŲg.+sC?#Du>zoh.0C0i˔ē&鈀¤|3nJ `.GVk>nX9l +@0*'7v ?b՘ᒏZa6`P"̎垔]Ur'2Q ΨWDH B%}C[7c"))C_Fgl9B s^op"T6 XEoIdtĄ N"'L|[R=8;by!MRZLk&}9EoB1ws44&䩡4"t}n U (as!Sf6CeU3<  3ޖ,8aEv~@3ڑ*BDzL%gƟS mA92@E h1tzE-h 6= |^qD*bT`[BDˋM9W._ Cgz#_iYn!T{Z^ =xYahT<RQ{%"'M86P,vKnr-XJTi2sh2Gaɳj͇Gy6N +]l뫜%[U>C 8L޷8d8(s7QF (a6Ķ)2Li(X +G8x^+g+)}ǯxeQ@!= + X{3Y=aYLRIN+v\)3a +i, +MH^ƒd_w)sC~IPLzfW$dm&*n뫜ThN*m6RT)RŠc U>1n=PKG{ah̼r #moaN#Yl粄~ 术I_3gX Xus]|fAJ̗վ +8bʋң9rK֚FHU[O]Ad xހ?7L|' 8e%1`KQ,S +JytwFWr-ԼgT9ǁ77 MVDFO%a=WV8s{9DUpfB)R|N9E.6݊'5&%5*G*عJ pm}jHg/!I̼޸rqޕ9TVr(zD+="F$qG9mFpU,T·T3s1He>w#,fY\5Whߘ ˆYȽ ^(T=z sUU(K5ڟ 0F9RՆ ă蜉p{nakS-V'q˂Iɧ] +o}un`׵\YZHiQסostqRj{6aΟȡ1K mFvʫRBP%D-Ά9 xg + &\[SYg?Q] {I>xu/e|ڱOBɪXq*3o-D:ET]p?BtuG41E,4 Ż}d()#գKv66o +OX@(X8bZgw@C!'AQ{`w+9qVr6%}L +u I)#Eq&GUӒJCxzC>s4fYHx{DdǒԱ p\lwMgn0.PQV<S72=rj륯pTխQd:35k3;wPgRlx _lBGR׼:TbOqZno6A&F?FyP+Ytg3dk5^l4xSy`áͤWbw}5m:OX:If\i,o%6H2_57b;s7Z~C 8 Or;UMg,{2rfc:Sm?VXY0;ܾOX@u2M,6ª3e3xc 9YxAEIA`YZh`aQ+I?exBMZ0d 8ܾ !I{D>2@T:sYvpDvF>"'oz3ι0\2;zc@fC!!.(zUsF)WcќpCG`GRs^9(-J\s +7\%`7Ľ?#O MMV>żyH|+D3Sry,$GyЀ@@ceJ% =5tn+C'P|oUa$4{,g0 t _}8PHG PbΛS$@Ǣ*_A%$I)rmD1׎ʶFe^;^F‘|ȫ|7B<쉀.-- +AQe|(UXjno*I!CuԐEVAd\d[V%$M-V;C <36لdi$s̳8ȅ(ߧ5y- dnѽW "^m1$d,_zDD9Ƕ>4#XhD;uܦ$Ks9MGjToRn_Ds??O?ӿOO?OOO޾ͭ0'Ϸ`<១6`V1g ܪn17Zr7ŭa~|f{ 1S=V!osT^!<!# +I#*6(g}|щ|BȺb+[)>$;fqZvBIUsB0W0HQLslT Rg/?/zKԾ{#'A =fy_ݧo(?[.&ʧ}! 틐09 +a__$Z_ )Y=LٞG}okzJWGz)o#z>HBd|垦2oC?W-O˷<#Iʀ~6Ĵxm]<4O.)s6Wl[KG'xoξH}'Wݻp+Avos.~tqs6=| s~wB~Xryw6gj˓rmŎ"0ۂ} xf;'BOu>=hKPE:t{o/u1#D.;q2]N jendYG!,aq[m L1}QRP.C̲|>-tyahJG8402~~'woy| DQ?% 1QSnduh5OhZRQ9 ++t/ksG55x/FQ6J7lq((Π4~8/moct: .? /d`!_>+/Bnz1uNi[s!˰!Afy[ _~V۶ܱ[Y9nQ2L^ї!#W~G/ݮ5(}O%0"(߲oyX3Đ|C7!Dn4\m&ᔿ NJa !X?YEŒf]"j7Fp;,=/u[{7.OG<[|0.Sy۶jpaEnZOnS +mҝZ<'Y yF~FIDpFżvp<})?m-)e 4fZjOmIm]SlScⴎne$FV厍 +m 4uΧ6~gq!?k,ݚ=Mˈ}?\]T8o/ND۰H|7QA1n{j+5[+53 یfӃKmip7bt-P>Z~rf /jk8Lp҄\vYExI4$WmhNsy fDa _3J.oh B}l2{噿A=͝9E d;9smsFn,ݤDK:fIJ+@mD͉2y!кn2xOX[S2k\<#c[ݕ]Se6JGy)'Pd+S^~ɇ% e 6G.nrx.ܞȔK{Y!_a 2 +(=NZK*#69ON/scu/scdiS^V遼>H,a Q{HlpEJ|0#Ƕ1R.^8|)YnIak4OgA*&-yY v'v>T 7{Aέ.,̂r=*f *Qxdw'`V@ Gƿ棞Km{V.d9+`b|:g2=%Ǜ/BmVC.L{w>zYQ0wŲlg^\ko>"ۇVx:?Qo +c؋1.qZ{Ɓ6C&im\#f>o2/r/l6kqiO{[rp҇R}brE +1mu0~[2Xtч-TbW~ǖ;meq3d-yɟ?R.TIb%ݦgY+ Du}ڻ=5S$Vk&zʴ=]=htoGX,2_޳Oωg*QYJT=oWWGjCUw.iWb Neۻf4>we8&]8MH,W?e9?e5iQ쀄˛+ TtU~1{`_y1h>q žËm^="㵔7Wb/UCl4,U39\UiT 9\}w%Ai:yȵtܭy{k4Frկ*`r0nW,ίle6'=25R(1\ί=`˄bRsˣA|<`amg_֯4E=C/XzHgH hl^HG4ڗW|r􂅜-kg/X@8Yx?` B4Zxsei+?&@L`9윆)96G?{Bd1@x.;}ZVlWe9>+=1}8R@=9u 7Lvί/|< k畈A,l?6zw  Fv]t;AWͨн_ikwY +v| p5!)ެ_(cթm8iƑOW!)Zcێ"Ηe+ۈʲInåi6V$JyWQ\aTBv|WL2'(k#_{ۆӒNEMaU!<`zZÈtz}:ӻ{2N?RC&u^;: #Ӎz ~{֙s>3fX@t:TIo۾B:)"Mڛ i3=oR^ádlz2}4=m:m)sQt;.(^^x~ۈ9ú9)ܛkԏnP0IZGn'6Ed6NқRnflV|->Ufa$.kOe\@ -G/϶-۾/qa։/`<:NBd,#'xrv+R$SwMf[l{lX ;ŶyMeU32l->L2 @1I)ļTn'L#-@n'LP`敍y8acNB&pGSj+Lo|`N8 O4 %ˉd:e9r%I W٥W{s1. wTbP4^xذe9 +G78oKBt^'EmzIF&KXe!II"M4֥"Drm/Me3,ߍ7_3 +=U YD[".s^Z)& 4rS0(50x&6T0)o6JlL('F 0%׷ ﺝ0mcu\ }ZRUn(Pb! ezү oڑN+Ey(4+΀2yxb~E2I3.ٺfSs.3SuVggOOLɟ!cqeC\R)paĔVM o +$ϮgH( ?ζD:oLF@ΗñIb+d64M /ME+P2 RAV49_\2P6ΧexT7CgDɥsiѦ +z>&jkҷϥY}^A +lWKl3K)᩼yXAA a[Wvݎ]fTɱS2:*;-%+]ێvқdDZmsZN$I= &;e2e0˪ƒm7~HS6-&"֛"wɷsmE=MD+ vƞ&މtܖ\GҍJ.ȔN\-"ZULe9%އnC9j=!QZBf%_ml!,Ů o1zಷ}!oٮG+jl]^KxZba9mHx?OBJgߙ ڮ-6< {yeslvO`6"<59K63+.!I͏O#B/%4o#B#FfWq[! B0A)4 $$ +tֈ*H̨k 6/] v E(YUm@{θ/ ׷Dc/6HugSj&-|y ^aDRf_NO +6S/R¿cT ?0hpj4 M͂//>3ı,Wr[y42i!:޼ec/h%ؠoAb7\~}Y2Pg-N:IG!U*@ܯUFg N9nS@!n h?[(voK@Rbv{J6Vy4N/G@j,#@@L:6}s8ZFrT0EX`Cɂ2{8;# Pn'@`բ\ޜgo'@ I/Hhu9N`u(*< r: ]oF|Vumu'o6J5g/@Q9yWmHr rU9&4QQx31&01ڪ Г) +9<t4)}gJ A+y6q2^~@E6䜁J})"ڰzO?(Z[h05WEWRX|xsӇĐv@vP@;|y\S9( +v3}hw!\y;y:RpiwG-FQ$>AiO; f|8@iy +6QdDZ$]w']ZsIߑ{Q j + ݟ&xv~ q(/jESSyQrlx}7.?."R7Z}EsD}iI҆@`?w7ට׋93t{GMmO?qJ=nj㯚E7Zy_(۝gYj۪f+}T $J,cۏoޛ MpWX) oqs]p| +TR͎%^=M]oӷjo U.7e樟ooTŀYl_pܺ6o&n@nﶞBr[O6аsCZicWm6~UDF6[=BhZ=՚^vTXH-g٦ZG.-u3 ,Y=TDht7|V%73sdKY[|7+Wnqq +-j~0>f{ːYe=O2U5[ɲu͒l˹n'XdU1a2C/Tebʝ0@N|l+14(=djzui%,`}v{ ߬EEeU']:#ܼBb4꛻WE( k#"#Miu)vBC/.F/O׹eP()#pcqAW͸X.@)%C!&.,4@X@֗-BZs`xi/-c%gemLlY2-i\Klr/*y^f(zx]lvbwU,Р8C+xcj∐J۪|UQe"}}2@x.8D3m? :{[yOd!0"b{MEvh[L)W7g)f!5Mּ}G4 +uh&5ET!KT,~_O\.m51ށAhcmtiH/z;;QKcۆN^}@Q/x7 vX˵)̄GT&Md/6-O'}l0n+jmT5(l>=mԗrA z8 Qu58IuP]hI5_&H k28tFw[ roH*1;Lo~Gcin#SFdRK{352)_2Ůuys.b۱h@2*%џhE R yTߨ>i:@n!͆d 7!Tr+ng! /C!1~&okj>]Igz8 Yѐ,H0bϗO?Yv?Âm|4Rz=}ˋGOKZ%6={d,_~(K Ӟ/ӕCǻʷ$H/?x4r4inx켎N[r_%,O|,Lto wNQN 4,s/xѯq((۝S6))#oޗ Zownb@6WgDyXp=/7e[S`ӭ8c!LjJ +7MA'K( ۉ3_1 h_2) :Y%,iC:Oq7D/G]_Nb=@ $k5sכ"D"ߌ\EK /&46v'[xfc䑊chsi2JLI:5e99K)`9ˁS vOj3yӰ1Cx\DB( <ޗ`zb^<ʄc*fZGѹ@P0!Ӛ+5+ v:{_P;>whK90%ud`]թO.ѩa"ۊJ + LHxNb0,sjnWEaV֜9)DtM(6gQ{*hK4{U6^DI-1JصME˯sN +V4C}H~s#W0h.sZD&?B:?UXiZ m0!NBwcPv@ +TbOd[3FՊ+=DRי+u3Ϝ[)w@3x8JhL-hZG(uA) x%f }ZQKѹa7 Cjb.uv4v[XVb:R X| 8Eu˅WS͜7Mm:B(:7RfYYWG:gxsc¢Y@vM}*0^Fo +# ܄zMъYV!:{ac=ؗ5}y9eS,v"88@flf"jQ̕ED,Cp0dZђmM} K\qs:A"LeY5̶ׁs8ey+¥oq$Ґl;AdMwU~j+l.фeuVQ1ΐ–*1Ѓ,: 5$M̼ayhSZA)ex$@V9PGCc.huzE^8P0L8Or7A|ʯ͸ (/z7=m+J8U Ĥ@:|=20UNXD;e)+SkPg/ΡUE³Nyuy(dqI#z 7Efb'ZKN}K\j*h@>7,-k +.E[Afx^nFVQIh86|ƟcyϲR6icTPqtaijI#zkVRsa=?Cʤ%8L\{47T6^qj}h"JM`V%qmN=$@F!DFK%hT?$x!P1W^Sy/t b +BZB6 36tB(qj_JϑG/B'e~5~+եL%NglfHtng[̙6h>8ה)3a'ё0#z!'Luѷ)';f[4 uTʪL +&E"1@Ys'8˹B䮴jk_]%W_6J IRZ,u B&9 V5Wp9K[[[ZFVs ۩]M{mP?4|yI"lCN~|Jo}Q|S}hb(?y,1h]aŋ M!wH:PJq'!He1vumel~MO!=!?ΑqKGK +3 zOPBpc'Oj%`E6!h2&Q&ufv"b;ח]*\HhEi6v;z=[z-9#v-" +%MGZ`v;)T <k"AZT)}R5%gD (T!!=c_=fdpWBFD-݅4R0;J3J``\IV3km{e?Xu6WĄi TLQ-?SH_ˢDmEW2&,ނA.clӌӹ]p=Ѱ1Bz&AΑ ]!2yg];\Hy> s/ ø%46©hbj2.޾9l5-tZ7g:(q*m:VBYw}.C,'3D u6kSaT<(Y~2RC&ZI!s* 3G%Vi dԔC_5=z?ap*:=b_ PH& c:NmɽT`$ǖ *3maWBѰ &f)W̯F nyh8$Ա!k)la iFMkG#$H4VpTL{׼RRlPA ӎe8ڭ;ؼĚ'5ch5WL^{̢3|XD: X {bY-[|ܱm9.3 }cFԂ5$[bO8J 2챾 6DZsrQFNa)KfeN>SLLV6^9Q4"9Kf$-ܑkxaWk,uv e%Ѳm#9sY229dd< 5va͹#d@;זfe4{ uWIk_!}E)oV3!ORfFx \S) S/"yORRcjY;0*fDB (&6:%!G~/۹ 2g~%LIۿ ,1 Y^.Y:A+{/$HvX>ƕ9^AR,(Yβ! =5*݈vrɫ5i1nmeц̝Cns  ➿|ϯVZ`2~ o^LjQl"  Z+PG;6{F{ߔy=n,ߔs(_,uك,% 2as+P54$1Odkc#iIwntLىTsnCr!+>-,]r@!)\ +^C19+lIoy +4FDbe =;~[pp5WaBqrd (0]e/~1vm^젅@'U G8fSpud< tC- xm~l\E_#@ 8tSFaD/3vqaȸBp%36 J(m瘘q̰G6%|o60RkFJX,wfڢ /x N#;ٗ>qz<=J Kݒ9ߏoiA8CMuW.^{Q/YMsޅl~Y/˒# $Jit65Sև M(F:-1z9 EQ(cH&4Cl~\; +bP~lhґ Z#;[ ͊pm/,:%f'4h5H͋G,NC:l؇(5ۙFh +Bj hP3N +dM#/P\p7DHq F +4| gJyk52=c +{n=qXF$_q[V(Ʀ@e}CUz =PitSAfɴ ]MzT4=ۻvMM|)i`XXIc9!r;Iٱ\RfWt*_Q#-`m` 6ъ]W?.HNF:='K,M{=1b|FiLzhRSئxm`uyΦ~#d8֍yhi)Z2(.kTˏ/IcXU]pz:uiP/\b8WerP\bs:L!;ju?֒Qb2~),h|K:-IoX6Vu @)YhjXX, e8 8;Nbߊj"^pCH4\案,Z%:/dXu몐C.:G2J/BlQ GhXbAE@ OD\?`FsK_` ̀<"v=pzQKᕗ/BI4Vt6qL5?P`[SwҔ~PͰ-]%xLQ.-]UBҘq*SE I& +q IqԍzCPt+eBSABOz!yI/D"]R)pQ;Y AFRW  @mHGcc5RH|hv }9KIN0nA-دVH K },x8y)\&I]3\.g& wDD`;aiL; +mR!gotF:U DZؼ:;˾#[_sgb@.L?DCbK43o/]jU&ӒHzﲂ>?=Y+#dK/rx+ ,^k=_,JP4g%hS_%HMxU ഗgfIPIЃJ8\x̀?mq?̺۫x[ul7:2߯T +Bn/\qgXSpҁ ܄[ 4{|?M0"q^F 抌8{^%f'}QiXom=0缊ױ,o=b%zr̀ܶC-S "=ܨ5yhaJ/ҕEbd>A5{tC.rudp 뛨:Q.]ak]ݤU^Wh/Iy`^#(8yr-X06񎖾[`YK"LW*X7k/-%A(` +3@ pa3a.@${.0N {W6Q:4{B8Gyd&.Z!hEdE "<-5)D%jAL/rU ^b9" ߏb`T)o,/r:uDƽvp`0-9 elO%=Q)@DQ9o]2ywz)1q'9I`CX#C45JFklm]N$:'^W ]G#&p6zJl*#??Jwp! wHA ¹sZ'B8x}=HkrDԋpo) '6'Q*J@'r2X + -g{BHkKi&-Ez\ %@O9GӤ}5>>}C=qu0ˁ_wwr6EqTjD;=:7nmai_uVi9Ic|ǜH0QF~T&BqW丹KCCȏ1ѵ6<%;>6Sb#B pf:IΜp}A⇸"#X=9/9Rt D19M=Q\+,w(M@mr՜דșRS$\;I-zkpTqiVZ?|+{ ڱv"@`ZPߤ"[yAt8#H¤HU\{}G\R&aaVYRBNN_jо5KKUo?k) 3a;֩6{"ͽZեo9X}N+)$gϺ:(>ǽWJ odQDe-!ʽ(g&8mW@2zIǸkQemG* {=E8k\a9L J 4JZCf_xxHbפpQl8Kqe@}eO&lc= +fsii1v)\ 'ÿ^KSD'g,pD%CP A:"DRo`g{QuJzj*9]05ԃ i.2 "|\ 6+s=<sT3cM4rHc+Ňnؕ;jdRZnn B[a$ʪTwJToo~cZ;|Qfp998+Cru/F|"P 4lt+ 5Ab|Mj7RRhg!/7|]dr\AQSjo<?mޚXGdUd~N~]rpQb?¬M5ucIw)7f^1yga\oq {Ѵi{c _"[Kw=PC6* +x=1F_CvcRhd-gT'jm$+9/SH_W9ToĂVB +2 /`0@xTJxgTH/ϠLC4}V0 $$kX0\,ZXWk %I!@LwEHP\η>LK٫uv5x|B05Nޏ[4`BDIL9^0t +?dd4d|n:DtN߱q-GZN)HTk) W04JU* fZ 﫻Mֱ8sVu5O5-Dzᣌ(vP9)T6Tx.'/-/w$`ok՝Pv0(0^!uƂi +zWi+&## mQ2  S8=b8 m؅3@r^ŝ]=䒣$:Q׾@^014~]ԃDi l]%'U`0I,#;uG=r%w|0[t@'G*w63OuZpʁhQCW +> ԡ3˭l7I|m +JT ) )F^dEIRU=b9_EJ#C1#EzөqB(Hs9ԢMΔ(%7nzF+qbr6b؂Mλ0 !܊@ɍT:/M +ra5qQ9!J)7ԫHwSe{\g* gIᠺK`f(MH~ KT* e~ ı FӔ@ !Bg^& +ux5x EZ xY#4!A,# |"u5n#7 JAU}r)^[xbU=13e +OJCDA BG8Z;0J(N5䝖9b-'n;Jj׫# ^Fw"ʾ^%SsX)HW=lTS[D9Pt2 D2Ca"јiK&Fg`])qLKVa!%u l){$9.`1b sߥPx!(=ٗ#*`זej1&0Շ"PA:ɘOjgTϱ%BSEےװc#PΌSdlb|?eV&NƣC̽S#(F7YyQ3be={(0JmQ9+_\,UkZptw2l#NNXPcՄ72.Nw;[;)?+aQKHAWO=.fJ Xcy]2)/e !$2֯$gX4P/28 +\Ӎ{U0]n8Sݏ *IT'bS,C#ߢ =lm5t=RO5 [=8xK n\F[Z`(o%o+=|q,Ӏ7~1n:Y 3ڵ;@(݋~U0Fc.6@1UXfa9a(@>p w^oD&bp2ɋ.qc&ˢkZ)INV#MuU7(XÅ#NтH~D{Rr2֠ghjկd(qP 1@N1:m6U[2=닿c)s!ș(rw +4yeMrj5@qhcP/Pj(!C.SI*\d 4oe.PسW,݆ɘ%V=epnWg"2+p 9j\eD!i5ӞVP#z JT -5vE4Lft{V,cnwE* 6l9#SSh9$VXC\b) ۪`Y[/Yu 9YA\šnb'jI h/i/6D@iJC@%Z=VĉæK?{CWC` W\=(G%B[JI;9UzٰH҈[bInh`Mw;ȬyUK͓ ۸p^-.+D|JINw !жSʝuZ\1@yc!M2 +xطh^wCe [= +ɏW)YMDRyD$Ujsn$y.f߱Y/f&`xq-dӫ|sM`\ u +P{''"@l'D m +L"ќ mاEm=NFI +w(!Mj챙}ǜc-~SX@ܯrN9f;ЃPF/[vHlzmj܉`v<´B'Tdz s{b/K~'qwsT!]OL~2#eȓ v"Kb^LOF(wF H-Tԋ<$F؂ĽĴ\Pn)e}S jX2|()F'`2B{ /&O*k\6cͻ-Rpa+6K*lIQ\"2BSV^bi(aϳ% +M\V)!d!B'h|ԍ(B +,MQִ*R4!M,K x !rH<$@ H Li"S4zc9);{ړ]\0?])%{}ZIa9w@j 잤"v* Xl[B}!֦^uGT77hœޙ%ǜ2n QW7)7Ȏ,5mpa\~EOxzOM1gfFL]b$d`ثN[|[3LA5Pkcdh SDʂ6L]PGp rZu"9@^M A!Wuu1EPI7" Hc`Tv2X6&c¸ė-5Gf{%S=AUrKҰ5X-vlrRu*zH +e_iZ0{ +;kAje_) 'E\3P3q7BzJo4K[k)hk3$':oIQ(!r\!:!L[1^x\1@ +M!"(cT|˱H {#K=?Cz~I%Yy„f+K<lyC< Z쁎M+oLjFSWU~!+].TrZaՇJ79+A-Rryf4?!R)S:c'"fllxmBb!بÉe4("rRt.D1rG}$?_uYgKH:sSIpfBV҄5[e!d^L1`6^J̛,n->.=X=e10&Rg>b--`|;`>40VIA(KHݣ+1iڥWWy ++Ib˩;B}Jh;O/ i~eRBdrR8cHA=X$4Y\L>("D7y+.mT>,Hނ<$#ju{"eɷp`a%׌ƜAOD7=X&޹n$O.qb{؃D iRoRl6Cկ @YU.`Qd6`{e""R>AiWsXAm2^D!9jrZ@&QHx|`7%_Jx(z)~,ȭ>vw5{Vv|s8`Q4h[lO[A( dO_ijFA^΃+2݋Mu5]D endstream endobj 26 0 obj <>stream +hFux(cŻ,ыqyh +.GQSC +ѫ!dPPfD2ӍWUЈw[H8K{hzH#0'V%s_DnQ|?$D *#U..yr(mȺּqmvU~WMfd)~u[%ggKe$pKN!p1Wﲩu͎>?ţD^T_ߟߨ>_#Mn1أ#ܤ#0sJ\ +Tct9\\"$H"=lRW| 9 iŃS] lB*.=R|>U=h \<pᤗLxt!\>GF$ H/$b51h3Ov~?`Co9K7-,K"j5w])r#[IC ~DS[Esx#U1tuEg:ԁsEzv` +d] n*T_:Je)CI[uŅeZ5KZ"@R]ZVw{NhA:tW?(r9$ӂ7y^MӖKboMh +v9ٛ+?M)dD_uO瑒90{q8v_m#DdӤf"qdTPv\ud4|*b/K=O769X7+!m)M0%)$Ԭ~xuٮPOz ~c"8h; Y%l&f;G6lI{~hb iyCuKۖ"`{u c:6|*PK!tʧ !2O&tUwa7Cߣ n &QUa*3w$W߯XlmA +i;=&GaށRµ%܊%ރfGjǯ5} Xa@vuS +ᐰ1PWy-_C}7t`TdҘn6#-#*2^Z=qlȿi3砺L!OfA +͍M-8ŐKƍ)I;JΑ}\.=]տE~+4PKUWmpqKAJD'Cu86 ^J'Vq}bH0RVXGJy +{L-,;B/;@=W3^RMKy1Mצ* ۏgGoT/9lFNR E]RWWЯ-S@}Џ(;b!g)YéԜ)t&5?o7ﳐ̘jL%I-,űw,>ʗF+@s-I3iLŎ܂Xmܾpąo<(ry>v>gqwv2P:z,)v\Cn%n&܏A@Ra;6qSu Bo6 _ʤp5}NnpGaYInvA@Φ9_hh7!Hmz($*PP|) MޏHua]o/NS@BmdvK/E) +yu^඗覙 .p0ir0dUzQ`(lY; 1x#p63Y4]0ʤnId̃+23ҟ)*e~j6꯳k)?s3Ik2ih{5~'Z;F#Ě:/ɭ2ЇkAɟ!g'wG[/d[^ 23[-%} ȗHKݰ_ +~)>Ct<8 jΰ(H*ֶv͎vP$G.d~UWKc +|? +oHDiQ`)Y_awxupKTff>">B5 8Ԝ.ݗFcQ>`EjR; Bg1|RmCe!Vodz=$.a)lm#(RRA7s^vۄi/9X +)׋ͬ`MA5}8=  [/4`C* )_K)ч4^a@7Wvܱg\J䙺@a=[m 6Z|pE0X,k2YԞ&Gi\?.;|vX[x= +E1_ :Pv:k;W/$M;~ZF"E K嶄5;vaCTn5WXA] m$hv 95B@\"pm{ldEA{0-%C6GwĞՕ؏:\-Q!P~`x6<QRaD6AηgZ$x0Ym]>p :X2X+y5*Uռb9IcR B&'QtbTj{PQi0 CH]I+Ps= ˫!VYby˓{\7Ce )!9P?ڟ&ܾv4&i.&'aY5*,o2cBC,ޛ_ғ<Òk\хԀّV H6+Lb{*S}G-I"SjztSM2yR=Xa?cbg#/l$ow\crb!I5޽%xL^e(DBJsUGoF2ILn]譒6%'݃\}q$UCυ(RYdKMU"!s|PfBC+UQJi#_7T 'ЎIV :Rm^\ujiKCV+|q$e4aaAY#;pipR=Hh3z-;=YZ+I YK(uڊHd¼١o"&aQ ڑk!@ҟMCT "qpgG.7G2Zz`o ;OK9Apj?19-iP={ 0+|HQwP9o3y`Ҏ wz *xWS;]w(ˠr.zڦ ^+&} OP%q9@IPE,Nרw4硦I1S@v`BbRn%Z@0'эHCaf`XƢ_D*?x{(j~27 121X$3 O*zQBHrPL(Ӑm p |Zo2i(-qgd`=r$&E,ɉQS{%P[(#N7l F!գ bbJ!F携ZW* VŒ#k80\H!Q%8L4ນ\ 47K+헓:P%_ZPLg)YVݸ}o#YN@O5U"w(9=RAdO5zF1n>I-,T!3B76cp<@!5Y{/H4/z}I&b鹯jI-Q2*ôH8KJ}B8= k, Yl"ZCa2Lw[r~"!2nfj)-5HcJg]m{u&恹;Q,fڹ`-~gb+/C&L]r~‘ʕP M܄eSU=CkC{oT\J%U(d!aIn;W/9(W{Kh;x!# #\W(C0Kþ#sYSp@hc"/P۪8.;)&W\CE(l%9 +*sEKV3Q).I/i +|ĥdlVFf6\n=|Gy'45%tX;wnb$(.&:n *r1U"K%!H.^*ݳac?]1N#29NҼ‰"/!ds4unxr A T:@mAv"{.tkuMUP(2~oq؂ 5J:jVgH4xDlSĞQ۸Uسt>%(SIJÍ6O\(&BZaE @3RzĮ")CbJS6ݸ?`*jJJ#䀷 +̻t}7݁ᑯ-xɺsUlw  HX a?=7z-#jnFC,0 +8A`b0G`K/R1)w\Sy>K +bwd~k[ Pq VyAt1$DHR}Pcn⒟j@[3w,)S3-۪ʑ!?qNh@=zP̶ |OgVKa/G-D^ 9~8?ؕO x*L+(&q5X'wU_R:(G(5NJ9Yt@?~il?ǵj`I2XZ>YLoaKPpo&EK{\$鶷Q;<4!^OEF?_)0ՒK"XU~HsEgnpv! Gq nlWµK`n ܠ|Yg[J+0JkP 5{lDM_%]7<صʡ8R߃b #+h\Sbc}ΕN7،Y%n({s.Bݷ2L@}v0 `J%$1fACfP1 Qo$ofk9KR ̠ab'i>eiq>l04k7GȎ~pwh/_.,{sʛ4Y 鰽~vAq~9'`wn%U E%$#mw!q>V вO8WLE (\,?!KdƁ/Y+A OZͨ~([ +XͣJF ePlIHC()PV>}ciuT +ʉ.1&t 'Lɴ-Ety/$Y@`k?R=T~( ,TmѪʯF{Ԭk&5T~+*$upqX+|G-CY"G3w/_d!/PɄr9m'2G +B)1aj^($ !@*%(OGWFL[RM-;=J TD2zh,|y +/P+Hx!v`^cAЀ%P[#Ģg 36:S9Fpa7Xo ' 0ako%m<\C=;ƃ6krƬ 񊬪0C301N<-}|<(RR+~!Ȇ렰"o:5K<$K:0FEBAA}^xÍW|@L`3RÓBG8_v-> ^ H4=3(S$D롪fHI6Nľ_^OOWDvA2ܑlх9!A'*UGqF^{C!b{ϩnRlCI9$րfy3Bl!E)M;@iiD$`S0vr-I@ek2lBs4^%xUBRd,VjP·\$N.K-2Oe-VB (XHBH9_ag8_[5M՞ȤP6ܞe-!xjI m^uMN52Q΋%NB9$>㼬+*jCN/K^IW g( + lO͌(e \l<}K.&e' wqx{`uJh|5ǶTK?6/0]KMrv$1` 7idx +Ri/}R fA噀.sDX0(&uґwMhb,F̻yF s4A:ɥ 1GJC6{ 2ʜ!Ez6Kꏑ:v -͚d*fk/p#0m *GdjF*%({Q4 8Ƶ[k,v* t٦â̧ol^` CBTc|Wā:`ԉ^s0fߗFj(0j!дD420PR&YxOC@jIz4@"i;Iդg-7R(HrI逮 N QOSULlj<%!t_@N$@('7d_;=f&T*%Ca%E%SXE匨LSvn_ImkC?.m. ~X?`Z\O +^t|v%ugK*k8#s tt] +Rl䰊 _CV8Cᤴ:h%qu?__0CQZ$MwV?љւE{їn@ޥyb݈.rDPc3mwܢfT>A)dk0/G{29Wܷ&n= +ZhT"ہLOszqe_Y/  *ɰ-GPQwݾ;9HĪ7 X9DjՔ훹2̓¨I\sl<.Y,w"{ΗS +ؿ\/r] XROjd:4*pxu}TQϢ@א\-G^ bCXBô8L) ;(,\5вw!`o^i,u(eB +ZԂ'"Ԙd n g$̂ȄDP;17-RJYz$1D,~%Fi⑭A]3ܡ?7T/_1$"98*⮴_r{_WK88D@J`+x?gWs\߯YPbCYv~l'mˢ$D]JCR\RN +xmsG"IC%v7-Edဧd$ ʟO|eH%(g9";A}$f;dogDo"{ߐ$ +T Lq?DG६׶(#%}î_UF=jo?K#kELlL@>T@# +1{Ű{I|ҫ1͆Uң J0jΣF!Tk|(Š$RLg͈7 zS=*$u*@ %էiu䡁]ڋ I6(SY)b;w<|3pHW cU0&9~H2FLTLFTZ)c'M{HHm=+u!? $J$"f&G 6>[w? !Q\QE')TX^7pHz;@w[$4Jr{ŷ6wrMk-HE'- )Z+)nRf^Zj5ɠ%bFr:L :if=-Xޛ$NQ`?uu?j֎ $Z,42t`M@zz}U]BeNG1vmVU=ˣoI,4?F"uW?5@ ],='8zcbN'}}YM!u]8SVqF\Z21DQ a^IP; WfX9SʋI1ō`ygǐ=U|{x;gx9铧- +)A&Uv4;+I2\a9N|q I@de]y]VnWI ' ^쾉gtfDZ)Vċ!Lwzln +[gѐT QAf@I(E_+,9=q3K΀87zU_ C1א%9i ʁX+/2뼔'cO]xŘM,*)tqV%&0ij 2qd4?3Ե kPޯL}~34+S`v +ȝYRl4w4% ySG%uz+߁҆W'1 q>n\Qaر'E8◙,G2=x5C"`_qeD~IK"fm)'5}n'5kl#e^tˏJ0ebŧG<.F8(]!3u<yF Ug.FN܆]16RV +@V빃.+H({T;f$[Pi/]&$U׮eU-#c J'v@T2XPviQ4z &=B} ʋ Q﷟M-Il?$A޹.C{T>85^F//Vvl&Tgs&E6 +!]Ԁ!Kn1%>?^.O4ChcƙtOaYÁɦ6et,S.%Bd剅ap~$,ݻdf"aGIP"w-< +Vk/MKBN@"s:T}ܕLS-faG~IGl8д$yi~~r +ݓVN6c{om~اzXf?dT&/R.b_%~5EZ`FSUbp;'q(uɲ,~TTo2MA-$DrX{,\Ҝ8-9}%lCfڙ%}z8:OboG$2]ΐd'A>Ȅjp`aT8b[6|`َMA;> +ET^W?юs]g'P~0qoaGꦀlRA3`IV|Fp,N<J!HshNDjͰRWj:cJEyHt$Ԋ"?ïMe ~3Lb PM{ +E]<5R幈ZSQՖwJXsИe|[cI(X tJ5'CAfPP [l, 3a,C Q| A9'%6-C0lM!YQ}QM7vU׳xcX}u9IbKNtոTW+A}áA2TA* ,Pbf`w/r֪̒\/B++ꥃځ$,[rR#xlIk)gmӞ |6 O#~ 8CGf&X*i-Hb4{fLM3H|zij3ّ1CaT-'DnǛ|c"][+?2N`HOt ץ3ќʆk4%MB*7֛} Jpy'jyn$sf*JQ a!jz1n r@3 &H q@$@3ULiS3ڗ/um_K-ݟXi{ +]+nah2A8t$[en2 BK%.kg(PIӁn*_xEұ W )?uɶCZdJu|^(8fQwGO%bR 2Qe'4)Chv,ě/C( C mbp @"~J%EMHctKTxhxN`dC +Hpٽ QW`Kع~¥ƾj!=fZDKOLY88ntqZ9m-knj^%L_vH) Rv$~_ʗ ׀ޖT@KL_ho/<%XE> f埭[M)b]LnC@ 7"AdžbqXjv|['6i1"qvQK+2˦ +BV +40[ J# 0 .t:ܫ)s Jt1&}ZuIfD*K)ME4>b&/*'☣lX
s.5pu;Y1R[y\{dV\0- 1:MPma~{Mo Y_`V$mɇp ++f]uײc ,"tPYM]Yʬn@y_:ph{]1J`cC!ֽ+J5ʒ{62@+`F;x@ۙ+6"!U@eԲdw +.;m^K:VJev|8{iA=_̣jxD,j)[KeIG67L-L3nޑBr`&SRW>`bnb'ThZq:cJ])(-PtIqn_Ot:DX)pMLF83iVj(oj}"qBL"6(+)V.aDW(h^TIB JډO~bcng#ܔrhT~]j|A({ڭ #Nb*.w2ETͨy<ɳnNbĊNmOVj=w֞9KUu+hjʅ`J⬆yUR@E$V<|nV/•Ϋ\Xu2[O8=@uiɆ}Vjp'RCRFXkﰠ"m%IQ-W("Qa +=G}:bEWa"n#2+5x!Kxfs?r9#:ň*Bʴ~0Ywlazx d<f[k9YV!F 8nq:@BogwT/ovsAK ʣ*mH& T>/FR|0bH{:Wߵry9S"s%/:()uK*dtg-W&=W`}̭r ܦҥ| 8J( ̏$R +$u,u^]yB}jB(b!Tn[} xBz5zX.ϸ* +CNőudY~"A܎[]iGدs:Dwأ &[eͶ@|=>h<;8^W0]ቼ9h(Qm()9 BEut&OCrDp_kF&L/I6S4eDz-+nK;o[)N3)o?Oo7o?7?~W~?wo_ =~'w?t}O_?n7ww?[j~|lS~ x͇WW귿Sο?ovʻ̑#㷿m_\oRq+/u{ko_W_6Ibq"~{!yYb 퇓L9o_$pw rIXZEYu%d;D!KG Zį Qû{^_}! ;=SE#*j|э7q|ظ||~su`HsXq*dyr#d ~ +wGJ?uBqʛ~pRqNtsx`3wD9~FWϗ|X%H )8,*eZ=/'` ^ |WC+C4ƙ 58A8-?=eh pv{jJ4x~'􍞍D<_/b9وN4ӈ[ st:<&3>Ύ+ GZ< +2ʖ?O+h\IiΩ|D4q ĝz En. Fˢq8X7y_ Qx^xb+U9+=#-uij^ +NPO5Ϗw'xyibYqiTUNSW [6^> k|ncw^A=;~f<8Wk'1{`jqĸrN %Kgh1C[ _ @U>0٫zvdU/55daL373Zk;ss;I?}ICco|>b 9<+9 {QU+LDi1֕8o~ξ1()w^A`ިE^k\"ƙOA I:o=!'1 5rN< +HٯUO*P\A1&12\3H=X8i+x)ΉFE[#*M& '8sŁ3h( _7`+3L76s>s\?)zXqa ~W]^}bm6_m{%q8CWϛw(;_w!T4kFعz7tsyi U||^_1c8|e79yL%zs#'qS4"2v(_ +ԝ<'ڮ◰;F8"xHD#hl2cѲohDcobfSkzij'#P_~- j)Y{Uc_?.׻95]9pz/aM4fј>l'YZNWl n9TpǷ &kjmB9mnbcl7;UF9|PhuA#)ϙJ?gs=ƹvD}'%WnV$[h9.7K73iO+4W+rNGNHŧ%z\ֽ\g >}DJ!oaBܾeEh^ y)϶ʟKcȠdg}|%ϔZ(4휠?DdPN^s;>2N$˒["ª +p=k}+ɸ|\@zyظgA)9a;)ۻ:2=zyDL]2,vO(R;A:Cɷ6X4^H_2|1;J j>ypc.o$lONPy邲3crx3{Oc ly/WS (@dڟ/R&V5VFDU+bIgX=x_9Zjفb~LNPW_$lFd/ +˵w<Ӳxv}ˍٜ#yVmą P"n#{yEL5q~yYk[Wl'Z։FLJAԒnrc;  LJ}/ o :^FMgcN4QŤu Z8YryLEWR6"쨈O{u裝v{sWzYcjGXep4SF;\Nl (l|V;.kn,R\h#$(|HgW}G'oyZ)g:kW{[FI)_"N ]9 u-f|6.,ˏ##kq.9/,CS̬S`؞}0jMAK)Ol<)೾ )O}`F㨙.( Y#f>1`?_؅Iگ^Y9аcOQߥl_!+O سc|2Tc\]40Yj%'w;6~4`AP':nZ7's4 oF{k kE.@Qys^9zoyhfSoQŬ}YKɾbFEۈ)NrSvO3hgnH0/|x9@try9g/4ڍ̜j PU8H3 +"w*iiVk.0x^iyȭ-?+<IW ֿ udew]q[/йfc;1o}v6%>69dN(<V{'n7{?gsԅGE˷<$fGg3}Ŵg@9끷wqs20%{w ެZb09cV-.(?tVghgKT!l}i9`PxR,w*;:+#y fF+y#X NNsͧp+Ϲ9|Z<\$UN4A +E!jYES̩2} |FvL4=b :Hrn<]½+u/ZS0YFZDQ$i8MMjq_Q}QO3S O ߍQB30\R n(23 W9\!ٕ-͑''Fz]}9^տSA6'"#|2EĉM Oj'gE*S/AK$ s-u]gA3O\IchHzWc@X,, u?_1\jL +I뙪{}q%ڕtu2 d}ؕ29ۙ E=\{բmmfX=AC_jG^W~r'/F=MOLyb1Ȭ+skM*CaO姜p9}(g5WR͚+Y65nq"QQ x61Ո|JN=*U3{]~K&֥ḽTc04#y۽1+* f>r\×8՜F>RǞC^{ԨOw{yaRȑ?@9hZjvqW't[w#ժ'rC7.~k;f6g:A ΓBVoD=d:6sF98"%D.p?D\ +]Ɖ#e[3.C|I:Ʈ+{*h泍ƽQ8th;״6E|PYON䏽ڕC~y+ZY]m4WΗyϼvzwkƔ됕ƉhȀI 2xGh\'i9UvrOj^4]zw8uZyH}hHa_sU6aq'+\'x?^l_'ONWlɵ5#XrB9ih~h;Nq1HcɞP^+dv6$m}ngD~W"l/0'Oczʅ|$5?4+! :)I,#",s=n\+aW,ܫHcgOeZ>=PD5j)ܠOԺѳא~=TCKz +}y·8A + P܋EΠo=_ש-@ +ٶg˙ IS,9U;(OkYN)2w,lA9ܘ;1NPj\s'fAcs̼HuhM:9oL)A=._g}sIm3K$lLSBi<2=|&~>|6TI_˾9U3D3xwBA8T!c 8HrYgx'ȒCwhl9fkJn+?8T!dt G'xmLJ߄un5+$I.! JN|sإ;'י<",d*?nwוdW䥮@IY=SW*~V3U*V ^~™2E. '*]#V+N0F6gV&g Ȱd]\tN%#2ΚJ~I +/bH렽ƻhH o 'ȓH}}MۜąF` rRdJ4bCWT8 n|YpvE/p, GCu͚[Yя9Uצy]OQPߣ,_29I9=iNk Npbe r"^'Z/vئ Q, +\g'H(t'yo +/z_ +A{LXQ'xr^{E?6f}*nqZJ^؍xa  |r'YVߣ3G}#>gBIh*}۩(KK!U5qGWő4o{.FrqEF].~nwg=@ٞ߯@RZjU,|UBL^:xU[qH__xc9id"dMBF)F}=*A@?(Sc- "*S}U5jQI25ā*&f"kRn,lӇb6P0fj`>@(5 * +~Wf*Oz@fߧ +O IH _7pZpZh) G_JW7NЫfd~:8;X;L4d2+ +LK^„_VPL;XU$Fը)bս 4M=8D|XK*v fP( J&0cUQdkZDb*fPPGG |jQTi5UL#`HhBBx*2x_}ʄ #U23o /w"/f&%sՍYCxS58F(Xg*KU6 (lõTTW . n6|@M2vBTLQ4zv +TW9a&bh( +3&S/㭎Û75$DfVi FJeB 蘚è5jd-Jn͸QFFRME]Z +ex U9 J +h'PUɍLj,rtu5Hkh F 5h5D苾T%-S3S5k`5ve*mIlR9Iwv3hоf q/՗]ƒT`WyMՁpLP_k*bGa]8AZ6iz&Qo&̔ %UFPGIQo ʽp/!/S5LT(' e* 2T2S~Ѓ$Tc\Bi +EhJ ! +,[+z.*k[Ruؾ-̭>T:a+YpH d + F}K-?=q]jR`5)tF33C͔n ʣ(XQjl,\+SF_ƚ1|Ш+o'eve`"RTsvezFaߪۨ:0cpMf+L]E>*؎u[eb(rYF!,E3]δj/Q|#Fd⪌j8b)^UVt1& +jjbҗo~0R\Hc.M|^hNdF8\}3HbY$j P4ZC3bQ1M57>AmJE$K4ePUK#-S5 +)@ß;Дǀfqqje :T[̠Q8}@]P[MkMRoi nXP*Ə؁NDk w"a,kjG*pPz}}B.<+B,RS+ XLjNJdh;1D(Ǘd*K' Ȍ 4Lq1*:h" w6C#Z31L_(R(3!V4GakM,gXtԆ7Im F]4&}MT oZ*dh,V."JPLT¬oTfFMe7 獪53AOV6*qҾB؀f 2Uh43KUs5jeB'hD.Dt|h:MdgUzP^ #ԵXEoYZHKM?TqbJkuڨSO#@su)]h4ƌBH 8!.ŝWxUeGv&}Pc!j U_j"W׫˪kM]KbyOo(ȝ-7Ԝڢbth>(T!IOJbj;)5]"WL 5S#"p@?fX .;\bR"4DEjMJMl c.13c?(ri&⻙諪Iy$lH•BBJ +܁N-y{+5ybۯn4EɮrPTO`/^+s0 J=Vb5Չ:xMZ ◉F7c1rPW[6S: oX_fj`*l+>0եLUUDui,V3PRj7i XD#7r,W>| Raȵ,TIdLF#S#qbwQ_R3d* D:|o)DC0cB'QK)˚bmj3[%VxR>e8S h6GHŚ3&j+5*1U:OۧvPTb,͚R6ҭZ柺$n,VѓKY}Xoa VF+fm45F3 /lV'^.>mЁz}^A]3FA=/uiH]D@1QCՈC+5\Z_VZȋثQ,m R4QR?UVjd"tWMl&aϫ:Eoz.nvt.`7XdY曑H5JHSoÍFu<ʸQ@¾zu+3ygbZB9f1TepU+F?dMs\eo&d )ԁ!k5447)LS/>O* S;5vS_7WhYlgNJ/U 妿cx۟NqfuNJFO EDXEu^'`pLR'j֔YA]*0B G,, +<";U.'UE6U vڤ9鏵܄󐄍,Z5xZLфXPXRG j*U,Uo&$jND|CaCDn \PPal"f5RO}Q2SUVH':kՇbu }\cm]5 +%!j%mi ͌LjPa:UQ)̇E<̇e=Cn!/Nf="1Ssfl #>&w\C#١Cў9ĺ|JpoyIJa>4k,=$ W8 +G_]Uu&u/$)$3SIL`p9\\d>~;L#2#A oOIΆ"NŇN3,ds.C3^1C( \B4.n2KmÅgRG2ICA6lJtS7TtLD6(g48ԆGsrFπ9a<'S^a||t:(m$2 "y#XǚՖ3h.uc͸kmHl$Vr~r61p +AkޡB)fnZ:cC.:H X*Y.~{ :x 0Ȇ׆{ t@#~=Ϗ{  o!OhSaY!rWۆCzGuO…Gs^QC8A|h8exx!?ޟLGg2e3Q"yC3Cr){6d҉LK|b4>,{5RLlh^?L`t(< Cxx&8k4%.yL6"&g,^MjB}M<sSo*b&n*?dEr6 bz,:R>}6U?U4k%%?2à6HmzXX+7{g S}*}j+l 8 ]P~֤}? Q6P{@-l s曁8@GuH~}S1ѥQ4W)TNoNg˦dž#uiKa\oPxɇ5;t I e.y6K3@+v9F1ly „qS<#܃׆,D:*b?7`;C>x"p\Xx.,c < 6dtHf.:Pt$0lXh>aX +K&$k4 tUJ .f<'-Q6䐏>I3l<:s<:TytT$:at&\ǦM7MerF.YHɒ3\ڮ9l$h,|O#4*@IkDMlzM2d68g4M8L=t@eLZcHn"dz>IHH`l(7Ⱦh33\zC]؆~ Yy݌*8,$r.`Dz>tTo«FWp klxx6bR6éȢq Z\ropЩ; Lm& 4-n9Dt% +,۾Y#[nV5_r}lꯋ)؏ +2WLyt@2yX:c{&ml*B:}]9.@EŠR_Dd;ZRzjɃ1_0kXk`R!'S"10; , +X_dc0yc{V`>D4{_)j{& +N,b맂|bܨ:p5!'٭ Gxv`~ |LȾ0ȾƘ2<]48,p CCg<oa{]DdCXSl]7l-35&rM9ÄeϠa;gC::q{)hgH!{G9"WIe~ڂ dž}J#K!΁lցSXc=$t@H'g6(kq®³=iCܑMG\` 6X_`P$YhS|H{(}u~:dP;Zrh- ^n!l ;iac |ֶ qjӮhm{Oݢ2ap6q$4GRw&k{ ^_b'*:ޙwcM33* ]_qr'+Gw!K4 Aa|`b|8|(KW nQ6U0oP't0O."} &8i; +k#ԟDؔʇ l3E1g#^<Zd}=Ekn]pt)5A=裢sFT'Vǫ)7!Q!y#51鉮] ~!kCGb\]x`&03pt $w`Xk XǢ߇.lXQ. j{!UKN;kqAoHCκjä[=Il΄Gki=t@ +qK[O#NAQHv"#yn#c,Z atC:;a\`hFށl4hXW%OK蒳23"KlQ}Q|ˈ)x "\){ߑQi#?a +ߨǃ[=)jMb>Cx yH@-:Xe,멣illyLk!7G .p_%!Y ̧V`3[璥eĶ'+_  Μx[KE PE `'^%+ЅʉIȁlv=Y&yS?Sac ftL}* +4F]*=)Ej>K_0I0>F6B:슱| 7U|)wO`s"2v$)L ~-? :0 ||#AF"=9L^1OF>it%ljLN7(K!1 +THH KttRt̟wcK6=& 0_`' Ɇ˩Tb4Ld$举2yc:u *8o4l^9)z;+ooҋ&>sK£K ii$Z-/a$ox53 |v&wuTX805ȒLjt. *sɂSK# s;Q1֔2 +|z`l |X/$H߂L8<%bĄmj55Wt%ws d81[2(=O~=HIYGN"w@;$qNG!?9Ħ8$\ph> +|b y> {4x%N~p} A5_ | hL2wys ?tM陜#@'UWLR9AF?P >'KD%cEM3*\7w84]ވ{';$\Z,)x%ٔ'M Et:W}w%[`vh>` #r5kT1]?SemD3Ll|-Ͼ:`%S3b=К A)<&q I( 5Im_%T ܣ 1oC\>;{2'>"_ -a.tXT|K,ɣp| #ȉm\\_G82;|3Y;1iۿ~&oga[2T fd9sGŝa} _Hڄg|0_Ll0:'!y`r/fvʧaΤψ:O0Uxl)Y~Έ,8|\ Rc+'CLIBeźԽhY0b{`bgI x 1)&6;>OR l~:{c,8z߈!v ~5OLL؁^ c5+U~g3Ph٦3y^;VՈc>Wgl9omVwF^uۘLc{2NM ؆-8O_6o/~ :'tq)Dٔz=L\C+#,{B؇>PgzOP+*ܴ@r z0`AG <(u!@;!ǻsgC HwqH^<]trF-z.zlR46񈬝HbKd L`XqQV[BܓFv֓cp{^O؇W5N=>@8b; I ̡7LNA,֥;F@\ o8X3*=aHY^CσG*=pż-4u4Z2j ۏx%'2W )g Cy) ݔcI稁ce Nɻ#E|Im3!V\@V^7%ko|M]FU}rf[0!oyRS_c ^(>o37 ;s#~gZm  x).J8?1 wćN6א"Sn9O`.!=m-r~re6CF|ŏ9&%̰ΛJ!Gy(rH9 &'s8ँr +JAl)? O~9'=Jyk@)|o9> p!UBe~s >|=릵~)YFoK6n$kqC<,riH3IGDv{C쳏ΟI5zG=L5[+ 1e鍳;G6gdˋdRtX't91"nQ5 J>ZT\TRC;)53 kHPhIm}FP.h.vn뮅.Ą'n~MW\1>@`Q6K7j|ڜhl/dۋDӣ"| H_yE〗:_>?qΡytCI>,.cOQx!CF#A>97uk,$+VlXg%q<p'poQxhh8aָ|"!|Aiĥݹƛ 26{W1x[z۳ duTE 3 +fy \|蚩\%L\`(٠D@ š|tdr7_P[=uqK@Er,U XuV5cϛ(`>B)\jLC+OS{,a~){/ko.o[3 wVgA7PswArB [3DWl :tZ,1aI#s !k/=g4. `lSgStʈڷ`va+0uwVэ7W,`6~ +wDE}*2"ͧ +PY @ +]yr@Α2r<9r:Ta*(8}G|02G5=xG|+|uڷ*Ύww_n >{/j*=|tx(:o|jWfLM:6I,9 ekolg?o +:j^G^1fZ3}U: 0q<)T!.Dpn#B +y㍯ĶD@H2t,yz`:|^\RtS1U~l  Oe +醻+54v UxZJ?(>42O,cVT\1_-֤l*Ϡn: y p#Kت٦udErGbq$vo'ax7+`-gPaa5/8p@H*jϛMW#%c(>:'yfGT]2!PrGW0av^IiCLRfr.B'"R1 l>Z`' `b l6>_Ŝ6uU{}Www-[w5>_trfgZ?"aP V(k GHn[rw!.:i@\@r1tT,0 A.@7Zzٻ2uS3.0dD8 ]1ȖbumdVߓqт|X} 4s7DϤ=%+pΑAx C3'z2+jҩ\֮K2˜du[9<[sB!`c͝g$aW8>Y$S{@J\V8Upt1ؤzm3K)jn{fe ')KW^2񟄚i%nFdb@D9ς|#0هQ53w/9}v&^ʹ̤kو3)zp@kQ Y1>8H?1! 1?%}c3t mi1Z>D`0Kfm Flaq*bts%\ܽN;0 M gF8[k6-p,~Wx @vAo@TxwU;šg7GS|/BmA~Y1x*RۧI +|=[fL9FkocgĊ w&jnن/XĤ_8/4 ,hD 4csGn8W|ΤFMfGs%Wl.Fp?bS s;cۏGw!{ +u~4*G|K6>3Vx VW@.OP:q*UxސekAax ұ!7pE叧c&A^ +]p@5egK&DnƴfC'>/[Qi3Z{YpÌi}l}{ cKȊD2= qTďͦlyh!]tl)6=YEzdIh yw!ܽuCh~hz*!q9Te)Z6HlzmLu| 8< q)פxJ\CqwdۗdyG81Gn=:iL*|E9/`񊠢QDtD2atEMbw[lvF~[~%J}O;>oT}^M~XC{eÝvxMQ-ѕWM~ ƌޏd}NӍ];٭ͷM7٪+@ʘZ<+{߀?# 7HM0D؞n{jj~jx&!ko\s2ySwʛ/M'l g9ٶ[@θ̽ /z ~ҩgE'׍-W+l{hԳR[xF+j~rrM4=[#7k#:\a;y͓Ne</NPP^A:mrv7{ˎ>" +oWLZF}I:=;;d '++SW̸;Ozk9Uu+6jxR^zYlYf{讣{Nd/kɂKlʑyl%pL+E`)?A1PCo'C%zCsHƷM%wLWiYPˉsK'/,[mn:O~b^?O!/S޾aμu&O|`S9CO^9([:5|Tcj{y% +N.,Xm@Oײ'WKGO Hm:)Y`3$oA#})MyЧmeO>pa>ufw=#k_[^.w?>(4,~BdE`ExF_?hwZ{Zyo^@ sT ck'eڟlnQ${0TKZ{9>eP4?_h}fw=6+Dɂ>4qOƕ=r+でs;ֳ>#_6ˏEq'>E~g~aOw~lw7ஒѳj{.>oxknzF`kvtU[t9!j{Rm_k[[%˷?!Iǜm{n}mNg}(OgK^3 y59|zM+5ͬuY^UXwzW(~.eg0ݧ$ݯ ko?S}xǾ~|0RקgkwS8r䏿leοv=P{x+w0C|zinP=VpW^n{J뗒߈tzY*߮F";Go{aBc.jTyuk:o>_>e>?Ϣ|~E..p3I{OOsy[i/Ͻwy~R\Yw6yEO_ǏNV*?,v];G:w=b~b= otu\Hcrs/_n>DxNjpÏx<[W_dm]ihX"sa>LUU|Q`dpr'#mn͍SY~g7(LsGcYR1FhcO?r=w;Xy'#[}RqM{^xÝ}͝x~Aq͊c)dsO;ww3_])q~ɮ:חޝd?Ieov??{۽\lӽ=A몃Ww5Ty_F`Noo l~n]CGBU&t@WK6?̨(~XWSNl z߲Y9׳rd>X M2yu='/^w}wXl>ӿLY߳gGWŽ,O7wMq-.Zn>ۻ֢rثOVl9Mu7un\K%&pzяYnOW;>;Qp]PwȮҪ{eKގ/?›]!W:".މ,Vp^XMwËn܈*>z3fBY*G͕(`?tf;:Qx_~6'zkCՆ:edI5J27_o󘗏Sϓ Ϸ oe)({{z2?m+ K;rf4mw|y{%JW]^\RYp/`GtEVx < SQ%GкkPVByԻ9-n2E7]rGor.ݸdJk%.?yUwn9w+l)9w6?RʜOs&?NeĠF'{^A|ݻk%/ _)._Uy?q[zAۋ5IݹǗ.ρ%ߣy:w+쵸Sb܈-\lgq;Uy#ԋq?(}/ +F4$Y*nVwV_K̹]G|ocuW+Oy2kVl\ W}}ᝌzwlćq/nw7?۫kSAG{y;}mq~y~t;}+0~a+|ݍ,s/dQ%W5=py}u^7we[oqvOtTͨTz%,nYÆ2=7^*tϻr'Y=9C2&Z*=STY?©_;\^+wxwYUGH}p>ލ[~m>1}Kxh[ n%޾x+^b󫽥V vӛ^n^~^}/c/V HHQsǽܦ{]뉰ב`]̽Ʋu"ws]g샻 GZ:J"VT~r\IjOW).vx}ՑYMuO*J#_a^w!yJ=UURd2{W?E/~J>m*1 zWX͛n^kXz3īdNȎ]/bݞIWwR|%G.%ￜPzr\鶫N/}wk֝쪓WcK/\.jG:!y +u+qoA./o[y;ģ#"Sn岿{hRo<ݻ|Ktuګ$+%F_}'16[)14^!7VxDBLoMԉQk{k,*v.|Ϗeʫg7_L.-SOW[M;ŮOT!\TSx3rjն;nR8ϦGkFwz-}ݣ[Fn=8~cU=?o8?2c_W>M2Kod/%zgw'&"*$>#п&HJIfѓ,5|gW<5]gso_e3]שg9nVuV\N-k\RR)ҋeSʿ[ː>.=})Njq7J,/Zʷ |X埽/V%8[.W$sI-'Yc淋!exֱk"gOד Jt轴$Z렖i㶡iK YD wWJV.+YZq!jZYmSʶ_H.;x>̅ңK!ZŗWvfTqݜO3Ny\QCOB ++*ֿ򭭻dޤyHGgJ ''ZmJaF%LHD(Y1{crxⅸIeWː)>{%(N^)A6_-9p5ZJӶ29?b;ĕXkuSn a ~ a"~m_?v}߻n0oZ ,z2n͞[>/ޤ*sx|Ϊ{EmޓD%"( Q9CUb2DI3JT$&0ۆVYQn[y}κsLsyyS#59b1l ⦳ȸ/=q1W]įJX/B 1 }9~E߯وh4# ,;E+sV4<_|b~ -'|bA峅.4nVP0T۲yƦCӰo0sI㜰ؽss꣈ wmN\ b?aK?AZP_s)F4A^u%ν _4n9[sڎa6BV;bď?߃gM.B(2{=\u3\'?MpeÄ=/nq)!GW=\F޶r]otRAӶMUJ4̭/O?:t~Smo$9Qhtᔊ*:V"#y3 [\,vba//}!v}#< +jq|ohSAw=kiL~.g6ѰB8`dcDd5Ҝ 5ll4 \Wr(^yKo6+ +p&cOa_ٍw`zzvóip͙!£i|hel+?SGNEc qd 2̌!Syt\d7>=3g4eA8rڭ6 ؊^ ёOTQ %p{qŒ_]+y{xǷ +~n;s;r-,? O2ײFFQx!n}D4FLt쐩4vds?sPd#BYEcWvJ4}IVL?sEd [ c \!ye眩D(0aY,m2['I.9hj@%t'vJ}Y5(g^OKԵr]]8ܦ8 ^iz9vNˡ ׻_Y/ =D*S sd= 8l8bL}<2ױ\7푥J4q2lƠi+45M\7 VRmW_ZbIa轰}9w [8%]ϗ]5[럴^u£[YdR2T r,$8ziXg} 2לDlcmf&z6Do1z&23Yۅ 9hX4eEP&T!V&>ptI½͵.n:W yunf}7evݺy>7)v d8)C 0՘G%cenmv8aMb, q|2&:9XX屁c`jHX<$8-6Iu˚l9sill~vۇ]?<|s'P%5x?D6Kq\p?YOpFy8!WBfc}&gxX,ǭDVNhdΠ {#FsWS_Pxkg' {rIXZ~xxigjn_(z)&//#K(ՋWBMaƫ&m:$;/K,'Q%SGhC:C&O\4y qKpN)Bf3h<9朄T9L+_ƂWK>9V~-|"Eow%Qo{9#qOvy~Skm!^oPsֆ-2jۯ7z~ks&c@bhdNGA_jYd!36aAg";ϵȖ@#4ʯh/ȹi'5ZTzKwQ3E\8!a}S33a {) +zr88wλEĈ = ާ<}GU|]1>cDwdn+F]֢9T)MZ0fC}ժ3x|\K-zh8z\y%W5-ۣ"pes疟ƻ/B׏)܏W|WM+Ƨ-Wmÿo_>[ʏ!?V:q/Zqyw +*:)4L5!0ӌGN¹4Z& +F6hG^ќh=vGhb-Ԗ$tU]qWpy(BɍjVʤ?.L믳}^+ +bM !'9&w_U1>KnJٝ_p߼(.chpÖ⡚fΏ&[/R6{yDo +\. D <UhYlҺkF. 3=~$b:eOd!iz߅5"/'!uk!ثx߸zmK0qޞB }~˽mQ&?`G1Zh[E;XF06Mƾ@(& d~#Ċn \iKN\|J^:ݷtK!o֒m?x1-7SgSg3ʏ]S(o] +yt?Mэr`/e=eCRU-t_1i ':z4@56_&$:+*9mף>vNjOdn$D梄՚uEy%~Ml +>'%ܓC%r)Ԟ_e5L-7rŹqܙag?ٝʕ;P'u&M_I?8f̞+CK +53N $B +1??,þ{C'Ox|x䭗ɵw?m +{ChH}v~7Ƿ炓j4z_|R 7b" J !JAt@?ۊisTեd ی'I$FktR qmB4AԜތs>-v}$u"o*B>{̃w#sSW?+<)R>}PP:|}RJY%)n6WVa}в =爐{dmc i\]WKTGR/$Ԯoܨ֛&&76SMvl 4a+훈'0[jX p~^|_?G-o`*E`Q1a+v~0irbc8
 s0^qQd;?':&G K-Y;ڃzfU)}^~ionsv?З>F0ަ=Un/XzջcFx^pkOv'm۟-~\":"20hr'4zZ`id^(4~n䆜1eO,̕ъlHG#dٕTi'"GasVFo+ іhɢHע]xJJn̓T*8t;J qoy7Ln (aR`UQ{QҚ33̞tJ 9cdWxz#++)!2U:Sf)m4_zqtE{mQ;ߺG^r_d_IlASyޚ竂n^S^^;UPYz>Exl:c2Tc2 +1F&#q=Py"wiS[~y*93'Kn6r[ĒDz4ʿ*OHhYh̅(+4Sr#sMBVe֌;//}GԱ$ݯWzf+쫕Cr;zI:ͩ,&~2f?jshd7a-`ץ~{m^(< g':#m>eퟐ퉖Μ\(lR>hhG"dMlv%-]})̩4g +1˨+L^d!þPyvlӥo[#S'+.}k2gKҽuƲ/mŗ ȋO =O'L=:#ya;! Ia̼|?>'wtrY 3u=/b禎lmXBГ.yJ6^4vC}40d۟9GUJ'o22635GgBqpOD/nEɏ=Q*> va_u~{>$KCґrrYң?^sЀWB7B͏jZ%Bb% +PiHRG +WDNi=\6̢=<r"Ua!I=SBg@opxq_Z~kWYN]c;'YTj4J_7'g졷 uٰM{'SelŇ~u Ӫy4(e +(;e&Ӂ/ZLd5KT[bb;z@KOZnZTkog#=f|i +Sk%aZ4M1FϿhG蔊Ѳ]8ü @3tDMUJ担|3$뽻 4 T*o\LnXo"zA}퓝/w `l:=9X.'u?]}h:]kJ嵎dw(zm(}*M݃WUdju?q,XyU<u\ uru\}EDX$ V1vhyD/RCR&kguOyl(Lqz~,ӌj2_]r`2ĊXu +۪PšJzp s^+:c q` +hR=Oq qdI>+iVYB/rcӨ`TW*]Aa>"%S5t#Gf:}]L2jgj3WOa;dzi[L#zCy$;^L{b|Ͼ .|E{/Ճ>^.W*Dϟ QՀ-zSݾR1ÜywBOim>2?G~,DoЖ٠VHӖk:\HxlTr!' TX'*Rʌ 3*:C KRu@+,V|`}Hӫ}=AאI2⳷3}]'E]=U}Ӄ̎Ѓ4w``zg15g8AS"$ZH.-//du-ù펽oi+$UjeTe^de6nD5.bd>{!eν +a/OfpLtv[IctDt߃A61 >,2 /k;>:4dOOI;AԲJ +I;IO%d :L]]@7:8*lJ3SD БsʨtUAdmph=6bNL>^twbw?>Wj- ҽO{KO%o%~pOc䗞O?]}-~neՏjϔMzOQ uFTj1~*񚽬T:BZvd,99̱G+p<%8HUDd'dbSGf*K7ٺCv̮<|jh.1S/nOeC7t7VKfC)Wr` +6̭lf9I6łhl`ŋvLds[,dF:!SN(#z;ے)[5ρ>|ШԆ>i*૾C'Rj Lq0_߹Jvqv}pu?[m<0 A{ +k=D kXS<]/CeJt{gf@w↬B;j޲  XW7Ug<[9~o)􏃞?hGJxiPڀ +B*h' #.b4o2hSrE}4MKcGJkJ5A94U3/}މ=Jq]Z(}GG|cpl֋>Mw L땪W>™tc9\&i,޷~ЋKWoI,Rƅ7Q=dGR!pfk}Y{1FdV& f)\%AS/]&4 +t4h{Hwum3/hu2C&˒)q,LVٔj4q}وIb̬5 %4n*Jw^:W5jpzb./@cM).̾OÏܾR@3NP^[s @{ 4GOie0g@ÌLR>Wny [ @l`AHA]&U[;.qr_yDhE&81z}B&@!6Z _ +MW:$IdXӆhǍ|YD+t|S㧓C߈{= +<ܑңD˛C^^^9*QB_>d _̑D톃/K֔tu峖 o\kGLP&k° ClX6hO jFb@+ +%ϦךkRF@V~v[zF <ХM%B sGxǏL!аgpNY<6$P[,xMm4@j}hi|.zluŞ/ϯ8Ezо!ц?樬=rg Ч5<2!ؗ`Rp|$U*: j?Yr?tIӴD o\zq.sHy4oe!j Ӡ_ +tXRCi5LAnH?M '{^'^ѧdGtq͆&js@ Ult6ԱWf00W_q4𺁯Aw\wd{Bnl :媓wbh qw]Al}Y-Gsms{9cLb!꾸 UVvIOO!]1H18YzǁIPu& Y\b^hcȵ_Z8o|.5`lեlUԘ\r0(Z*&@Yyh6hm*vߓлd֕Bc5 tdYdwaXԙh1F1<+U/:Vp``- ؝_{)7lv86ے5_=w_z*)1]W Q^mL-Cу oYLbk7(D/'SzdSsTlي3'#NNQ\-ѕ==|i.X`}: +w`{_yc*poNXhD&hA\$ܬUFJw0ҁyHW8MYߗkY7cHW lY!ccA[Pl є M戦m>T޴k +H- n̨cK h甠1To|4ĵr#/714.?l<x$zvgq&, g(udpR%CG\iUBXmkl +†'}@lv̍16N]m X6Ԍ|Z^=Edt'|m`gU; wqwv['y \:+(T eVms k18FDKGQk4D" -P6xuAYm K8+{"ȑ^sb=>zXچ,0AwA;ЬhAgx80>T1yR$d }a}Kv +E3I.0C4YcEJ`gEdTewMמWLSxFtnWf8P̬02 +YqG=?? +4lieFM}ӂ:}B uSy*?ux! ME4mX0[_c 1YTVGh sqGoЖ2ja;$uţ=HbLtx& D(yes.!?w/Βr +5Ov$X#( +Pw /#Q:ty|dH&|q+lB{»זk>OVh8 |N^&aMdv7V +Z\J1_f\]gIa PՃ}#U; [7׊YiIXN8f; { R`gAbgV YK?Y,c5!Rj)0wA_r – gB; z~>񊒮ɠM}k4_<Tg< tLXLcvw}+Y`<NX`Zo1m Dz x$#r$"ՠv>0rI> P A*JCYi*6 8P)ĝv@Xe=)7Wwv!恝{% u`g16`+W(R +GŦGOf8~ do +0F΁k>kz3U^50*[}ȩ@ 7uLf!FB;96η]T9 1yzAYeu[s_.\Lvr"=ӨŶt$쬜V`gi\T$sy;@7&,%𓁝U8R;+eATr^`m}oo@N,0ejV uFՀK9"`jdXx<='^? Bv൯2RQH~$-G#wB զ7x]X4f 6 zlt*[-mKJy'ŵ ^Kߊԙ̏@#=6]GOvV:*7G^{^\6Z* QmW̬3;{JPr![z ,|}:2g$*M.; ֗9@J*) +X^fm;K^l`WsaqX7QwZ 9'ܘvk]rqUtp"wb9':pbuH\R!BJ!a=KAStL 15م5O\4X/am}ChK`mVwJۈPT+ǵ*0p`}s)\m<̡1ԭ'ya ׄ}' `F!ly|㥥+}`8?sm[&Ģi|-'OܯS u.]5_W6 +Ø0 ٺp_r>r}1Nb7=\\nxвfȚXϪY֋ /Y|K FV󕹭V$~-3ͧZ|eݓI5_k"µ{.ɥF\\ïߖt݃+mjp>8>GbDi5fb="ԉjpEj#k+K'$!Vhr!iڰX[`TEL2”s[LX2j q=( 6D0uc4KW:]PyVKvNToÂeB.6O0€$:0 g{|F}䥇aMD^;Y-Q l2U^90@oqh E%,6n>Ol3 ͇gÚ#Аk$YO;?m!u] +,2C[s|6 XiYx";s8S- c]Qfu{&=Z8UsֳƖrgHB֬gk6\){  SxոﹻJ.Mڗt=vp]Qy|77Orc'\T +dnz3"ENK|o +{ݸܑHzQQg&UQgpNM}bhu,R$1c8/"X)T#,O{mo"`S9Z֢بX-`m|>lCfst(ZM(=ty鄏B}"p`mz3pϊ0a LEVwYpnIѮiXz +&5{9\RÆ&iS}=ޗDl25>:kRqt4-HZu`/ oxj!+ze߅ͤ1XĤ}3C.%O/6"yJv8eQ5';zvxb.\C=/ǩ0Up\!>L' 8o?=[ϖ9[B>!y(57=cw> n/g-a^OžG =Y[ g%>% q֮ >ܛЀb,>{2`-8El:-$h4*pNpo\sZ9a{iMyϑWkprFyR!ab 97eityŰ>#/ߟ .n `rtį+}I9`r0?X[l u6d˫=hVd Q/',.zjUl|vw +ɝ]St-rplgyߪ|TEA%Wpl>y}%p3a"nDzTx}r&C^%1Ϛ޲ϖH^ZL5_^T66Kl\|{H +vOWHo2VX8媶c$M3ue*dLσk|iJ)y4&Pu< rf bL^9Y +'A<-aϖnifP;˨73 ~Ŝ6V@[XPnBXM>p^a0ǹ-LJO#+`:;cT| +"A\-d꿜9!b>O~(aʌȽRM?1i8߆m,:+tP'66EW] B/ڂRuL qas6uM&vZӆ|r]u|Vo +97~alE%j'\Jg_p_s53Qq`L(3$csOǧt|:>Oǧt|:>Oǧt|:>Oǧt|:>Oǧt|:>SBC X/ދגuIS:'%E%G'ć$[;·X?/$=")h^} eֶ'ΰuޜs%!ֶ/jl-JߔF 20-,~jqH2~J7]"sӷmpk]kmE3 Y; +D[#td Vyr A?T!CkmMw7?DRe4-(Tk4@K'@]WcVǟG."!||(.yW/cԁJƿ +Zj}4A)2QLVSחʩ(Ϭ52|=Ӷ*Y*AAZe +zD+쇋MաSk)񊆳K'9;.>MzIa8h6B6@L0 4(uZg2tPEt&cru٤}Te7a>PC4-KVmf2iOGkk@CBm#zfɫQ6q9zlB.9z37[Ht/.[C_$3=-ԗ*X`{ ؞w2h3>\|.](6VwL֤֗$)GǍEjqY]\\Pp>I<ߔ)>QCL֤C¯QQ/;Qk T<Ĕ +~+?esF@?W~:b*\-R#K3 +t$ s=|=Й z{AIlLHb="QC~4(AS@Oe2XIׁVUF7em&gx|t kI4U$C/#KC)a,_}b.NBo7uM {DYV=3Db4ep0gB scd>vej’~fU)>zHR#bo/+S*MeF<sZDg "'A %c-zOd<~>ItXLD, YAGiB/Hpu&b6:AlNӂa[sE +{%SL@tz@CC\m :nRĪˡ'*_ +^ zDW^+}!EL.h.ȓFoRvM8*ʺl'm2G=-gPUsl :'*J +4**ߤظ|2u1hkZ -u#Ub|]^;tEh#@i ,Ķ}Чђ#m=dԙF%sWMzx..G)gN6+xm#Vv-sAS@YY{2 +2=S|b!ѓz]WbHbzz9&_ G|*A$[Mtב た}p=@O]ʪԀF㸰&GjdM.4Ct@c~RDCNa z + +ob>n˦A/5s*"M/-+nӡöDG.,Yþ9yh:o6~x 誱DI6xq‰@lqzwGXs¼ĞAk 3ȅ@f S7v0D%qfDi}hEJ S¶>$l3g>Pv=2cea$Ea5H<_a^n%¼=9чh5C#-l=lA4؊ö Z"gMmﱂUҏm (@4\5Ұ/ۗ ~ДekoWնOs 4fD100PE7 +bآHw#9g;p{{~~b˜s}c>umh- -]'8΢0k0k&Ff(.<} ;>4(hs)S^*]=Kc)Et[@n Z:&:U?y{"k7yÆ̞ h"XcZsW/~^rA9lEӄo,a l!f& c>qJ 4 @' +h3g.O`R|PIQ6{DC8@ /A8mt Ԭ11&%w6?d5C|9p5hB5nM-P`h@YT_@Ƙ2 +{`dV *жx&fpFqAӁު瓷~ե6Ocq|)EБf_:6hnxtIQ/+1{:, +_%>j +Z1Tоחc?O0p, ŶA +!FY/{-`/~S$b|.#n[ը_dlˍ(f7t阒TJ^ +]Is!p%#+&ԩjԄ 媠2K\X 40.{bej e@\:+S~Ih"?({9^ ʟf#ӁFhV[ -&C^=aЁ]xgccg}&9HsWNbC O" w}2`=rmH/FM\SCg@-/ ߀^aMx(O`|S.sqOzH>W~DQˀvz}VKAxu5޸ +TCE<97Z=fND~e;G AA Z#rg +WAW[Ș?~uõ'M X 럻NDUng2~(D@&EF|!Zq< Qqx/#c`MHۏ~ \ze.=BnGF7Ħx?=&ȧ R*G4t`͝FӦNx.x*-}4(?)1C:͐?R+^/So:? b]!>8քt'Z +̛ iZM=|koN/ Y 9-ƄZvL!u =>a\e어~|j{hPӠw-:ksi%QM]4OD539T}:5y@+kTטpTb^oev Ʒ0f+ޖ+2wH=*,М?i;r|+ }^䞤$vMx"j +_>G/71W"DcކhX-I/:OΆ_ Is0_4Gcb蹘">hlq+s1yBk˱^DaJ(Pxdvj =?99"KyJ|V~HKq`n9guT`%п~P<X!va:h9b=D < fC:)1WCsu^k\}o.52b 뒥Do19ȯb4%GIנۏZf- ~*G endstream endobj 27 0 obj <>stream +A<(wQnPaE~)m[1ᝤO ?.?`ln/ G ➠ +ixq[;\w>hA_qܝyWɔ.:C{&QW:|u"E#=Iw zc >75,wcZ௨fB|(x< p^пuB3ZМ1a,A{LhӄEGGKkܟAxu2<5t!!>ycr&iDz(N:ZkAzX| +Ό|"F1J". .N)d Qmýwxr8l\Mo!9!fzLX8?Z=&n~y)[D5%1s$ +pK#%spŐX\xd,\Fo(xB( F zFJ/xU\W,* +:mt%~+5<&1QWѥ-l55+*ŰCu%8j=<>/ :q2SV:wT˄!7W Þm^q0T;a脢 +56TN)S3^nDyk)P ++\\YJ=[sa]_ +csX W1لJ-J|z^Y9)_|)DejMx?فoϵ^U2` xxLmqzH@r9m$ g4p@l6qTCoEW.)3QwVJҗ@UuhOH6({sFOIxBh)d TkI۱'$xpGm}оW0|1g UuQ2qS7(J*xL96h}"}u.x2x3Wb iG\]=/{|111!= +>Xa)J TQg+UuORTa|' +?|'/S!-r q5rQj&Z^XK4#nPO^<:Q@eAK&%|.p2Ή@NmQxFxP{.+P}Gu^|axZX.9b}eX;eE!h3宒d,5! (a}%g'^Q1"ģ/<{7ǹx!!vY?W4 '^1hre_k􄄱%3K6)xck:ڄv2JNnPf# +|yf.o=:/x]#q>ĕl:Xq(F2w4wO@\%_P'`?^5t-P%YK_ŜR&ὲ8RCTNOO^vɫS<؇P,b+nd4kחaOH N9π^ 셡mf[53!倣D:BD +~X}9Gdg{@?bjhh5Ox +Ç|O̎xޣ {rր rX=XU'+}kp=pԥiT`s!p^rЫF]_ { ^ ~veGxc{Tp1b'L@v0.XA>^{瘹xOehZ]]k&Z2j/_{")o3"rU-~o?gb^n!eyp2%7V=}.񾽄J/ڧ'| ?.eYKg0Xr0h.nm `]qJ랰uƘ>qi4<hPKY@<'g)yaiL%apfB6v%'1;e7N!֗%qK U Vo "50f k؋~ B }~ q_LQk )85C<\\'Ea6'_y&6֤ ASӎ>BiBkAb )OɔJekrF~(~_lƾAVVgawCg'3[Ԡx\Ϻ+>+ e;/74_6ƹ7Z1{Oxr6<EпZ}X煞ǡ +7YZĚS(cx$ar}b1zEh,@a)l:FM{m[c{Q?2@M`||hO[1yq,yf$ 2 HGm~fQ\ {s+WKaC6 ݃YPS9kmE<ʭװO=y楀GqbO*XS\Y [b5lDVYل+{ + zK//lh&K.Q,#lk(pҗ #=ScRy[i/ +iLX&h[`DzTӸ֡蓉jӂoYkՎFe?$55):p2jj>}ذ}CJ%B5k+aXGEx3EC# {@z!P{G@ށ'LZ>*[ +#aen/EMgg^ѩmDMz෎\pX< +JuUqP>a/!=ɐrxcJͅL@ +R.`VX*l +4v͞OFn":@_.OfLhwLl!̥Lr>A feV3j!oփZP״|zmFdÊB 8DV]d Һ\񧙴K<|3wa\|)]\o^iHWa N+j/z'"YXiI{fҌ$J]TwIiڏr.W*j&UE|J%Jj?] \-a!x9Wa8?/(A}dn07؜6i浙STXKѩh!yoUш;`m{]|QHtY,ɭ9dW|N҄Io&ӻTѡ1DŽ^q 1F_fjz0bS_zެ25Tj +>6 忤&eX >(W{]z]G=Gq}֋@7K(a_vFxK[N rO>l#77!_| +K[ĥ&]0yn֬dhຂQ"閰,Imj'̬%>/6JŷEVJr5k2٫ڬU[FGož[<-"Jo}ТSY_T;x~(H^g!󒸿6PC|9M5f>}\%zGo# uvtEmKUz(_=(>..l8+"ީ11-;ye3R2 uz'_[sKR;=caf>C+ەoVKoi,BF&}'i25C|E@? +ߴwgJG}y[vt~)>üd~>FqzX*dʔuYJJ}$}Ee5E&!3>هbqn){eZuȫjV飊#ҧe;- }ˈޡ'F4 +R7jw?걷H*O>ꢨ>)0ے-8Ǽ:T|8Tv^ .jWD  tA!Je>\<$h,y59Sa˼=LeҢP 4q.Gxakx&Hޔ_4wQ_?ZͿ]MG3C>Y +bz%jI3[H{UǥolK\n_b'~QsBrI$j7XJ&496_ a­b+q5OŃ%O_|د}@x4xkV4Wy`\x嘣d.⾦#ĚtJڛڎ~Z2ٗi*FK2'W=GK,~hmR$.mn>)*n=')T9T\o7e_vӯ;Q;2F4P+nXӯLgjz-n%X6Y']mLh͒0=_Oi"mJ66] S>ne + 1kˏ4-?,PǫhaU軩N|!H=mcDN7s:^NNjLO?0Ѹ{]k4|?髊s&CD[V 2h $ބ<1Uu9*̲9%ZpWNԱ[1`qsΗ2aRY5]'K+_<9/yq~2Z^DZoϼy'ƽU–7qgwQΪ㤠1gSj%vs19D&.7M za?9^O\M-wIp Ip N<ߜh F"L5H-@5Pès)[e}?C@ӊ*6h`W&[- W6m6b/n+ueIR7IiI }ud5ȧg GK;JEjK#.4&&z&y&&WzJZ麶"]BS}ܢV9Gf8߬p@]' xP#T}aAfJ5l(~pL7D dsv+ɖגN6JtTş-x%j~#+~-gium1q]녃=ŲCy2Ǟ)<ŔA8ɐ+zP#+?kX۝CO=HjJKkrZy!":bpQmXa]XIuHeuH)&><1jkTPoeCZq@YדH3'z>sy+=8(ѐI.I3Ҏ ަ agC_*TJ ?IKLz+#N愴齷*Ĥm[Mpr@O+:$EwVMKDLH^CdQMXauF7k~Mh~M*4R+]eer7We@SAA)'4 +YƩ +Ĺ%oϚ4G6d }j&Qaɛ BT_~1zT:WGE +[-k }`MnV)'Zo%\mW!Zr;Gf$KLuuOlLa;\u܍wo +LuYJh^G;>+v-q-:ޞ% loVW]Z7X˫anD_Fq/+v/u +M* (O;{\^s|^#w(OAeE^E2(_II>IѹQzo9=לO6I +ʶlaޙ6 +λ׆^qe]jLjr{5E a GPvpnjqH~l$ر*"6'&=jG}eT䨳)Ǜ"=oͺEJzC$%ͭ~Gn]GfMQg2SO7g%p7`C=Ϣ}Ȟln7ѷ#ef}"9 #j#c]#_6xg~ۢdMTǤMQbCcd]"~urƺ=XqB~̌rg~pV*O{'勓^ '֍jZfӤ8$.n5=r/ѱ:*%;j[mcl2@Xֵۉ*]% g2"m+cnuC9y<ܬ0ڼ+'BsR_KMx≶tGpܘmYqcccbT7;^-g_ܡ;S'8{V1~JkewLZ[${7"J"N6eDw܈`<[էèa;ߍJ%{7;o]sd;ÝC}})!, 嬒JAQrGZ-;guJSLQӥ' v9 vQM^ɢePMDSwyR~y=|1}6y^b}ƭ{5[U[ eq)[QiP_ڝJ"_zn +/ +="C /#p13VkU~n,E񡥾 ob߻ɲn.o +Kߞ5Zinh:rX5WX8\O(silt(WMطODh4n;w)s9,[ +dJK iks7+V([ -}>3vUqBAV[gKwYo=b +:-v /( {1"-:+ֻ2 ѭ2$!Wm4jSt)b0C>7@k8ޘm1Y鞂N;%/rE!S;n +Xip"BIa1b1CE$"1PA,DfD5 W|j<&N w+gc"D/lt5u{}s*0.WTZG7(/F]-=.v|!J[Ǒ8G.t/|Z&knuY~iI\p9o-j ۰SXTXf9nzFN󚂶lW"&(b1@%>r?^z,'yx˄"b/JW?*727*BoYzgԕ{nQ/ +\"s \"rbEQoK}*ٯ䯟\/DǼjF5bhts.Nqb(sJ_8t#rj7L F N$FMD? fNYMrU@ucsB9갸9zlVGTasշQYܢP +r 5yYSwΑŞQmQ_[>X7;GΝ/{=w]Bi t DgO@4ET|?\_{h.{Pk~[?e;zAf-#d.Zb^BX$aoc+Bg';QrkGh9-CVGGqx!5&-}Kt"7nMj_uF){R*K( r bƄixnwyuwpMc~H9_$jĂebEb8q؞<Ϝ[I/|e<^ž-pM(+pK)-vNz^[RX[EPѕnhr:m__P6,/c:{cѻa3I8MC9ii#/&&/"YMT8@Tv!v}=B[8!Ԅ(hぼM(D=E25ɯZXt)&2aKwiK/cC\ ?U/`N@Y IqbM;YӶ3 +S''ZGL +ߏ@(GJ,xf%?[n3oxJ(`{/<Pk}\5Ǖ2׌JJRD]ʹǿ \/JĔIh)7ČˉiVƬ!H̜Xa? gb#}I{Fq+ש导 9b,~~?1?QqBb696s6%,Q'-2$f-sԉ bN(˱e[n AQz\,#hw +~AX{Ǩ7Qo5F~[i'<9g84b42!75v91k:b̽Ē5bS sR̥$1s1CQ=~o/T;A6kwٲ<50Ts n Ǿ.rP3P_c;PXST'Y5fp0F=<{CM@N!F"[BP”5h fMM(NML_&Ebbẓ +m_b{;ps[?rG] <#5SuCT[S<̹ZǴ*z䷥NKr{_еxMELG ͫihM^OLDc8 F-"f_m#0k+OU&ļĂ}}bO fOv6C@_X&2{܇}|yYd֬uv-`DTZ6N E(G949]N]bEĴq PnD䕄tiJkL Ă '{bmm^5p*<]*0 ȊWztm%OK">Tل~oK.vHL*q0}a:fC?~+ a1hơ6,|LP<5:llgPN',&g 4&h-o i7KۨZm3 k>Ee(wƼBXhtscBgCRoC:J甎 +G%Ejp[&/q(LDׂ/%-t*Ĭj(W( +3Q L4\;k71g^b +1w1oM,xXJmt+!y/~Wm zy ,L/*t~M/~9mV7F WŻh℅u ն1BQT4N +VsP=^XaM,fF,Y#CCr5耚;{;”Ă4`XzXHcGo 7[SV z9 H󭰓uч:Dl̊M}'TӵӞ(ڈԲ2ې +b}Axm#Ly28ᯀA _N1ah>*SGDL@Xs[xR1lwf읶=k;.=ǯ|j.b-j;k;-Re(lc|$95w-t=QZb!j9SA4C|2V5;e-pF !r};r1<ގ^wuy#x<~o-Foӣb¾ܚ}n"flnf-S t8n'r.VDfBٹ2,ƀ6$!$r 9+g1xR ӍjZnR?Sea$zݔ}T+>>&.h9 8#qtA?f H#2!m;A,հ!<{6SIJBb+0lǣvݗUvg˙_; }~w훵;=j:7zA G*8SAiցPzYYKc{];`{I?U!!AjI *m7RXh6n11gVb&#bIbA]'7E R3ω>=u!3s?mx6Yh~x:9WC39X0WdM󠑺6;vC39#ŢFܑ;Ӓ-$!L؋ zy+6LE*q0O>&qEqt \obW#Oܙ)~3GΉ5q;U˸MݜQڈ2 +HK7hxm|m>Pi4q.`O{ o턶:Q>F2QAd1W|*l9w0wIZT1z!1g ؔG8 aIˉ[f$Am AI_9KOa j9R#usz`3Nq adC R7+8L?rּ6B7ϭ9J-ԵG,?db5Wc$}'ٛtImLuLnc2@]hP1vQuEyq\byԉ B,XCӳ!5|wݷZ% '/=<_(8:V偢+Ni*p#^:X 4 zm 9(EGi9QWHv5z-^^-eDALxvNUI6͌-j>!~_z(k`7u2CQ]A*AsY,ۋy~LE5c:7i%}s(_ Qݥ|s ܠe{mvMb Fz9iLnM>ԛ+>TpBS1xvl4 яԳvg$y1f 'Nﻤ̣v1׿K_7^\ gd7Ulzg6-~b z)n&/m)[8)1)-򔾨=%i [ydf~2d BQam w0 +WT#VX-o[ш_vqBDvvkBPF<%MZ؍7sMY*.<\#-M\< NJلƾmY8GlOϳth 1HВ&w S4tjfTuYΒWOZÿU*%SwI~4kY#T-Gi\z8IɴY_Ѓnǹ:,jS6ZoeNڏFޭBSMl3$:3q!˳91{_mG~M]`*zu)u|cftOu˥mLHمcgG^ L1ίH`xy nO[풫O,^EJ,Ey*eb)`0E^|t<@y?gi^Q0 +( uai  RgRb6I3ihsSi:f7tG5Iv;-6-e?tt1n*5x~olxqP=;Z9vKٓU V3ݶ²o|Z!ϔh>[N?Y͗ۗ"DS%Lf.8M5?4RTқ]Wބmٟ5yY]{ً[Vp/m 6uy($E.b?a}c@%Ulᅽ^aֽ00C߷^6kp;59}_9 ]t_r:Fk?U;> (+?"7O\SE|Kg]lyfB-a62W{waJfû?ԌU6+]o1U9qF}.+ e 3r)M1 3C +Sٺضd9gVB;hx $};bݥ%_#>wiF>էE?\Camg)shxoga&75ɇy׾lQa~ &VIm· lgagSחsUܧЦ_Jli.ٍ\nHSݩ:BdAf*}xhfn1srBtqгM´Tj j/r4 $n5r=Hz{oUV!ww'xTUq!n4hhwq~ߨ1ҡTR3#}N<8y/bŻ#p׿uݯ7}/w|y|F|W>ᘣp6ac4cYݴqf]7k{׌3Y'dnų +1[\9&cf W_:q/<7./5ܜc\zᕁn\GeB^T>fXrr6kz{^>s3g[꣊p_R4g>/:/wsEgbTw(ڝan^Irz-_o[_nn6HO ^=Zlp/wb^g>E"&ՌᓪFN,]x_/Žg ݟ} Ӟ=_(; yX`~P?)u٣{<<+?WY<~ftyf~Q IօZ{XrI:c5[ܺv#ظr!:NdX!G%ڪ ŎČ +I,Dh%'y矩…)|rF{k($U3j Own|ܐG}oߋ݋4)L:ۙ\: ']{eiG*5޹ 7i6ݩqٸOs@`9KmxK4l4hW>930g8rmpOoV/kDc%iW8Jɫ,Jx&K/׵<\wWOpز.u7rmO7qO7}?^u~P7;~oxpVx{?ׁ? ,&nm<0{͞O܇ ckFe B4׏f0MgU.܊p7w<.<ˆ-!tx~ )&Yue&<w?{~aNCb_c,| je%ڞn G2l􃿹pL\}˵=?n:t͎{=4-,qY7{f]vi\{hvcnޒC';B{3Z֟sZ{@sb\tP>4[ڑbYgh%/6`?ՇgQO~7}Jd__&b~Mx[2;Gzmį;0ܡhcTI*mWI޾ɖ;6k6/ޠٵiKCkt>Ֆѹ#4[mp%h'78I7CqjppE +07's{f-6A |fxth&ld8 sRũ{(/]g|QW|y>if՚=[kKcYIp4:aL%d~SDv/soX0JN 757nۤBjTxn6X|Zvl<⤘44uRY=rbVDҒLiGQvS|P3 Ny<sШJƜ4 [K\G{"줬X/ݩ;^no]/H%B:B7;!ɤa͝~4x^ J "Ts?r;7WVrW'W0r ȑCڑ:\j=l?Yw+:hfFI%3M)Ngrk GZ>V4 [+OҸQfB*]l=n]_!6oI{f8Nrp0>ҍo}Gӌ>+7~q>,]} +&Z8~g]ybfm}Dr'K'wD.g>ېnd\1f c*F!q4Ux`taEΟM7 ͸pEfʘb!s,/D+qRJ~t꣄BB_;Z, nq@Hs1 \.\7ۡ!uN#VQs?]x!1`$4\3=WՋ_3_P#@3*?=_,tJhπ ³:?+w/{uݯ6a@L&6{:y .,pwY- t`&l\d`w}h>,k8{r[ۥ<556 :"s>]l J.i!fZL4]yXKhɈ=0T\w\q~i"}UO_0$8J\Ik Ah7_}A-fU{,b.<}㭥zV>_iy;]4׸N7c +Feu0ӟMl |Z>EiavЊbr0 qpäˡKM%U…ߴQ(0 B)o-jxfĢ3gQWFZB۟;\b@.j.2<;12Gz)V4I&'p{%␉q2)1oZ:x_B[.==zu,4gB"ҌJt!>=_o_X6]K;BbXfR`xS0oĠa!bfD>tO1ut< 5'Qfr3}@_9ZNHHV~fx6۷A7QjuTmiU_Zf'}'xVϙF҆lxo֨Ո/ʟœjx +~̗Z,>vNb+GWŧ5C_o}~͆y5hth WVriC*!A/?g*'<@6G?[c8l8R+/-&‚}!y=|9w'KkՀ;z0i{]E┱<@Le1=lN>0īdM(OYʱ +Fl-eLEJ%rh`UU]YV[].0Đ(kԉo+,o5B-^7|gŞ;A3'CS9L1x{*-cTh +)NBD> + )1K/lM,.gp֗'AW`1zWN"L~phեc1-BRbtLU'=)9.{Qx)7W.e=ssb.\mRF NN`۟m3xm$jB;.4[4炒p\D+WO<;5lXVͼ-:GșBBhCK8‰jF-}3P4}">yAqg7{_SѩbHe˱eR%|rݽuЊG 4h%)7bF$1k2U.^mkzty+XJr=Zy 9S)(P_FҊ>0 + +:bW8s\ ~c#/8P3]9JT-4;pg^{;'h2z*,8B|(褋%7]z)('cv1T`Aq34z zۂ7+ҟ,91G9&Bs~eT5 ZHs/Z0 bڰ{ Q}F.W^bE|B=4Ÿ|YʲCnރ g 'g=A`챘1 +||O.' 9:&v]ӝ·Q󂙅 +g _֛rz+5#t~M脢'B׹,VC׮BwwBZ9^?luZseE|3XP:[>fTwq ӳ{U|i|;/ooJEP,ҷ;x~z_RLjE@j@p=CfA$1b}:;[+ˍsJt(%ydhXj5fؿxZzu1_h `^Pw9z[k]-:CBs/JIn1t9ӉSw`w=w{Mw7Z塾foxs<!( +qY1JA!6Xwj\HAhBYu?ګx81`gʷ'X--b9 Q;0NHS`D9#HSl`@$cWX!qtq f$TrSE93R:0;z)]~-fvyiL wyÆ{W>˧knhbgMI`g R?ם屟\*$Vm 6c .jV"$U9A\xyYھag{5hX%iY|`^K梁-E#Pk#XH\H.$|&hz;kH-U< +:IK.;1+u'rde ,g,CLZjytf|5^w%Ьy4Fژ)0e;JJ3꧊CO2j<3IN CR#lggM;J߰Ӈ3:)WNUY<#\[vL"bZ8Ʃ73_oG]{g-HsL +jطl5xH\{n~m4u_nw̓5Ӄj\zrZ$?Tkk*f'a=\0X쉅즩Z kŅB]cy2{5w#vNR!&zz5,#>Sl !6J`09(e8|4Xħj4MRlwt:0~H>yr}7)(gehޠW +-n)Q`|3 rRl[5<FU3bfL⏌,b&7G;KyBUk +'/L,#}-_ Uck]h+,q1f";dabICo_:^- mb!h|>ŧ* 3`K# Ycƣ؉|krk V"b'k<@:E%vD?CjĖk?X\R*/h{h51V>X6t6E)>;b {)@ʝU +yY. "j;׬V-*I `T]_F}T&>Bb$#m#=Yuo1q!,7aO:덧(+/-;r-;Klb#2βpZT̥&6!bgO;+2+;+ ;+abTYގ충9 X`b>&@gu̞jfR!g _qe}l]K%"ێd!Vқ&G?\%&9` /j5"~]g5y`0˩N#"~Ei.?'JW6UA-$2\7Q-/,n'%ZFN%[q}/\d쬤Y6FbgY\^!~ZujOAl<[S=vt鱷|x,KCZaZrŖO7˝v n[ 

jNg/JhܣZzy1j114͖kS6#X-kKYlwWNdˆe'Yq!y߰_sJ%]sʳKܚs[ӋwWJ/,RbXr:ţV&nLQ3~CrÑ լ +0-pĎF{` 28Au"sx.ri,_]}ᚊEbXN 4#vR MJ'=[{LO6D;5L>Y>H cPp|)3DYxy=ȥ (FF]{{b|;K>oe1ߐ,Zeﻸk\=XsԆk'-\FX}_R=n+'RCJD!(J:= cy6z_lZ?\K|'VcQQvyVG'yj41RKFGuU K5$9I_E,qxVy{z]l[0h0B<5(#i!y +]쎩`nȅ31cB}D+QrLaĀaT[ bGڋI#S.=g&߈"q` Ả%w| +4RTՐ\> Xf5} /*rٵ<>t/.FOCj(v?!DZ굲WĨɮD/pސE䏠~¿Ć;nm"^[|\hw}PbR8ҔYcxU1l# k61Y= @ 8CڋK똍mPB= ; W=bkTd|mG<;wFÞZ~m)L)}Ih>2<z` ^3|>Kص/陃nRpp\nTR錡˩a 6Cz4:Q# C~%%X=9L̈R3 |+_"&Qō׀99Z(18 +-\OebE#F!6!e+Ezjzۘ%kƞ1Ä]_[!oƻܒ\C%{7Ǖ2 kK{9$F<k$֍Ź7s_+JמbMAWoZ?ߪ #9,磜/PrOK0yo[%;YOׂXj5㐳ag/{¹{]o>-P" QV8^88Ea+DL;6L' A\YNh.ǜT=3gR~zz؃DΨ9hHxmkџQק_\ %׏ř1"VIǒ~I +XQv_A`m v|lGd 2j/A>Bj0 f;/'Og.sC9|Nj|ۣMyJ9%UB~=ҁzb}%:q|]~EzJIb֘o2яM9r4#?I.'[ -PK[L81ř2?e*6Nƫ+Ď϶J>a)qX,+sZ>^O5'cI|͙\ǧr?XYT1<|L1"F)C|8!)k&V6G>C.Mk_RSJb9)c5yFK{k5:N< ]\wIoJ)6d`LkuLY92VEܢGZ:XMYAWLX5.\3#O#X賳5$k'ȋ`Z%49Z>'~(OT$o,mnGNxeاK+sBv6]ˋ\bvDžDE&;oė9]KYbM]\ٿ3ط8/f?|˴~Mՙ}36$8$}QhM~ɺ V,]bWZzuKW-__/%//9d/G{opY;ǘŞd ~p~ٮ$wg^q^Lo?^:W-_vyڕoO`?IZ：̡W[ykً\4]lAsOg>wYgVhCf,k92Aڀ+/5|f}=ƃ30Ƙ{].ޚ}{4@22"rm)VZσ>,ôI>ݼ w4ZlQ߿ߗ~[ +1ヒ!ebH "cv4cԕdzs0L-Gc8zqLC~t`?c`<'i˪129"Ö$(g%4FDIxI4 ~#HAX!I"Dgؑ4B`#żьS!Gi! +#c!$ n!V8 oǒ $tKBBU5DㇱbWWKO.0dwO(b&[AZ{l߃P\#I(}70Cl$9qUcZ'!8{!Rt8>dMh&>> L8>O!fKG2CF2̞Af^Z?3w/U%Fps<_`^Qaggה?0wگx)d]B[.V0 +ݞ/荡ti0>-cv@9Vdk9rW=Z(́h6Ys i^_3Hu@H`)-$k545B/Y Վqs={5+I5NjFdCN3 Ng$9R'؏hÇ$Z-@"jCfDlGLHIӘIe:l'n1&dgH*sdI2udw +򃐁}B,H+ ˲c3G`Ҙql +|<%(Æ$NȕT$g +[CFqb`$$f E12o(=HԐxti'Fe19"И^r8sT6cQ4IE1y#tv/=qḡ"mi$ѐ>]/%&QFxAVRzd)"K4߳ݍ=֛!R+G[0v/,9Cxwф1FZdL`"[f^QU>ȵ0~#D~`-2{YH6:Cd)0AO(FLՐH Kh Ok&Ռ5Ė;vjX FQ)$:XcUJQ1Hf`T[Bc@ y +18 +n]Ըj -55z=$?Jo2!فaf_agwO[ 0S,oC^6&Yak #R4^sH/`P1rCՁWY?]{5n`l&8ǖ󍱄<ɠK2Ga)HPbG7BjT MHZ9 c-9'44<ӆ|Xb  Ҩ4ojڱcZ;S!)Q/,oRKNχ/2$8B +K -[!a4UM-.-'׎ ɐA0cgs1hcXCo$^ !~$𞰖0_\L#wWa csB>CR9YmS!S1#,fwW-͆4hh!c*'94ÅӓcGbT|*m;Duq?s0&sh4bA aq!4Ot0J_s/],d 9 |Pcd]4d2'1̱\ L"G@zJ:raRtq>ɾYI̗h([> ?>ZȠ$-cM .cFÓ(T#hLw8#X,d9avgHð&6C.IQ)' pIB%qɵH)`P:䏘mGQe6@XiSŎj^3wiWKLbl+ +9N$S3;.4ј"ls! *|bCc I#E鞊1SdHCr$i|9̾CVͷ'$FщY`8$r =9:df*I2_˳B3 A#l1L ʷvx >K5mdW2xaI6P*o.jFZo{mK75pՅ4U LPlyEtQ੅PR)UȵWa4]A CF`e<,~d _#KŐyJa>B5%ȃho$&hc&l}l +˅l;|Wl(\K>Ƌc,~f %foZht_JQgA#//,62UkWGbV>H QHy@SH#_LH'fB^ebR:KUWcXe/8s8^dm0 +AՂYRt|*d7h<׶~j-lAV2[dE 3-*j[0ײK$f BHxkɅ@FY~L##VbF`ĬI3:&Yst bL=Zc9rRYMfd;(urH(q5cX@|TYA~YvrjI9tt;$ņb"\㍐kn,;|@A3|jH!b54F>', ߢ 9,,Sl%uh-XARnK\N +Mz f\P@֜<7dX;X;(Ll⭰HJMXnQdVC[&|b֣t>qG+$!dkc``Q@G:ctKj $xmpsPsC}gg!&\F) RlH'efE[b,).Ʌ$[C2ZVd-ћ"xxK/J`z '$t)$}8$ V{< gi}eVO:mqӟun&Sc-% 7R+JG. +=R` 1#7άCǧ@FИrjT-O5d  S o5EYd 9NYn )q*ǒe1  `ggK5W$\0~'|"YPv.dd@מy|'5-p Ŕ8RQ x 2ڧ4q B>?j H5pc$ւzY\p}&[~Vִ~^ +2²m%SȐqDql- 4p(c8joVx|4޲JYC::9%|R-i1%|',)Q/2}Ȩ;X|(!#H|fd5.$Sqgc?_j`5Qyꌄ1oB;Ÿ⑈E|ېHA +{rzJe'cvtߐ +f05[AiɇBT9BPS:Uk<=C5j!$Q;咞Y|->J,~&?5PJ {_AxOK5wWBP+X > X"OIқ& ?B҆Cv\hb|+I1Yh7G- =.w<)w\Iŕ)KIK@:S~>+Kţukˀ]pכufWXS`u?Iȇ&Gdhm2G)Afu dѷCd?5$ A$Sn-GW_F0daqc*G}ͥL9(% s8lC Wfvߙ^7A-=g@rQH$.o$OZ?Yǝ/_ ca^j9FkEXOP~)GȩOIE_R2z}襰|!Bob*cLrC,e~j}Ce@1ɓ$QL5B>bj#_ GA6egL䦫-rON횄\ qB*Hnxz1o⢜:Qlxg96໤bB#b^a`cwW_:TjuHא2EBFΗXNbBB zv1ʿ !DysV4_H"{%ᴚ@B(ѩvX;_3!!'.rNjxG ߏ/w$W[X]yz$!w\fn] "'5+8=טlwm"!c;o[>D2xlxgD8gj:7pdgaF:rnIU^" 9Q#?ʅÿ=θIk!)XaoGݕﬠ׆CÙRo_$5fCOg%'B/Fa}`.m9|H0`!p@֮<Ѝ'( '@M5}Q,[lVo,%fB.\t=/ OCҋ{] g ߀+O{BEh'%7s&Ր<0 =,=7@*ug GA6#L.Cq\NkNN[c@D1evi*rbk%BP>tB΄z {TD[l!#7N籫4 Bo A2r,{ !pEB䛐,ҁٍ1@Xk/tNGHlRR?ow[A|N{?aV1,a8 +ȃ=:$MQ =<547CèrEC46kvl٧BV]P^ME {X=ȁIZ+[GQ $7PBׅd=^ԟŕ5@b +9p3|I#HPMw5ҡF7䡤ߴiEppJQnQ}f9Jݵ3!{ + $7Z=Q[JWWH_A~{(dKf+=o=p\BB_l $qGDL P.l +!!rMH_oւoS=a{lXI=GL=:^-<7Ov JީYrFda=Q kK8>[0EԍE]juԿ@x"CM Jn* d>!/+4|FEAƝԪ!{w{j\vոxJS| r/GK?cMDյ8[K{W?\FJ'Ylȶ8sHߺb "w$Dp!!.W25[O<Ξ\Ӑ4ـPצ `X3q梠o6|O Θ;)jQLHn,O_-E6}`tZq$ѻ 3-;uoٽABjg7e'?^vxp6xC􇒭|7HfeS.5Nb\sf\wkZvnX젳=^ ml씺܎޳PJ([˵}hX|ePuk1K NENG9!?0[jYj{5zlף\MnW:q7\|g8R*o.R \l tіޢ7S "z &^XOG ?Y i|HU~R,G@߄`5[j8rM6eyz$0bAtDTp(w"r QR[Pg!]΄_cu*I +K]'>z=`{ݔ?v=?ƹ`sk߇4zJBG+p`;'RQxj${QwhO䂵 TY*&w=jMK|rR_턽|m~‹jYW#3쌈#@7Vйb%~ +!cgpEReWrf`O/aذGv/qV >yjLHʴQX}jRsc$2կWH+Q_}c3&&A/ +}|jTǑG[n./}?SxT&±B`iov)t>&5|V9raR88OU`O{YJBӁ/G=obr|D-^lldXx~pЄoci$՜["1P84ߛ*մsŶϷ(w _`N߱vO]9LZc1[$yS ?ADӳpF@)q<孥rFdj3^P gguYƊ+KAo>D+Sa{CQଂLʁoPa,J#D 32,!rԌh zƩj٩8+ሜ S}߷Bd1;>؈ $ɷ&*>=84*WuSn RVu‘3scq&„#bO; Q;A؝7B*Ȅ,8pCtqvk]/| YJ氚a0.$ + }TԔӎc r] p&c{~bp*}c!| 1@wNb etΠ\jrFQyo<,2NeD>{nE/<7*,"tI.΁gXE} +[YccbBE?`&g|/壇^%$u'HEf P^B =O;cP=(\UN͝.~ҹ?ԛ/ =Q)*WjtOqcDtv]3 :'WZ.u=i<u*͟l#=n6K|.<Gr`pw6:r}11;SQJuE <KpK=(\V?Mr +y'sWgz<]uvooOO߂u_xtJW#}K87=Z6t<'v|&WbvoS^fR~s)jE߼ꉾ};C&`q3bh%KgSу^ mƂ.~,?lv|,XX=LPE {+;ω+k]^:=-=!)yd΀>:7*h;l\.P:̨.-9E$A 5}I^tߔ.ou$$ D9Zx.]Ev2E;P"ydQv(>ٯ%!LvCm1ÍpeI9ї-- ';u3A<&,i7뭒z"i(&|˚/H_tHwTY*r2TvJ|^|v +P1<~ZCktN!jvz)7nm +•]N_\f&zxTNX苐x:,uģ!~mI:J}& &+O϶xoW_h9Yg/骼,.V?B"wTK:]t^A=SZ(2֣Etrj#>:F }&cN!jN?2o~5 +>S0[=CR5UoOU!N5Β=#bAbbP  {4͊l8GGG[„=[>;=7x'}" +P٨.Ci(>*~Tkх=ɻjG/%ɍ:d[u >ؓB0ap ^Q43[wTٴۢYQEq6(ۄU:qև9N¤]ogOPhE(CK_ %:tT̕lϊ MpV>x-f2@G-hqiO^Z skbY#꒗fUG8O,.ou2( WoDeg$%Β:wE$EEW=6ě^ fh5vŵ35ҷW|?a+?Od谨9@W!^/[C. *0*~|%>|tG[%"m&?5NA.~3z۸&zbcA^ZXc-)h1ޯ4-3'u'س>za#zrRIq%V{8'a^uڈkj\E^Ҷ}%1G?u^O={?zUh>PQ lp"^Q坧z/1V/uJoJ:לИw5=XgnHQ9:'l8hG|&REymA1 ߆b"^ǝd]E2`gV=6aws}FC|)e) y%&K˞qv]εfgvǻr%U#k:6J]Ck +ػqh}]$õWqdˈ3c~#$~3{pV!,|#?n7RYddM9a÷#d_'qJW_uWrFpP1ߏu\K̬IHM +iz=#զ~KMsg+D3Īa֌䣝qC?Ev8?K>\GElC+o{w`ך.* _+~igZS# s~Ɣmm7aOG1IcR=OT>4V875y'4fJ:.M]g͇Ke-/G_6G߬퍽TRRs9|sBj`>I>1g[6HtAJV6kydu'ɪIѮڲ]Zen1a1תdwb"+[K.D׸DU48E;ETŸk**\T\ LoJ0~!i{"Ú8%xw ȇ"ѣ :#-%{A2FvP$ÍOՑȀ;H:\e6X+#;z`>` ǥm$ufe> !͗3϶\}', p p߭x玘zunF׭NcQsdQs:טB82k㲫ҫ}jCކs+UFhFD{}w*|ZJBͻbD[O sG+CZ6Q]W_,% !5L]y y0dPDkM8y+l¢x¸ mq)^ 9۶ ٷ-4ů981Kv-n18r,L|VWP!K=ڝ+BwH.oN'qu+Юオ}#"BS/7=SXU`rbI@|v_[S,ȚiG#cXvw2#BC;o]-Z/Ug}#qBǫZ1^1w\cJZ2[${[3OfObCj/'$W^+u?՜{9#h{L:.ܲL2!*i b!k˶m9'sS(H|k5,}ՙ} ;s;r̤9f>zPr^wsLiSEkƐm'"s2=m'mI"|Xo^bdobROM-ɯY^h3!6fHQ+ssVO}Ǿ|0`Fmx]+qYwSc3b/^IК) [nQSd%t˕4Ϻ )7}qjN>yt:ڲ8ަ0=-3)(ӫ!:xWN[Eǝo:ڦA]WnC{bbBOb@Sp +=|s72cxotQdle /aj|d0n*Cbڮ܈!G O0Z{--sʅ>9b1# 1'. (ǢWп=kuy)r8l,UY`>Ps>_;n.4w}Ga~>sofisl``Ftvfkf`1s{Ɗ~ެT/{2跕.QOKcҪ}+/ՆFH͎,bBtx2РkkTBCp8C>- W/z7 L3;0tAakдRo /^Z0L$0LT*+UMLA('i$.icty__g`uW p+b]hRج~|e/^+{\!{S}'cw7ŞљU>q5IL}._΄Ɉ;١FYn^-jb~jm~J^?oڶV,Z )` "{WRw9 ϊIo?)M׀[E`,* %> ſ /X|).?[ػE>/zy;;e^%+]/׆$S_{́/;^p笆v XxVl+L:S97ɳAz`2+7>Ncf׃;Y7F裬C!:'76'%Q~5aO"“m>zSP)K,=֕KBT\xtg 7Pܛœf6c OJi񋀊 +0Uq9 L̞֪yG(ie6Qo=`"ńXxӑaۮȠ} +}e #נ*en17agrV|%xdPTǭlsgsTvՙ,``M@yFOfM7K,jv*gVs{[ۡvuW#Qnvl +}|_.,:P}e+{#-#]Ω +o_~)hT銪pQS~%L@ez2~1i+=X~:`+.Δ? cIH|{Ť"Ībw)Şy%-} R8z\LXIn_~ gqipUplgmsVhx`2TiKU$` wLVlx",[]}\%Y\B /0+/wm|#Qfs,\~ٶ0Nۅ83(spL3g9V97y$``vx֊8qLUm0w&~<8Yb-[^ My[/oJ[ߔ>Tx$Ը% 7$46Tx#Y3tSmϘ&wYcyW9U7oo3Tm _&K7ف5`]=} ՚eNGᦼ@>X;S}[lWG2sݍY]u]ͮ+=`-XN߶͟mx,?(+ + +8f(,-SNe`m[9;}j@䀹[`;X kdO[,uZ%,;X.::]hL9̽`{=1===-g̾9S|CE +@uئg'È={± `ެ`R ,v <xZ^`3X},v1`=S՟0kǙPߢg/=Ooz]TjsɉŰNhre!E_]Tì3gӿ\ 0z)X6q1ˀRAڦ +ϐ۷̞ L\}#<f@,`oKx l-+qRFv'#_~'y VQ-CsFvzԴ +DN1x8Z\p{PXTnbJuAC0­p3 } +[nTj%:@uX9PXŽ{9j5VfmZ.G'}gkKCosOmpKlrK_S֒d wҸ)?cxXXCY}5ٻτ εsys`R.XKڂ`0l:@~Oո->f1W٪p]L&..)'NP݂10TwIcSTT:yڮm<"/9ͲP q5u=-6`XXK (m9%,YO%E`i +6`g +[#{&~fԴ>0QƆ;ߊkʉcךRbڛˉ'Rbc2.D 8G& 1Skưi@ٜ"r/g(-9|8U:S69K 25zx rh"gjO=fVOۜA}xUMsA50k52&ӼOIKIУӭ2Tϡ嚏QZ=5-v3# Y|m3#Dy``:CAX;U6Q` l *M(nr#jŽI;'p/өh^ɚ ~2YZ*FFװu1"62bP΂ڕ sgڨ.ƚ4$7hw{(lՁ.1C~}*̇gYjXy +lz"$ێ]W0e@%Zff-}!Mw(lX=vוxUN9ءuV˜:P_J| Z/bQlj^Dj<#?8iP0=nN=lNJmo;N8%8Dazi\+X3v+u?Xwl<` m`j~' vb!r>Bͬ/թc AæfsEoN?\ ;J/} o0ۍ+!5e$F}|o*N;hq3a폣Too]DjMx%KRUm0 Ser0oNb تkva~`OU]:]V1gDzaָ?ڜ83Gu3\ ;#1X3з bڄ1*f U'<gX׍=w϶f뾓b8'yYvK|>NnS-TVn<eZiwP*zWcmk1{5mY~gLb̫>,F4@y}l׫btm99%U>CFczL^cn` >Jt#ժND"r2_|"j:`!`KZ"pQ5 ~+̛m*< XSW;h4M~X +>łs>1ֆ-42c^3c)a\Lz*`x <킚߭/GƉ3c'/p1?qYx4J *`/c/wwLDJŒW!^s*m] }|F +Wr+r>l*-S:zXl2vRuz[_U9BU.s}U׌VrÍdprW84xSpAܓGg΍zO1{̨1Z7ł|X8) v>lEnM_Q/,JGܑߴ-Gm 苅 FЙ܉KVd)Ø~졂4_N=T˨~d&FÌ)bo>Q_#/M߭ v8gLZK=Oud:%[ >?xskǍo?bԹ'g+/Jޣzn7d">映"0=`h"IB}Dr>7MQ1OxD$eӱKlgc.]*i +0V9/ZA_W._ 1?jÏhr^&&KFO[}%ԃ1v!m!߻ɕyOK.?4&mruCaBGl?}8(k%X4p6,h{K!l$} ?XΚ,\ڃǬ`X_Akt# eмY+=-0 +382;c%_q +yc{ѱf.ĢMG= lT!#c K1%Kh}:d˭DffEƮvzAp^ٓSEM؋Wx7kt''uh׃YbORR s"JN#AU٠9[g񽥢{6v,%&! x1ss +^\2g *sl|Dd=-} x\^(5'| nݎ'<&Ly6E4{]%w7 iry$090Z/c I)h tv5m@ؽB,;'wSl+z}7Xb,j"`y*QveNKD{0[M"a?tG-I~7!U'c rt4m+ 4y/ ~0_N0~![|4u3NnYO_z'(o=VcOV$`umĖ +V6g=T,NyNCҏͰ|,.?b,8qO&L w#~|B*vu<3Sٲ1bjvެf=`txwC{n}uf[f012͌Q)cy1%chtI1K{ +`E@s.`q ysbh"/·89}^Y@VJ܃Uɓ>HŒ}Xz"b3i7G}eq^❥er+ImRZZB27碕!W>6EO:nOkNu,s6w}f#s]ǯe,9^9 M1l6ڣ4B{.óԅ<'RqHOMF{ȫM7>\ň!Ҧr}~9\+\H2[8hʕ<:,z*6YP׆ ´d֨6STx7~V^,ZauoF&`Ƶ0f,8=97c6F>Jjj\˓!vإ $@W]tEC@_\ +]d.7[I|=T^yAbAg-{,BaGul "82IxuIQY``\HQE7b>)sqeZ&׿$Un^SskR7IH_S]0$vn&/:FNr;]+Vw#8p[qh/bIU~ kio +!},+y=rϘG&C<Ca-m]Ig>7-AG5AMAt:  By]OmEJ.>Lzy/.͉Zo@Uc SiL +]Aӕ)y"?*WοM@ #C4aN7T13W:=Fgᙕ¬=Āޮ ٤_" 폧._Y<^hK>z-͢GtmC<_O\~:A<7?bxh*-r86xg7t隊vBPxVrB8e)jt + M ־C@k~`le9\&9✺4Md}\ mE/SwKr{ +}m3LIXtH7.i0-auRǠtY :$OڨMO9B&h|6IK~7\g +OLDbx"C[>X  +0a\ xR^2]qψ :ho\ڪk8)W|| +~>l:~A6C | ~auaOJ<ͨ؃a鰈WM1e.3;oṟ%OVW/%1n庂`rn"8o{a1&1cs weذS{ω|sy+蓎Y([IEqY6ʯLҗ"nB{$nk䯡N*4 Y!8?M=}xPQ j +>SwpՎHG84.QO7b)M}A=vYM\A4!u +{ɷ>Ľoq\tԹ8^p칈xwDOGۍh +7bHŽ{NM"2a<Y짏 +\U#25=\<_mh0m0~:jYt7|X*2z~?>tTIDUœ &fb!wVbVeY{y7 u9`۪`Ì`M`СC@߈c +pz<< tVFA_mZD?`~\Tf!<]11{DprzGrFl YFy&EL,FPIBv[\,6E Ó>#W RJM]V[C_Ve2+gģOx1)cl6-\ jFo +҈Dlx%i:Hw q/.X=L9h?AWV}0,$eoaZ>!Q|JIevO{\6y +b_lƣn$  +8DA?E twey"v,p mz3g%CG8=}Xo܉ 1a^82?8wؑ߭e”=G{JL%jeIM`DP_h ڛo-_5iӄ>9yÚ(߁)X`çКWl%rZ+3wYsM̜5C]GR^h kK{IӊHeX9*N13'q]ѳćƙv/%KI 1pU<0w)rhP's; >W*jijZ5D7ĝ6 wP&xh;B +r[K9HϘXݵ[bah*p9(cCjxlvaGKT448`@@:HK 0,$;ET.$ 69ݺXVoe2KX(=Lj . aq0 1Ckm%4BXtH8S^ga}AB_AfQ3Y§Ĺ I)8H醰:S ǃI_j:'tCxHi3!71\FVn(@5bF!|c5y1}1b=[{iNGQ]Af>4gÌB3='Q> Pނ]?DZtwM`-j2D^[l149| .<8FxcmuU%> LhY:(Ѿ) Gq^' lt )`LXC銛VD,g_[ƲT㥼t` +::tgr )rGW|ዳw˭}GǚF%]̻"^9*߮'Ѿ| =(50| k0*QqZ<nktb)IFHXrRgqVѐk % - UӤC,;DĊB%O:E:Eq[rZjqx3!zQ0'~~K,C {"6*&bk978j E\عigL$s Ro9q𰣒1B + N2 XG `q4P>S *ˈڅtP +` Ⱥnˌr8!j>X-Xjʻ8৽' l0?ucJaJn1~Wd'oBBHXˑ6cQ !SyvʎyfbvTld.@1( pSJH)hϨ9H sÊ۹Gd<<V.csӉ.c1SD!V{*xu97ҨGdTS̻{f'_oZ<s3'ӛ5R z7Q,[%'>=T#+af}Q1Щh +wIj#~#gnf V{}Xj`. sH-!&7O#~)bgay6 +@mcvHn6Ғzo=.K^_1wOL0:+ظ\gcG*΢}He> ӫK8Ehq\9HY* +[tɜA"oАm,)r6`ycJSO6-]tИ4&"}e5O!R|=F*CҕdI2H Q:\Xg@|c+{s=XKƖ> $Y\ZJ!'¹Q䓴P9WU(ӤS+mbs2WX41dΰ!7h-:)AظKW#ĥC2f2;>H/RgмGkN-Df8gSOj=H(Xݫֈ{ <'m, pg~|1o˷J ZM񈢍#a&ZրHwKCDLH"hw|򰼑#m/n_]I .&rMC63Ȩ., WĻ>=iQjga0/?lbj By.>eIQ*u_x(ֲ0".>0~KҠc\g JTgOLΕnD_g6Doq06Wj6g=&#m +Vf/Dgd{igX;sO m!y1j6"E蜨)kױH_^pAaJoAၹ+a9먘EiuڈKeu"#ڪc˝ǢgH +--_y5q[kuCwm̮+'^@k|suLüuIV9 +圬^1Eby؊X6Sc.WΎA96EڍY,طig#,{M{GX {jg'al|HpJBSBeR +m(eV1vMlT"gBLo{rF:[0NiH5rrj:h7XAyZ=,L'&Ҷ?YܬPR^34w؝ YGc{.j|HyNBQ⓮jgE/ s 刴Ez&cN 酡8$;?OH;e:NꖾPb'3{4Pt t,%^/qw"kߑ/wx8~~-sbV#&OB[=qrJӴJ:[7ew;߹͚;/}44n)E^ًϏAk£R”QGYB etTn.sQC~Յ1Lh'tgcO64/]KdBDh}Q-tιB`jg (%hD.G +8|_lQ|X;v/u/>7q|4f=b抽 It=w i|sA(o\bٓ]DֲmIu:VXܔC2&7R4PNE=&FXm,%hZ@<jN:$ +p'7,YTy-=\N󠝥e(jƃjSVS,%֣g,?va--%ہy\8&rO4c@={+G-bt>L%=<Ǖ%r/ET4E1[  e%?@Pne +@FϾ +k-E\Arrۀ>xPm|F t ' +hsn1e 6簇1R|4hR\IC|.e4V¾-T; ,E;˳jg#]\$b!CokJRY-wQ}ke|SKCW@3G {8_!ԯgȻ94)uKSK*k2ԗ[8R9'8>f0Or},jg5$TtͰp  cn-wvKJ1RґRhXCC3ŌˋqgARt b㨛(C z9./1Qzx-b=fHAcEV^߂=wq)WdktZ!iGKFP gPu +-&aErY{EqN~,8[M6MN4pǘol|{+]!U |2rlTĈ cb{@_|#zb\ejU{~HBS}Kc$kTg5Oa=%U_R⩹"UfpҰ*CS/,pDw-`z, :N}zu{"U]pgRۄ?ESG`|MXʛ OҙA?N@GLvFƚ>Ƅu u)6|Enhg)gť>z"T6\,9_NzVrrMzޣ%d[1[IW卧X}h9 i亣K"˾ZUR|﩮-\vE U~qŵ҆佒Oτt>$şڹh ɇg!z.mP}'c\#,!OBI&֌Bo5=ttP%'=#k-Lo.Cf$_f 4P7 QSqB'Y9=&{E5<8j[zxmxL:>˹51|"49-|ŰqЬ}.S DNI5 +$n xEqz>:~tSNBMC:,)׫5^2sը j|A 8%| 'vyu!B igˊ!yB+MI>2'jgEm#s* +XMy߲oa4ubT>l.Rbc̫КUx E|mН"sK"|YJHBq䅡v9a]J8;,yla}ݙ n6Gک*ؽukH> _$'cIr}uQGМ9r'CBLM5CAw#q2%a|؜;Q d Rjyc'A +&Q99M9@rYԢ8{gmhm~rI'g9+{AGkbѩTB`tPF/vu֬!j3СVa փ-@  ,.Bž򼻋f1Ƥ3灥Dd} /ңkBĿ+-gu&+ ++EaT&2﹤8I޲xœ'P޿{ϸMTn]XS__ĕ^Op3˥XD}.0+ޗ2{ ' q+EVçҵik[-佈xU{2P NgSܲG/{44UpMXc{l&Vd.2G1tP (z X$F#ܔQW>#F#'E{gĞ% K_ Nвw qy14~ 3y6]G$ 2 y]romrr Vs@K%qF=J S~j})T=k~חb m;jȷXQ'ϿOk=#)RO_.ϻDsszQ9g~\1T{HB' +$GAP6|bGf&I5ko/Л|p;{ aGu>3|M 3 9.;p[yb~Զ1MV-;K@O lI{'aŢW.rgoH?9WF8WSxL]h:S=aW ̧tnQN>7꼢fBp(8zA8sX{F'EA-d3/8=uR=1BuɽҵR&V<5BE6F{` +^G Ov6)f&c+tA_#{  .ƥ㳩&8f>d"ӸI 3gs^#aKOTcM:;|aaWu*OeF;}80GhFM_z|=_z|=_z|=_z|=_z|=?wl[gZۤzbK]::sW{Z`ur<mo^\oko[y,7m,NכE^:o΂Ezsm򤅍mK K-~yK}?o9,Z^p΢K9xz1}{7qYgCLg޴z#cֻyr-4.zi%u&n$_ͣ8oƑH((,&M ĀLM3%4"2Fj$ck!h(l=%?s- gAX:D;Dm) YMQ  ùClܵ fF޽I])C92Uf]Z6鰕Hp [݋UbzK.AEϨ!i _.6sRGHc!z iPIIJ7;p[߱"7sIkĴ Icë%(JX%![ȟIrQzx Pzŏ%:dNm+FaЦNA9hUdC+lhЏgE34BpncɈؾ~G/]dQCA;^ 60[S8b#Ж)4(W|QKa M݆&2ƌۦf |ؘKM̘[h [as>׈ Ra<]I@XyFF.9kh/rJJb/% >Br#|0|#HT9G~hK&!%8$Irǂp¼__J'6/"+&p2n_\P9chs#vCJ@pw.%"NmGAl CYchs9)JŠИL4|ż&1o@,#RoqAG2Cri&lͷqGZ\i  ,>62l<hic(5bd2=dmė{Ak8|?m9p*e l'qڀ݉($#w 2^9F1%kN;_BP/H|AկCŹtn7;`!62.\Jxfmtcȧ_Ļ$ 21v}u㳅sN]Dw A%q d\=I"QFo2|g] N/EB8ئZ tMdhs-o3h8qO0 ;/4BHRD$-n|*>6cIr-HY~Ͱۣ _X!O3j$3NÜr|% +7]4I%zM(ß 1gft6A&=S чs3A䎆`v8\P7x(@ M y@FϹG@\ LJ + !qWpj$V >J$ߠ;#(IEqj;1r(R/=R=j[[>Ch,`~Hd@G,//s[+麴I$$opO)a HMf/9,D~GEULIG"~\ qh6Om3JA>m$gtBȑx` H\VnNs=\O'3 +0;$։[ +!w&(3Me$WQXi\sc-;k$qqh L|b2ĸ30An{īNvnd{x3n7|AhNB^M;(<{"_wh4!}Yil's֣/i@UXħ\{& oF {@MBrq HT!S|b0 nǜɵ F j+l #T]dApqze,Pl'>hj2zf@I#Sk:()%q |M rw@|{b{k.Nkn `+Qrۇ`a h<%&$0GuWC鏹ۤ> >y!qYyk#`n٭ ex;M)?6O| + 3 %sH}$6#9%c&hPL<|خ_ob"_\ v>1eV;{9F|,$E:DyQ_k)K3gFܱ#lQdIQ\#u?LJlW9U]l*\w{>5 +NQk!#w%U6R>"?w4!le֟(Y,rE=! .v_tPܴV([ "2FWB!/D D\K^=C?=O8˺XƠ02Į0)9㞾"rN?ԍMb Hu{[퍜dU W=3(/& Bz$!ul4y~Gq[`_&+C;#i$Ԩzh)hQ @v֣,S∢o}2Ph,|O 34Q8p%<'~s`њ>jHzd}Se@"-Z +$_jJOS}G)J$͡b@hxd*)yuנ"+Mkll"(A rf7uM=CQ_D9?1B4v9|Kx!N gf%/VqY sa". +~cs+!LG۝ELFrx޷ք1{PBIF޳Hax_.C[S-*E՛ S삷 Z br:ag0-wF!?ڔD쐒s03;RQ +pB )qRA]=r,% /Ty:͛k 5|5 g OςOT[ʥ^%æÇ(HmC )#ʿ>w +ȹ9\܉[ 4Ԯ$=|@q$ Bnl ++I)Lrׂ5bӵAƀH&q +.&%17o 'ٔƼsş:0ST4Éy [!<1XO +-@I <@p)B.,>Bm$W #Dآ?|}12E|9oB 8s'_| }F endstream endobj 28 0 obj <>stream +vbw3$_[ZwLe<+`%nB]T '69Wr2*v@6ݴV+9@:0GJ".3PO" $-.fiLui" yC;lNIs5Ki@Bqs"PQTy]LyJk*[*v!}ߚIl"gXk/bQ:'~ v!ܡB*+z.ĂBqZ\C9; @r/U(It\)9^)w @ k ,UX-|l؆/f]׭@ 6q Wu"k?{lM,4 ֳyjB[`A.KV.ifvۤy5>Q@<ĺ k.=.etJ:@yw_꟢+_bJרA~ؚ|кG +~ +B-$֣Lݽɷ*3?.J׊7~viQA/i$=.0R?]]G*ݨIdۗM !%;RA2P7djwqG +/}-Zͦ_OQ^<=Ct+Q?1 +9=<ȩ!2/+ kE.خibjo1eHޯ<ȇ)/BuFYܐY&ⰨZ8@,WĨa  LIsz!j!H + 37Vty̩؅f[ja %\]Co輸״>ݫ/ƛkЦ_ܴqDg ?@a!-2/󮯠~Ne\\e_[ H)|}~Ajh^uTJ_lm/),oRVXH:M؊ '|ܡ)T{]- -cUO@D +~G|*v#v!؅۟bY+-I.քIgjs- 5CGh5J<:+\{m(ui1$!p,[յBr47%#*1I#!N +dW3b\Xq.`1o%jR>%͍Mk7271&#]dK.QòP@Xɽ7'./(ݳ7Ori\TZ˸X"}F?!mG~of*vzzlF /b*ő9 v Em͂' ^(F{>˕ չ'u$%ǞUW@suqs*T;D1S k^j7b|!E}m~JeuPRϾ~jri.~<7œWb3E}XQl#[O uD2)%)Q2!,!")LH{{XVEkڵlU_Ԟٌ[ v#B;yaSKJ89b\)tcxBᕓ|a* "5AWJ,kȦݞۡkB Z*rtI$iRX_<׸՘ l9w(#DDׁw& 8h8YLH@l=bh$Mȉ1M{&Aػ;Ufh1B~ǥ#/oI^p){X==BKg*DuuE +HQ +B}&tEiXPG fA\whӇ}ػsT_:yj*_a0ಘj}3̇@ &y_:*rJ~9{ օOPX{b͏qc:{{[KabDuYh#Oxܑ`*=!fpP>f0t֢8lCJtOKz/䭨J3(K(^+g@$؇|fpz6kXcbBE?r" a͔^ +z(Z3l4<*z:ֹ"&Q5 S'@~a /o[ qJaw05pΙ!h+ NACr. j +O +QWL )~2,ɧf#g0UkQ "Maj=G˄ki] CMqniX+7"=f 1~Y/`5 an/b_o5-v% U8н)b]96M/KEg|3GVD>] +H}#t+}&M?~w +;Fݣ{QPGY:쩷qڒj>!>tQI4/ ɉ33S7b_R|%dOLP&oa/|ՅKbN) 46W&uGԌ#K'PD♢Olt5jDܰ/z~u!byPaOXGb`lهSL  !Nce&YEJ.;CYq +I#4.*;כE-+ݧEQ$f-:*ɏ-F #ŝɧKk>b([VN"U9Ц4/(^.}V.B+kW4:8-{Fh3;7 9*KнA̒өBy|iZ +:qkyܺ\̻ +/{P{RQx3bʕؗ(~F4$؞z~cȕ[ϕ<_u< D\yJbem?ski]O9?SQٹ+n_KΤ#3h-=>~ _ClŹl%kmkʶMbuPٲq a'kEY*a1C;BnQ'Y7p^[^tHS8y*7Yd6wV+KNp"c~e$?a'#űO&*[^+73/G54[{9j~5X~g^v߬W~gRm.ߡ<ޠqUo6 h\!HqR8Zɗ_`_|V-3^Z;ުunז*H~Pofv1_ڀ??b]|쉩f H͸E!J_ +7_;J5;k-XG.[>W.|W^VlpLv["2P3:2U{,>`ky +&[޹-TtmduK۬īOW[\dE~{J]ʑVŞ{ ;m[m;ݹoݸ?;(nVq7Kٵ_ܣWn統qb# k[q0],SδY'[xkPDuI8G_cYTp鹵㟌#ӝsT_mG];\.ŕwؤVT|!{'N 쭶m\s- cKͼNn˗Vqf6P˰I}9W?m~ +;u{_ݣ,xK97G3]_ZTe,ߖ%7:'UwX N͇~ҕ&g6Q4XeۍX7LD7^ߴTvSyo6۟/?^ [_pEHjSU]˳3En:][SyV7IζIr?ݸkmeUXfuQ|p={ꣂJz[u$KvN@[vO'n'nVZ{Vj3z孇w,*^-H8o״ؿ7m^|z(U1U|+k^&^Yvk/Q}u:\}{⶗ײ>g((+zqa +MVv)/t9+e<9˿qgv]w^(|ۘ!tI/c|٘tn87S٥ +3gܫ!m//dkNeIㅦUJ݆mst+ -Ol- oJ)^ZdTtgo>فlw3,}鱿b"~FBٙ|꽅\kCsOv(C[V>)K?)r/QQŲ6LY[$\xc-Yf\yʝs?ʕOj÷Thr6I|e6swkQQ䓤'IE%yQOʔ51绬W4dT63e͊N|X՜L͛{Wkg7{K-v?n&~j2ƥ@G.GJ]ٚRwyÿ965ڽb}&{\a;RE)wTJ_ar#m*l+ת΋zМYY>$ =)}o?lNmxZK~kI?Lm`femhVrm\[Ky⇦Wnq\q-cYpgߊ⹮O\/YoP۵[-Yxſ||$M\~x&z0mx`qK/&gUۃTwaM)%ͱeګm{y9[^˹_Ϸu$ǧ#37qD'>[Ӯz!_o>I'Ri2B> +. ˎjHU}bR-?n{p(yUytaMU˽$ΚLnZyŻRuL:Vyutk(D&'?VY?n>sEQR_6pފB[kgkI#Vo_x3]Mksק}۲ +> /r*Qw= u:^ޖTќ$D}1  8]{䯾Zw&( u^mDc,SGz-z"=|->hcnk]'dץ4D&%/߄0ovNS򣸂{Q9{Ed<"U\V[HMcn#F.R$=N>H9|KPhWJ2?[y?^wzYK`㹊?^v0{.w9̼Ć܂Y"rܛKLG7x2avҽe7ݒnn}7gnw{5F7F%Ȩ[ڒ6TFݿoj}79v( +|UUST(,Ϸ5L!Qhn vOBo[Rw78ӻ9yu6oؽ:,i|YHSF\ٮ@u+uv<ݞ4Px7?'6 O~\%-oaʁqkW}GCrL}BnyM={aLLC|_g[֮ N Q_{yNhoCޏȱ}Ib{ yoW'c۞Oq } +mn{#Zry]hSnJi*$ސxh_v^^e2xv7uV40,YYd53oя%yKL@voPTZLYneߎPJ̉&*Ox&U}.*H+,AXr",Z!׈~wڱN -F>/6VYk(231{2]f3<3~FYFd6KUaZW̔㘱1.3Dft/=f\)9qW2Mݘ5#7][OmݟݬF޾q&0V_ua99Qy1 Ea wr1 SߏxE/Pܦ6=)d.̠dӁ?l +<4bQ ]äz~-68۽ Udѓ=F2:f ӏOOHfp=fR3'tU^.8~C[F_wcJU1\l{%Ltxq$71)nTV;j*oGf Rx&,c;3n?({U޾;[/}x3ѹ4Nt/^qckSY157G5WK3e0L/O\h~yf UOZ߷:әy DEc3wWyԷ9rGgݎ{;2k߭7ò +Qyzhq27ՄO κ[ېX''s螎$?ۓU񏖎̴1ӈ#sCJ^fyL58zhҫ+qt>CALoA䧑衳91u?;([]{SYogT ϪE|L{yo.E>Jɇmy~:&2yUGG"֔)&vY}c0zGkKϿ79C|Cia;|߮5?]~#\3*gwRu6$t\t8Ք$;ueMb dcO_Ⱦv;|[!Y-5A9]2O5 tuﺝ-~{rc;f(Q_n}fDcf/_uoR|~8Z|9od_{^p9WoܹsfhV8uh}ZnJm\Nr]Lve=ɻՇk3k#p{#VjΝ9`?z4עvz,7}:z%ÌfjOfƎZLYb]{痁֯%\Q|ح, y%^YqoSVj<AHfM=X;Ihͻj/^i}Əz{?_z{;ӟܡ`:{{3df$fhYhM̌!7W˿DpĄSm凫mjc._YJ| 0>[oۼ2ӻ=3n /`dFk Jg3zB˙1ÿgF\[̌Йnj36`3 $]L^YjY@4n֣I.ҀN\*$ٝ"+:ͣЊ !{67!ZS׽d`Fi1C{"? &OXK&0#{Mc 71p3z:imf%2_5Fx}#(Z|Ko=Ww'aPyw䝸uk|Hݫg]?&|D|/#|?(7d_Č]Č3V=3~)3f3f)3jzfwqS9faC`ΪsW2$gQr'65fٹ5j3s{E bf=u^PFߺ.sJќp9C ~/ =>ghd03Rs434fй?1w0ّ3vȌ`FO3'0#Ggf\fE/7붵i=VWTx)!5 +Iϻq/PaPM~y5= *&5{rb՘S6 zy{=!Ìό85lݡ[ƌ5|3bOMbMs]q̢m't55K?u? zjD[dd= *|X1y Kĥ}kV010-!y5̹ZsAd >gk[YBs5IcV%nwk}f:_LW3m.jHȕٷ5^{nFȈ{ϰu{R"vQ{/(vAXkU ґARl ņ]cXc&{[v.9g=?Hu͙k˘?i^wȹpin\/F_4tӢw[=>3,g=n7{D*{A Q䜆{'!۶ߌ3,&Hj:̰K9iv,3nI3s53ֽ4qaFx2Ťq=cxcX!p5?:;\*|x j 74]!uÛytRÅJ#CLc)͵#eJb#N Ϗ$9f@r~VNLQ7GI@{|ǩ(f8f"fL`#3ʷuإՒÆ $}uMF0Lc5ؠ3Y:f @f_fP7f(OfЌf2jYGMl|d0d-,[ϿE=^[uu}C'[vF>S{mA^wڿUM> +'yָ\Ha=qƌr! N|Rf`?IkÇ,b ]8 reV0ffjfL_qxV3Z.8mˮfy4(8UQ~aM_^.zhK%[7~ S|l :N+I_=/ a뚫ٌ_ϫ'Y^ҒfYC~d #x(fg3%;QŌq rT@̛ : +f5CÌsKa0ӄ&yG&꾱aR  ˣgkķm길ڦ'C~c͛9_ʮk^9=29́ |ؙNec87\aɥ ! 6?o~oZ<{/4L\~C/D?ܐe95OvRk7kxy混}^$߽mZaȌ 7=ُL೙Q̔S>3seytzy97-j=kf]Ͳӆ-=hpr}:}a}C b w5"gy%sm +A,cx"'~be.3/_ҘA$  d/Kfqcf7qg<ۆ9n-~on~fo.zm×6"_ !ޥK?]- {Wƫc+/K| +lI+HsP쏡W:1O`SUC{XL=*f%LU3SӘic<3~3a'3e媍楞5?ykaW5?^TKo~ Mrs RAP2&JK_]꣭//lUpmsJew6޺VVwF;7U=<#j 3l\f fW<•1|fa\k~jA4[borU?f~J_ + *_ : _^4x|2/+W}yʢէ A7oc_hHS_i T0bDXnvC^v.M'tO>6Pzh:w ^Sf)a6cZۦ ɳHg3f8/}ot)5+jH +! \M!@ξ5}kS4H M/*ˎ:(:sVGb, C*N8ߟw-|NRob&Wwn +z~p^5ռЇTg -n5NO>C\}wFq \?˒>&Ù;QÌLf\zѡ~۰'bs;,h|O6o_^1(6R$0UJ3Wo9+|\.=~<:GaòLc 76֖ 5̓}^|/.]}FF޷Kxp{qw!:S9U{F_B=H̘2eK +Y~A!!k]_J_ޕo3wL&0),+okEtd=i U]rસh f8凿y}%rb݇_b2>΄r/nwZ-8C^B6qUPVfE)̨!4Ft?ҌkBx6rPs) K|fг}Tuo7ޟYpu/ſkūn<-Nr9mQ-2j<_^ʖkUlnR_[ +B3]B 1͵_>Nb@2j(`0f2\鲳⃕o$Of^=ѱBx9XoR&pLUyc'3K&f1!pBaE}Ob|aw+G/ޗKNn>'7 +eb6 ?U[osq yBnuǣܾ[sT&*:mCx`~k9'}Rf k!({仞EJAO}b z]|^>G00؝Obqkm vBI?u< +DBh:݉a7BˋlWwv?Uu g& NV?\mS}e J-avcK̖.U0^J4Qoa3~:Շqx-^ޣE#'{z2n1>Z3}IhJmHIǘв ҕG?c_k?[eF]?2W'V[~w]~*}%^̭=0+>_>:l<{5ߘvn`O\At?tAWC?]CE[+w2?jz>[?}QO)GΝϸ,1')^6tUbM|pO#/KG +jakTe0@*h&2[5P;7!O%r~TRuO˄S q.cS +i\և.¹w*c=]jy"#GS +OZ +Ɓm}N5gjUflH_i̿R{uü X K2էWkk?-w;nw;y?|G;_Q(:X,^/Kkw:G-ɏw]\:PxDn[77"^:{i*mHE}ƞ\6D+#-vUunKѽ3H4np9`ৠbbbM.N򚾚83+_ nRVם=L_ 6}6S+_~x48cت0g:~_{cq;1`r)N#A~]%G:ZV?)5 zN#W^cG0_a5&Bqp+Q'<{'z[ ]ݸ=O/" 373k9$}n;/hW%w^*DU4wZu7OߖqVR2$[}tg o_'S!PQ/u43efHs8/2sdS.2\O3u],!sTK]o+$YB+ KmzՌɶM GJGZA\Ep>N`Bfu?9 끻̵gW!܍Ta/I%G 5'|B푉$OUvջ*;S{zy!h; PERWat{^b()@w?;`!`7G&kvޘ#z$| + ?yɟ~)+렎+P^`S6󻆂GR1w$[!G'з"t +-2k#$2P#kOLn.ڟ.|'Z΃ >N> "Tվ7B-=o?y!?UއM̷yz L8ꃱk3T-Pu:+0=~3~42f:p,f匏 ܛ6Iox{*o_% O4aA6X`|1"4q[/͕:,;%[ ? U{`btgZ +nޟ7ߝk(¯~Y8*H>"B}^ ؚS\:^/PW7Sƾl2,ӔKhZg> 3}8feR7 4"׮?AvS讁C^3A +zE Cn880B(4H(mu`۞,}4Ui$xbF+hJOgRf g FUǨw};}p;%'wn1'2TXmVYAA&9 +L=uH8{?+V v NLޟ #>|r-_d;R,;n4 }8|V;y;B>H?+Q` vE NDo"ׄK_.hNm˖t WUfb{Zb5 6˜rZnVw ;d.[,2YЛإ TZnF2i5kN1%eDdY3SU0P;8:B#E뢳,;G76_m_w4h~U}R 4#OT꽯T\Ɵ~-h)㺸s$أMbluEd>.)6}2oPyW}_-uv~6P:U|n>,# |Pe0W.3K\2lzkeo};U'ư[퐋z.fk0 FVG#{}CΦ`CW zxuעCa}DU~ ,:hqLw JH%H|i^<+&Q~BF;!Pb'$C!TT`,fۣzupC*1jՒ: Š]^h31$E8|V{N:x_hP`=.{ <}o}}b΀a&A&Z*iq@nX~ AAM jh(\BEJ` ;2Ü-ͯ7mWiͱpc$3\x\}8 VPHQGyILcDC`)`ɈۉTsM8k\}d2e;2|~&}.ObNK =yȇ(XKǟ+t/Xrz*+/z 즏a~1[xnJfy tq3zĺDceX"pF 2{*op唝[jVtKu|;yTzt`*qMg Gߪc?~Z u^&9eG3AH#zbA'YSUklj +,㉯Xg'740  1p'XaKġ12J9UeyA,nxH sad t(3*C>·K/@`xa6.3:|jk6$Ƅ mcJvybV{&8H$Q4{!MC>x!gA!+)g19JRfd3:e\T?Xa,NcI`F i5^j)r$ IUƐ})BRéyჩvv=6Ki> +>xKOِgcM叟W%O5<8BH(e+Mw Rj`65?nȟ?~4QEduI&>vuV\䐚dCRT35ṁ2jo>GwTk>Bمe-#ɧg*1xkqdMfJYCNkbNļ: -GƙI*} Pˌk*K/+T< z`i6J$Ò(tmrAJI4Nll\sp2=ڔ5} } ;r30Cnva`j{\2 g'O"#Ė[q+-4 \T9ka棐Hθ̟:p3Hgg kk*ΨA'>؏~,fRٶ (ܫP_4\ˋےaGj ] 'X[@AF=t4qZF-MщyRRfFJ-WZ/.7~8v-D&n:_l/v ͵]Ƿ: aڲ[t +X|ڽwUoUlX)9>Z{2t=|W~4w=q,cĘ +K1В#OE\iT" XqQØa- l"q^T1uX>O?s_xڟ ;\-DMVT1,Cp|cˁNN7_+}\|뼫麭~"4%#tEuC5'fחɭ7܉mМ6BŮQ$M<*[hbm{IݯnuR𠅊4?fXF k;.چ[mC/g-\P m-w]׈ԵJfШ֟whivTs\ m-qg-CRlzgvwj-ɟGP^ߑ ++^Gw!w= +Jztऋkov"RTYp6G}`|xJ!F1"n7x|dOzit}tY`|PjwKSzqt1sO)ŭ56d\B5]}_] t=X.7̧ڀ/B?B+X{Jw:xΘPo91};wܛOl6;n/@ ,u=``O-_."7t5#츹PP\Ih}D㡏rzwp95UfXsn<1SsG箠i7>R`IeU5]_+:^,*ǕNoBH)u}5֨uH uD)mS?HB3؝J6VS1U/U/5NJ[O&izoX6w BF|zj[hIhgq[I^vR{Aev(^x) LA8_]A]f 0P[E$ނO+ h niJ+l֝ThldZPltY=,nqcD}`q2|nA] )5e b[.V$ڋI^W9@aq|:kuxhJE5.+Gf#6kRK kз>V"P#qWj qY?A9uzCPJ~ڪ3Q=$1N1Cʹ}(s9{>zG\g;S]a`*j/qݱܮG37ϝKםBu;_wnt1Xh>zGb=e<_UI$ 1SoNTb+D%!.Rݬ~J;0ɳӦkHc\nEW/M=|➯}v@;kE:<ڲgŠqlu1V8Lٰ s2m)Sy12ЀȨ nw +6NWI(fm?Yܚ^עC_,?`3˕LNӶ,uS=lO}=DvTg(i(X]vwԇ\G;jPmBhSPmxʥ3lO,m˩9Yb[Кkjȩ|ZS>I."zA_^|o|4^g#~ 4ëĚ}ƳΚ;JϽxZ/%1r;?o=u'_P@!H P{$^oGkNL\pUd)X2usBI MDmZAs=^l]$W=TsMEЎ&Yhg58{a}PʀvQ*g :]0!m|YEyjgE;/7NK\mIurR uбorK_G|!WMLsz`VþDbtk ~'Mwɝןދ4hhjwd3ͱ&%!C7+ 3R!F,tJ;7!ϕsۇ"Aۏ1W !F*!vbJuXWZEtu=zmkM:/.$ t~,MԒֈ5 +kD@="%I[kɲD{GCS6os- .|uv[$'~`v͆S5Mm#]w<k`qKvyOIwܐb PSd+¾U9 +-TAH[ۇ O4ZN$fv֎;λXKS; V?Yέ^쿵Jz3E|ѧ#1w׮C+6l8rxv/E^a ^u|h0frM.Wɫ3]==+v,Ifq=)Jq+i0J)#ֳZb%J e(/0*FGrԗmtTqP-ʃcǞԬ܁} 7@암 +#@;8!G~ץM/eSjF9"\H4$ .媮1@];Y˭%Rwd6u8BBn<9SM ׶o!PJwo.es.G$ߺL_i.*$qHp홠%OLɃ|ۅjgQOvU,?EmTnMv/A?Y%=YJS;+c‰Ԓ9/㋶; $eT8 +CVp|t3PdKz8ǻhɵYQ}^modBr!&_Γj5Z'ħCM}4'5yd~/<'P1j}ScuDox_a@w O!RWmn?OabLCN/+IܖOKj9ja󉛼?#=.BO?,T;4MYgmje_5jm+6 \>&8[zv1-x.bz\5'f-8XׇŘB :RY+=wh ߻i6Ξj8ǭZխrU_]?pMŊG16B-Fƈ4?SdTaFbx..w`h'KLvdܫX>_JE,t&Ju{~HA.8+hAc$kTgkn4q6[5xzttٛS}fĝfǧkH + oh +P<3ߐPMh\&@  hzCy yq_EΏXj:MhX4Nn +:_z~_۲D'tO2:e;Fʫ*>DH̷})sH`w>wvD|H{GKT; Z!XZO쳲9_hghgɛ?#6]A[I69\}h uyW;FQ=cgH[/ΣZO_HhUuOn=jOLt>]wj.{!*L=8kwyEtm+\Dj,Zk;>EnDre$*Rh9|ɫmͲev|j D.z(HIuضcauc`]`T4RW4]6hnGDŽ3t;W_&XEè %MɸA5Vۈ4G8:^zmD4坣-m!\Wԣ/ljRe ʮ3r=ۤFCOul;z2GJjg9XזryߎZ BzxT Ry5x WA|r۠;EXCj;K5 ܵOM&ȇCO]]uLRϢo ]_.#3|Ձ%9rt^7)8Z37]Xn֯4HNM5Ww9BwK$gc &Q 1KKzQ-OY5Nз%IT}f9s ,֢83hmzjj?.|0kbLK62k*(^/4ZFBg k%;<&$mСpiӅܒΣ=t? +c&q4ڵyϗiRJk!i2`_xECfCtk!՝>1Cl|횽㩦94oIGs>@Su4gg󻞸sM]oqeV4&?8 ~&S7Օ:{BĿMpOO:y&TS*Ze< y2ŚDe6 DC^{&~ @ۿ\$n8sK\$x {= +b%g6DΊ>%^B h֫nth ^Xh=X NL +D2*8'VVȫ]s=zNӬ?0kQRbK5HF嶺i<73 +bi+M`O_`ɂ%yh'[aRnx4~ u0lz/4ȠWwd*[ NFw_NxZ/v^C=ԪnAo{~g!|f=%XT㱛v5tbpj}Wѽ'Xk +BrǝlMf{:$vv7nFb={6ɑG`͝=c,3Vts@NH̦A2?e췪;Vz0zləb%Ҧ.O/+F +v:r͟|bE0Ǥ.G~ \۵\ӕE,)gYhKᰇdJCW[i VZ$wzh2l\ָ)MRVQ_.$>u8]#57p/S1AjA.;$oJ Զ1Mm yZs@O li˻w +5[vFIu=GЂ`O={%>EnMg'T[:XͩOp&yŚ C1ǥzO:WЊ:;c rJyl@Əgb +ϕk{zb0yNYُ+%94;N$6Vv8hQ2ܧ]g: u:?l8>^w` B7/EsrmtE#h\>:jsMjdD1=7{i|؊N2N%_J_H{ AGn,tzHH#+mtx?x?x?x?x?ر CSCmDon>sUR#SlmOwKI]9 'fEVB>?mh$BR"DfM8M1HD +f&DǰbJ.4DJ4|L9B1oIy=U͆0#-yU&:F 9Hc$@ϽrX:lWAG(g~^T)=J*h*U؊u:{!w.V)К2;)&(:]L9Ow@>5chcA`VE)UF~J-ڒ] R%9k(x :G՚xN);(t*Ĕ[r1lX +K _ioA紸_Pxo,R0l 2jHe֬h u }y;!F{FN7tIBTve.ZV767R[7;Yr;k27k;b˨a?R\aiJ0 [k7];+HvL tP*II+4g'R2tA+4UmABW< c"'Q"dlR`NJ}SKl5QTy5r\b9\ >`*F&$^򺪃55Ǧ26 |K9:@"BjH;JaڢxyrӍE` +z(BrZGƂ:N%Ѡ(P%b"3Ȝ7RrzU|?Zň^+A( !ڈ9[YJo/EPRL RX[l"iJGblVo2+Vd?hYJq.e6>Je.T}v@)]p6.12%Oǒbqd*;tR^z:Ny5]Bd +U쟠pjnZJq9Nn"k%>LthG*+167:a3~Z*)9]=357ukS+iRl^1ϭ]{kc@D;:Fj [_ۉ~ɅrQptNt#qS7A+12.59n&muo]WAwd,a!> 2o.7!`W +_ŀĊy&_ϰ2y=I|x2ā^f6t og?BdSh->dyi._-tGюq~e֚ څ&D?^ 3֠c&ؒ I6PI #ٖ#hRJ72*̳@7r:`[r,O2p0yI+E䰌O_{&2'/hCЄkjߤ]s`|.c(XbT"R9hV'g @1@<ۄqZԕ[BG,: +7JX#04':R5Mݶ f cpB>C)9 TLF_:`kvYWw.a.IN*9vܖM0Wrs,ѥG}* 6pIdVP"0|tz|FPWcH\XY` j*eO"1FE1@`m7c@BPu#ƐSIU7ҘjӫS (S͠#>s(} TVd(mI#:wi# Lc %9tGE?SO1)qݱ bDϤݔB,p@)$jᠭ̈/'ׂW~_ŔRQ +:![ImYHm lz%w%6B8}բ~5c.{Km@bWµ\~/H|ՀiICtn7om >/nh: +WD;J9̓N,9K5 +t&~TttkWs:AC(OƓ2k_d>js՗_#0K 5smi%GA7lt IY\2?(1BrB:O)> +RRGI㕶GR1y?:Ca3"Dώ||ڵLrHUv@% ǧMUj6R_If? + ;2*̑RfK/eݣA?]\T24%m#ړSy,.1]PT[IJOA͋pmI݂-Y*a_X!O)H2RXВVxcXm!ف$Pyig뚣Xb 1r偱b͇A hĬ{pP(kwA^ r+R!qy"(Qy-Z28KL 09-Su-4R0HcIs;?~O*$ s +Y.oEIUw9 + 5#~>s eGaQLR3ǙfI㡨zC傓iGd +$J1 1I% 2˜'ZOiUu_F:k]ɒZ1ZB|7!u{J&uJcC aBL&$/f_u}(~Bh)dF$xe-*RL6!$Z!iJaz dz#Œ:] UԸdU 5": +6 vY$y`RR?l0qb$i&l,m#y5T (5Plۤ>-}$qӏ!Yf(3͠4+EKE)X 8 e K@VH]Dj: Í(QO\Al72H렼sP@㣲1ِUtuKNRG| u#Q_ +E9pjFRゾ  y՟o E cq +*B7aÇS>E|lQ:%kOEA &z/m2@ZA4ԇ-+@*U'A[}$Xjsj{uChӉor1U=X뙔P4JS{9|sw~˨cӵy @3c+kn"Ua5g)o`BLnoDžm_/4Uk [{r&[n̗?pۿtVHJqpԥZ%OJi~Lu'&Kg de.؞zU u?ǯ|COѹIC͕\>΁i)"]\ +"ȍK/ +&lФ!_85wg9(_?0N ]SsɸiD`R#LNŴMt +Kק@~>&s6^W1ǟ`Ҵu'IX 㝳FVn]R~(M<@$ԫr㑼7_[VEд&v~,u4u7A +7,L$='s9Fs!^i{˩D٫DfҖG9E d6Cs\ Sl@"La 92!p^ćm@MHz-O~ek\!eGb.GQ0lSy? H ԭvޣ nR`,FSX<8gWa"sMIrӫ`2O0} _1d?M[c^[n_ ^7)jZR̝Wri\8۫Ӌ|׀O$#>]'?GGqݒ>a_e /TErDi9s1S4%qL ftFc^c6LMJ*:(HI*c4@%0P +ܹqƱ+ +MM( +0>~J:`9U̟MVh5NY0U0(Lb5Hj3d ("30W)D|}+s'_gu#ȿN +hyqGSEy_7|!ryg%_(򺱂ly&N "c(BSQk,Diط;85XERrNqh)؇ل1 $l"k^VJ9u +C><|(àHe[<%0.:LӃ\s<Ԏ/$cw߬1ɐdpN q!5PCgS2!0W2?m@ B|fNi1'Ĥ!5qt(I!Җ߿=&+,BFa˹rg.#bv}A%Z&sUq ؆NvWJGMuːǛN 2N__^o +{OˡF\r-㔡LvoQWs2#$kPǮi- )tݾ7r 1ǾK};En?NF0(xZN Z? @ wh2?/5sQ&F2A&q~4N wc<!}w&L5ǡ17L}&f3R#`^.؆ʏ}=2~/ss +gMgȩo B\ jRdl,AMA=8L8T j6_jWFM|EvkcrA5}⓹ +TȨ]tPzP+߅njףUDD6Pt7U\p7P3%uLrS@܊(ALNcnMx&vO5 蕀<p~ \>|Xxr&9OP&ڎEK3OQ ǀ?jĘ-~S.E4e;IM{Am#m]N B2]@'[%-/rmr&a8 +rXb@ɳab*W+?9^MYM0chg ԁ )>ۥD. V0@z;s} N-gPH'URJAe9< { qW5!585l72+́یw9;n/D#J$tQ T\$2s?S?p~(XS>~q46PdR7"(ya? x#zOʡ:ڿSۣ@=r1{!o5,;_q̄|!(q ^ƀc&`ryaR%ngJN.>S[A  x0 t\AOsjz2'shn`'\ 5,N>ZJ|P=}ey"8ld8n/\'s?DR aO7PaO6 MQ]Mf Ȥ~PCYa_~-a8BG -"r; ykǩAP%;85̟BO+"(BSv^*+_ qa$evTS.Ԅq"Kw1E;;׭G8i$qNhϤv둉ꐗ\,Kwhya5%ym2a4x9䏀NCX^-=}mUA&R!2`;y>`2'_rTA[5 1Ǹz(N*Z&ra HP:;~6A(uHsiX$T*˽[N[=Lr.l՟jGK95;`)[DB ƚRRx(ȵ ).0B=n)KWr~&m9%(~BT#H<4ca f(IT8_U*(+3a*:= K&zejvAМD^QJ8Gfkj%P!؏Isݸ[y))(7Y'u wD׈ox]`8vp=^Q1EELBP g*8nĠl~gS *@_^F=_(+Am 0͡x\Ӗ0J5X] +ypȭH4{8;6qo#y)9eI=reo^V=-=^ĒҔ#QjSoly +LŇ)\=0Fl63.JD`nqVI(nI ɟ'J:ba;Q>i+ %q^A A7-c95SiL|:X&ub(ڑݼ*%ujBߏ.C_0=\MبMlՄ@Uj!s$U=p(uUL |;Ŏa:آ~NY/y)q2#z(s>\_5x7 jG[=?8.`WjSB ؠF +>(IκNrGLj/`}s8fہZ>ܔf]ڋ˫CDS"I >:Mz{K7=*9d_hMoBPO 6q| r;`(RImI72!*Y+95]+A>6+Wr]'Q%@Q<:8quyͩʻ`/5Џpw-r+l{R~W9N뙶y*UkhGhd_A03#ldxߛ+9'ԇ8$[G+r%}܌Nifo.n-h*t:i<r- Cل0jf"GE+BV~X}Z#sdƐdcx Cj\T?_>xx +`v3]e^ j\rSA}jC^k2W P0O.MNxP>8#\vQsA rRg|UKz#`f*=P>r= +\C!py芝3oN \}೾Z8F*(JdKКAIU{mK)1D攚rpAvJ05۠dīDXF.oQO<20p (K=ozz\L/J3?\׀rkK1g +.ܤ|W೸ w6 +xm\\O7uA!f.=G>1uh>~hA8l&uP1ҕE[wq/=S$8r~ W.;[!zrofTKuq `l{g59cB y~״E\^jr|aqsΏ:ԚFm u.Ŝ2[A7'F-x:Ԥ +ꍢ~S5c_E.N +l IOJUȫpkrį )`=\82 ҲHoр\(햺qMV>+1e;D6ryi|6_6s}nZ1nmxEX#v뗅y!8Th*[W[Ctw +iq땄"ԮἋ[!;Se "|ru 9h:J.s#zcu (G꩷8=rKӊ3&Nُ%[qP(aӁymp@y z7Sz})L@ơ{:b*:J^ Tc9>}+5􉚺/x)PX|=g5K@ K╳ )P0+0`%pqSO`/L`fP}]ʠj$.FqJ!(sFx 8<C%Uױܳ*NI@Г >/8rKq^I0uLB.n圹n&n~ҡn n~f0"_3%>r'}"~2m@%TN'őE22$cwC~Fr3eqջA3 }:Oou@sIͪ&6%"J4d=O2]| ׬ +v&񼳊˥rY+GR*z* +aԴJkg4Di HxDLNk2] zG=zf>D?޽֝Dw-yLaIVZt_wY5̽&^Z qv&K66 UNF44zt@ z 谢"^90o'@>x7߬jiV!*Pp^/qk1u\M5|!" +.|_dIun]AW,i>rpYdU)|CH&% +3Y +퀠Z\uF|*z2}'K]$51_"yYBj YJ _])ӡc߳ xkU6֑6-u\bIg15m(jǹR(xB#}G7a&E>'2y/ ysDy@|1$0Z$N> +O?SL¿/D$W^h)iVlHkc@, +GdG([$k1YlĵiT40'j_h%{Q~F|T+iK3ZIzJԬ'N6bҺ'A͊~9%/VD~_+;Α/$tN |+&|"* ]rAa>X2'lfkXKEÆ~{Kj> x49_q)Wo]C!_|{I]E?^#]M_3M< #zUvue-c"k" ]Jl%/kNH6&VIF8$bL":_UM1Q͂(W2X+Sws k͐nN +( +.qN9𛓤f咞_i{7Uq 3AK!a}DҀ4YAI1A~%o2k)6_i>).nYZTi--7ʿ*~|AmI^9U%$cIi~YIAYLMRv +.Gl&kB{Ⱥd}U뢾Fo悒?̈_,_R>^ 6xJ?UZv=|j*>^u[<"*z2VQ'~`i,,4T4ʜ~&a~ϻU8$iQv "!hO˼jTT\V;ɚ*w{f·Q^E=%-+u,\d6`on;1g.F] +;y5#t /qrwCH~&vL[@&|Pn 1z v ^,0NB 1k`і'7-><`pQU軹CV]bHC=SDQ +b %uNݍИ|Qi}'5n3)h"fuy^?37w[gFm"b޻yx j:$T`H~NdFSag¥nuem!7|F7 XsX2㻶0ktEYyӎD !U/Ѳ*/ˎQGڟFVZ\$t vV'LO~7>&w' šoG:'ؓOեWLTo6NaQoɖr +(15b-FHTI>>~scB0'GA“d8?-| ( ؕb7[Ӵ:4MKS!o|Ԗj=iZQ"-p=1OR/\˗_O<$G><9"ZQ+Pa:Xr16ֽ7έ769ң7QR|k;oNpzxpKxZ<>vC^or0^>.GyQ% 'H /I7e7S̭fF/ k|v93\sjq'K;% +k~%*~56exI][S?kx8`wns.R=.^ J9i'xxל5& +0+wx9=`0ioGw n v _e'/*h +|hX?YZ>]bsXrsX|KGOS?`EĒ]sf%Ůf E!ⷍgDJ$I(yvHZxQRc/ҚZw +Djyyk\z ~-iXr1>D8" C$_vg4:EFԺƞiI`:꜏vdE6Ƹ{GF:oWÕUiӫ+baY%Rc홡->&YuUQ~III} + yUla^^偑NUqn>ޱTgVodɯ3:#<-̮.W\\`coYCP,퓍|3}2ϴIgmDe]k`zUir>$)~͕Y/=Qg/?9? +]Vz24l}|crYOEs1@W%zAE/~9dTz)=tsFYz_y.~՚v;q7̢ܤ=nOzOOΗZ#^7z)01\5cz Tᵍ¯J[8|+ ~oF ?ND#&fYS֠u[U38n G5oZ54K(1EAn~=O6:dsGoKUpc7761@g5^H + xMӱMşj0nuan,{3Y\Rjy]e4a:zHϵɛЪcwGhf +YC-U&^tCbhMK:EN1M.Mcj_u +9,#LnTqg ۷߽#hn;S˅h%Y;lO;3kyεawss߸Dw)wI(-v{QSP./ ˥/wyx`RVMu yCE5+˞gcO)fѤa3>M>i. дKѤKDhʘ5hLJ wEĄPpRӁ\M)rcBa_طɛ.ƜӪ9$;{H+ò]zR4Kqeo_`MJY79wӶ#̩[ QqT|F4sp $4Ca=v=e=;k/ZVo?mq4w]DY4kPDsp?[Gj'h~`C)OyZ-kLqK oJ"*"kl#jbkJb` ^$M=<8{C?:9 +)M]}J4sZ|vSw#ii{[a-EOzh;e+*FÇnx}YQ.!\{}R[CB[KxiԲ{_ZϦ*FS1Cj>s-@N״Qьk6U}c4Bs6*g}h7ZDdhLaw3TKٍToKn^!1k{! qam]mvy竣C4߲fOo_ =DJHiB9O{!1+?{7n=[ܙ{тEZ8Z +-rFK5Uk4_iVCԞ+yQWy!A]z_=9/) 8gˮpyHWWKg^op)c߿) _l38ۜߧ+[f[[}#&B3cX)5G,'В=hQZZUQ;n]vFqIiKI}CtWvk+s ~Vb:Smtm|Y]l\kɏkV=_d 5xgstşҤ^)6`;i>]#ZHiZ9_xր ;oU+M6lqݳ;8:j16\eYc[gJ\wcBG=-,ok?x-}_RG u:W L|Y7{7;g/-)hQB&Gr6Z`ܩk1o37g;Ɣ

9٘Zdܛ둧nĘ:Ն$UXFFFrH8?1ϣ:.e4}Z4{>Zٗs]]xR |wfN5eSU>E=]U7Ğ3Ğ})0{1Z|89`'] ^)-.t1CN4g,d4j.7eZZ>VheZc3|ۑޏvOգlV[=o7Z*oN kղUogjd˵kYmzVhƊ X`|:"0 +cgʠet !!$"ynw稊. [|` +ܞ_,54s&RZa;h qo*n󫙸;_5O%u_%.)*G׋Y'oT:qg4?a7a| k1xR͊t|J60(ZAXT}^F俩30?nT;}n*L݇gǘV7ת؊R +pU Tֆ>gx-As窠M&hvvh׉;MQ-dWi`OϜ_+lMg?~gi}gyڟYwVj=Hr3bt| m7Ҡ2nxskBu;ou^Ƥb }:FIf=I?'}ڪu!vܒ8߽M6lkh#{Oܙ*aۮ% ~e`}g%؝efnVwum<1$ET"|9=l{Zmڏ-:e5wg\|c|fU32=y;D%1IjTb۔ySASD9E9dgmBm5 KK.?lS,&@K8~m̝ٓƿg>/e 20x׳֤=+cm[|^bA'G֊7C3[SYz<"J6/*q;y}i97FshW>2_^)KoE$yhhąGoE Whۉ;÷]+Ҩdwyqs2qC%׬Tn{íh`?=*1*`y YS%8_] oе1e6Rٱ9?aٖD9ag^+KN|Ǭ5kdر82?t4Dx7]R49E}!"d'9I0)a>ݰH񒬠 apq&VQS ΅mx-ъ\>}؟v9MVqmf|m S 랣]Q |BVe>?ōDvx.<%mt6;29&n>ݹA;?thG[Ͽ5Fm"2}aDVC,='W2&tiz%+,6+-r=%n2[Dz~"d"6}.wo3'D?@kϠg]R_t"vk`t4ȄoLq D%{Gk h9h璹h7\+ }Eo${O3 c( 0KVߡ)JҢr7Q]M ]uA\tHm?zW=`U{Ԫ`ULq8YqỏdP?9JIOd|]K @/cuP CV8kqɍ{M.EMٽ[ W6͝:c-mg:3EzvTRQa'x _p=_5> i{5Zcժh9r hVV W;_OYzgбFΩ3Mn,4Iorw /v FN_J6qy1bc795:=AGCiދz8^Dj +P.Qs1[ȈǛ1oi6|.*G/7ϪV8[1-)vU_Ԅ*+!ysMu=w^ 54c26CWl!uǂɚM~&|t!uai[Ct#^^t ztKpx)hnCFHDfǹd,6 +%  k<"t+ᗳZN_\ܬg^%eKw2Wg3ϝdR>*f7l04TȚʼMn]]0W]x6H6{ 3?XkENvn6]rd5-920a m#*D=χOٯ{F + +=m_]SGf ŃZwvd,2pԛ9|"6?kj|;s1u}[ߴmQnH)lCfvQ -~\V~ЛnV>([W1ngwjFzAP50xbMY?S6<8⌢ɁӊzhǪh߶mHgȃF M}_vs |oIϔ<ϤeR{o%x*|0v߲HUfSNaJsO(yA[$ J?\"yrPZY}wl{AB"BTϋ,bH[3c/eO:1^! |J)})T3kD;TѾf(LnRuk,!x&OxN5],uMT”&U8sͥ k_*xD`0OgRܳ.61J<3q"%f0O虵8nq _UMJ7RTn|al3ԤowSgæ|A&DL^ +b,:4LMeڶtڳAsGu ϲ,=%i0~?֊fJtQ@eRNs}\J4ѳk okfšģ|o􏪂_Qz((}^  ymG1Lgq.3zj1tQgtQg.M6fϖI*-lG.7&)To=Rx5Yީƈ133`n1}pEEI:db0j/Ң3 dwn j2>vK^z0Ǣݩg繈hk/Wԓ ugm"ېZNN'#gf{[ zg6MWvYA85L_b#/*&6sDuU#h44SB#>C #9]&AⵂD%=c@MWfa1KF蒒z͘DN_̿>8C|YEx~+}Vw̴}=+51k}D[pQZVOX?CZ4)8f3pمj4^?؈3 ++D/\:ӌ:j=8=\t `, :MyTArN*KR}: wEϜV=6{YzJ׆g(y6Jj2jwo% +7Êכ؆N;1],89EC-n S,'2zHAjQyM2:"nWNκ߽ԵDxVN U{K0[O(w'\ +ZR!̹?4<0KsHKQ<(ȟ`[rŗ_:xn1O{f-'N8!ιq<`LZ>#Wqe}ԭ}ѭ۾eD=s„kjpY^){!oOZOCy_.LP'RL2R~RN[U"j7mK֣]6#]#_6LgD!-3FVSa xFf-¬?P 87*Lb~2YfvgQKMF;b]3}19fbn +9uRQv#?j_02zCsl;u nYAߴV}K'n3I)cY=a.'L2rmhOЮ0^r +i;-qD^]9t0/!8=L?}y,Hq+QqMۃDG-2Z&J̋/Lɳᛐ\AD duGBAj^"Lj6&Rh/y|9EuDof=89tD?q3f#`$8Ҟ+Z/qO9IFe:P 6ŦIrXFG#idi4-cq1w !JrJ!ޔ۾~㾵֩3#Ygʌ8֜}Z{U^{-:֞O: cG6rEӟtyw+Jų ۶ț56t'[x5Nóx~-nM_3wwUج=0XâIQkHqZvT9tm_uSfͼe}B_kؐ۲]+O_}<栤/m&vM?u6-{آ89nظ{]L1f`}vc'7x5ũO0pK*_F3?,?9tߑ+Bkw5 <:^-{,]gƆ)/oL {o/oX9 dP6熚2㉹|>kJLԲ1f*KG^CYpS#8{C < +;}19+1F`ɡdhSL\^ZKrŮo+O=lT^YENXXc*'9iim=6ۄ2g7}^1NA1 +<Ű#_.dž_6ǰTwFÓWk^csu lyP?1?Ǝ`tspmПnz0&Ptk;alI1cR,m=C_qFR{?y[~ 3|^;M|Ow>" ~;ػHwn, Ƽ7:'vN#~%AsvBbbn&1Z |k"o}˟FѸvB1xijh~z +<.g07H >L3,gמ^ŨY\ywo[m28F1s 'LĘ w,;aɚp qºֲ7--Ro]:)rӗ`q\w*-%'-.C5>cɄ(~sWP,U-Dv-J~RNgenOd[?e"|y:?cO/r$!<l)m?'UW֕]R6lDr `>ĺk[oZNSmrk΢iK=cEa19pQn7~7M-ηK1僯{}{n| +a:#gBKws[,1uЦ@9vx﹯c{<׹xSCm=;&W>aѲI  ladʱ Xڣc r?#rזs0.#yP1wdKWc:aZg/XwbF->bC P.X̧<]7H紆ۓoOiy12ʆ?TB˞\x[xc01!ԾD!ջ,rF]su0m1l?x1QE-wNE`Y|̉:Vdu%AGж`V /8Eao<{%7a3<ÏR̻U9;1w_OZ~Mr׻<ц?PG~EKL9=1k8; .{'EuהW+eoZPV߶|y`VR4$߮kOb@kf/hbgR^y m +<F:]K/_6o{;l3j0,pV0w^}ESz@hkNܜDxI*a|aLZ_,زH7 u\ZBG^AqAtMxU9= +˅9B .gjdb|C-b1F`3B~[ k`F_,GwD_]( +aMZbT\`ǦSz'aG(&1u ;N\Bx=Nw7e;XG|3>QNW| #0V39rwql+S)sȡĞ.9GḌ?3Gy|Jh*r7tzd2i` ߾/}G/yBlۼYs`>ʂK6cɷE;'N&ͫ S]&_%RJ2.:.l_2tY'cRe[ΎݽskF0gT_e +c1o}A~x 9zt@?V7ܹ eR[=8NQ'o|˛bDWZ~?;b? ?{߭<8I,оo¸_K֓)04yal0@_{Sc\8ͧ7<盞|s]Ƶ;.| x*j2d7={ȺiOs3BG1?|o pI1tpKIw)>\% Xm+N 'T07B c~3%][W* $:&aɔwٔ9"vÚ?S"kȇ3N{kSk[|x2dMsv&I0w"ƥwNj^EMky>~1`,(k>1x[ wN}'3û߿bQ_A o9p}W ?v䓺nZr崁~Bÿ +i]\Xzo9e=sw(Tq!|37pYC4uq& keOTC"+]Haog͋9p]6 |O`/BOF}Y$뇹f}SOo8&B+{qyƸMwmfg{\s=&Fvv`/UFƺ ox +{[Ӣ2?rugkn ozm +o>zŷ{ڦ7}?>F3]m`b 19HbwEknQc̭ 4m|pgE]OnΟ b!|x=9z,[kjȝzT pMķqK&@mZe-yq)ފMgE{9O}tkt7S.;7޴ _̱dʃ jbq>:-ʧuw?L64Wykšsmg?Y?m lhc=Ywt+)"7qá+Qco\zu${0It E׽xը+`"#z!-_s"{M{?Pm'&OWrpdD21.'`^^ӟϏmyNjqq ?9) }k>Bq1ߑ0(/._36W1TO m}cnn|pi>X\Tv|须ŜsOgŸ0r=7ֲևA}ok$7mga\U'㼋e֝rcb\nʝGsG?|#1;kZe©BK&b<N'Se ai4|+#s@,t&<3M?]9V(qצ)o]ټt7n\s:TJ#wtsW~9_,wWḙʴ= sGҫNrg=rq2̝TVWLyp u,?Eϝu΢xFĪIt/\yFq۵rCqɘDzqݣc,U _{OGyxV~Vcjߡ4jU>5G n:w>`ĝq_qFߋ/(0f/;|iâ'Dw}l7keBm Gznd Pan@]'O89l8r/xVl7.ۡk9}> -yk7̾rg± A3weF2vaS _'|jL8qʓ}'G'FW<sqS~5.{b䟡QS m˘n==}Պ\C964GsJ1wxgNoQ%ꤸM=%Zs*Pn .𷦏\N 3IFT9-bBy}ϑ&c2̝6rgrg5{x/MKFm 8w1g٨!m\%Go#ҺDʽ囗=t.xh6cnS>5ڸ'͛_&j=S.^*DbX̍GAv@p^]>s%b\=HYm$1q/ZVn#g/0'vxFhOY%#j֗׸s6<}AGrT\;\_1ѧmVK~ǺN[rgQ'ʝ;kn̝u|g/Xݔ)wV#OYYYi#w!-c΋>}1`.ea~s+Py;"wMT3P,kDsܕ1ec,{"zcć^ ?/:m5:zO +[-MD|fa21rɸ700﴿ 8?[` +=NCy eoˀ3wr=wVM;eotXf󙾆l;ƽƕ{79[=(Ϡ| 0/ Ų||y+Qgw%OkaC~~ƒGؖo_yIc~0e oc)`]~Q -rg)w'7Fѣ_܆>hP.uWXh$rIF,\_œ_Sb_$ ?ҵG~ 4ny:]Z}uu<?(o̦<,ʎ(&xk<|>(oI0}xоOo5s\v}Xfd᜺r7ݳr +ܿHЦВ'B mQv1Wl<N ֻNh|:ڷ+>s O?ڵC.8ȸW燻7ߘ>2}~@.rqKHF\< vz2\]o3qcQ~5{.FӼiضoO9pp}S)l-PSw#`7(' +]wq| u}<"`x̋y~B;ߚNcsˬ"YtU_ߌ3|_oءOǏ6yj`zK#==}`Sp_*K;ς |y3 +=4<5/XAZs4ʝBp=N/κW˝ybhO +2qI9[P>=!|ƃQGv#xWtV0ߖS>n< u=浘|`ַ+RWf#P/zXǽz-wVh׏x}Qd[, {?R~oh_qB{\iz.N`_6rgmw6 +zc=vWhقzWwQcƘ#YhjiXއ6;s4l}@?`{쁷7ٷ+oڛT=TmF^[bKhߡ)^W"ygDWxGУ^^/zR̳kx,GYQC\qkb^yMk%ͣ#W5> +׸ބ׮#>7ܽ<\yr{Rto_O?-l|賿 p&5;&O}_M91-|n{u"{B́z{|?TwL]o Lzkϣ.p)w?vA{='=Ǣ#}0:hD_A9U@۴}XA7$#`އ<59-<aO:ۍg羸sp\z]ʯWV @zΊDK~$p +?DJ{qh$pSgYˉ0 +{c;_p}~y"zE畱?aܫ\_KM'ֈ>@[^z-7{OwG74x,فc昖xυ;5y%G3ҝ"\os +u Z0șG3V[ iﰡ}~]郭wPc1Ȳ x{~&c_s7{/9xx}E V1C}'G{f +C{htG= [0fÝ+N9f.A_HSb(w-DW+lG?q.ȿQ[&# &|S+v9)0+C9c`[\k9xwYk&?Ə0)8sbqXtn=3OP/16uHaP?x.mt0+}['pn?8UkLu-7N1Kό:*;tog*)F4uL*3:ƣ1}>nnδ/̴,B T`*39E5_Zf"?zxObNwDgSj1v xjEgg rOw7\;@4=F6IhpcVA"d lŮೣ>ʒNqIw%tc/ݚZluYNtGW')`D;Htڄ힙 X| (&k/ X&cRz&uҴۻ@tǵ]ŵ]еƝ XF%dV%&RqXLƭZ1S6QOmVbi2 *޳uZRHU{{zΪAq,FksL2us6 RL-ޓ >3Jw7{*v[7SqUȝB_ښNg,[<-jW +4Qǰ+Z;1{ Лw^ޕLt:-cY(ΞL|HZKRs >N1UV)J[l!2v"udgYL[ӎ>CC{ vJǚqū-qіCs, 8dGD(jD;;"ls◙dfqG"|cd܏I.tE([Jrx,Ht/J %KO%*t.vGãQI8UөDbm:?"_.`V[d*|Lmu-1"%u;ޖuNENww-Nҋ1[/ws~Vȹ۸i#i.OCu8vڤX'9R[L/U#rp,@"8F1Z[ &"%se$S)Gm& +;U2VIOwhiq7.+>)EJ;(Ջ㝝/JȖ_pԑw5T$ 8J[̂xW$cɻd.v+]97:G}vġ*[%sq\Bq&^o8DZTq>|8?3[^2wE w)Uc;ܧA:f?ڳ"|Y{z=R}qwdJg"pCk<պ AVxwr2iGz Lw:Јvgdg"[w{赵%3ɥ gBۓT!>ש1LɎQ)wxqiufs%$یc73+WǙq8S-v:|rLgZǍ8bb8:ΰLjqq\Bu)F:ng +E>UƵWj|`JR,`xBQ=J/Fcۆq2r^, +\ڟ#%t 4._;_q#&o%Umv7[IrnrZys[)q7Wwscf6j.qa19˾gII$'cIN"u#:vmЮ/Vb5%'Rux_saGi,mt8DK> 'n70 :;c< =~7.YRXlK';ͱl]xfVVbsٔd DGz~-*RH:"?%0I_ck~`4vn`4 +bEZ]Zk{ K/8^`[2?=9O[2,AvE }gG--%g;Yܑ8JIEꔒ$ASǐ=8vsυ,%4wv&Y;3 Q*{7K9<{sv-s-ξg)ݦd{{oO: wWnvLº/Ш#חH˜bJ.Z+Z1xcs: /yP"ԍpUl"tD]ѱJRndq٪nuZ cۆqժr^oq-;z},sPڇms!AXE>W{݉uqZke# sDZP,3:/WF+0SeɶGwD!>Y㣎ej!=ʨV\= L[,}[ +QOi/(e9"G Xȥw.֙xNOY];؝i_&idn Tgʌc7ގL|iًqxObNwDgs "Ԩ#gh"hij-lҡ*0LuO `~&ޝpãx +&5^/DqLڹN*n4%7Ҁȹє{hJ#қd80%pDp:]=ոB+B$F %9Tí$nJtU +Cxػ;>stream +TU喻Snn;2h#iæ՗W0^ަ* z:+X˪{Y<U^"D,{*T*.`,FԔcQYT(x0 @/x/HP=+{y K*i6+ +'qJVD p) 멀j*^xlI +k%hUYI)W0:YU"C0%Ydh-v1/Z h&{Ut40hO!~*̪pmOAXVÊQeC +r}LD@?V!2+(B֒,,9emMig\S f]SļPה~,Q\&|66yH 2pf +;lH49c_Qe9 zJe_Yx_ne$mx9c6Ҭyױ8C@gDQK8.ׇ<$ 1G/,J؍l=< 5p@aXu;{$l Bo%` 0T />5$zh69m p`׿c?LqBeu+#CyLA p86nUËmhJ54DmhЙu 9AC9ă=0dVqUTT\xRFp`[f*c  V]Lpm.<:}CTZ>UÊ:&8XMpv :O\u1c) +>4&8XMp)_E"8 I]T6E(F@p E!Ʊ N&-(dK<ʪxU9 S5HNeC"#`".fPqя mi]\ ۠DaINC҂#y4^-Ia?1[765T6 +QnSIADGnH9i_c/)rЀօmQtqel3xB?TNhHRA$ FNY=1GKs]c~91nj;U!z*hDN7WdkoLM9Aup xUcal +s,#^ +Ί飡yMtM0CJ7jP?-ztƢk|q?V-ngdc־]o0eǻU9reN#{kSx +JW .UÄC0`[(8cenxfkxX鮶c:Z[Y ΘY Dt0QGƄRp@nL'.fE ӵdѪۂHV]j@fUTMNKT9b`oԚK2wOEEKy$MaWUUvԧ3fA(l/陾0OۀicKAI<9*# ysu6О0bӠAۖnI4WSL_*l6t6\8%S̲Fb;mF xgT+&" M ˵Ba8T$Yڨq8VX;-˕c@ $J ,%s(8ƙ[1F駫*kۖn9!Z2QmF.sW( + +I"f{Cw0lm+0mxU_j.'\p"065mk]~2?fmM0 G.(cb2\cvn~a8[qAMdʐ<)me\$NN Y!Zs`٬mS<\8'usvbtYbt 2:N>Z ɪWoX(V5g1%_/F5A);G]%)<#s:.Ж+" +s 9˲Xr$lapV*X0h?s~ cgN%B~#G^"k~ +!9TDZM~ cؽey[B]NF>tTcYԘY  v0@( J^CbZ>Ä~gxeE`x=:#ʁ*P +'Jt^-̳LRb%S¼;F䄀8ɲIsY^EIJ4b`xJv#fbFYW +)xRADgNez'`#YTAY@S@,kkmEEx0H ?b=Qz`B{Е5si;hYN%g%{#On`Nif|bqC>Ca䚡m dK,MR>Oh!hG),U=xG7 Ab>֝9S- "\wJWh{Y1c>jd S@vvf2RzXAjӒ4#6uе֝QjK :*lΩJcfrԡH@\E*'NwR*TK!(O¸WyZ hS۩<]t+-Pe,kJ3\UZͣw?FE 5|tMiCӄh s ˈ{ Py΂LeEr +V,-gbc,|:򨄤J٤=j`0pWTlȤHf"$ˣLY""$;d/˼b2]J^MѪ)fLAYj`f,8 KZN<ڐe 6AZ[,Jx`qY7v&Mf6N1 dRBz wۦBd&f1O^۽N&fhI6YP̊ d&Ȣ fTlbo>/&'51 ͉ỉCvfь3)afh3cT,2+Z`/bsZ2p0 E>v+.vu̢12kCӱheC ɀQqoɄdAN_Y42n@Ll:m:ra׿,drcHW,*1T(J" 1Id:FK- +(X &z{B԰+\ 3Ne, + +E"C'2:Y~oȄ$AemN_㭶̢vQu(9q0lJX4bHQ|As_е_uXߪ2Xq~܏g ǡ~f+zyjz Omw1-߇7ei' }5gKDaSD+--`cKmhes?i)aƎ\o$| +m!nPɼ+wC@vh[+Pa{ndoRy,6K;~Ɂ`:M* uCmt(1Qo`JI tMI7j(֐jdfMv fy۰AT ߲jltsCby[:@:M޶ Z l-dowRO6Ⓑ·1ml!(5D7XP6aED7ֱdZ XMlp![H6Z:F`kUȦl%Cc6,`ɦfv(M66Cl,eéj9u;(E·,u6Cؒ)YdʶT?rf3!lX,eʦfQv(W66 az )[MuH[[6}N!moY*oqipN7,N7, N7,N73jd[dj'ddJj'd[ejce\Aӱ4K94K 5K+SM| LɁrӾ%ݑ8Kd"I ^jJ 9`Y̐zr8\ e//iA"FXM9^xg"\J$쵃 Rv3j ŮBҞ7(Y:o%04e[CaU{CvU$ONXx:02Nu7A.eDQB_0byé^*dЖNqHlAjLnΆ .K`~"@*6/I6粄QEmEdm7uhiRێܦ <|*k[;Nr^U; `(;Q'-'hɸ1o D-5m#;lU]noQE3x:aCjL'k;5ŴӿcBݨnۺcQgM[o3k+:X Κ/͹Wd"u^!cA}_{ +" +M, +'[]F7^@xȽXsjZ=L{pGPpMY +_;o>_>#en1 +0Gi^=$).<%"y\(I*KNAu d=>f%xQk A;WD`cZͶ5+Ũu5y<3iTA3NEsgt*:a^f'(ZNLVX p}5FB€p^TH8aL +2-@ 2NQ/8Z H B;bqK +*I[ASEܚWQ x@VD{P0'\4`ڀC?>>i-BcU F5ګ{myTCC0߮pyLN +F`i$$4x}{M*i}f00[^ZnYX9YèZ Ψr<1|FS^Lu<3,jHșL/1kB&ƾ\rmYQY[I =#-^LK)rvYZx`*PXɏY5C0$ VPm,soVy5鬿Bg'F</ff,Jh.x^~PW&#cs<``wzF#s)(,6Ġ3fw +[ƽ$dn#ĵh +qkm6 + nwp@Ud"Y2. 2,b\b!R[sXWi+~`G_iy:) gB]v1mV!-:S{ԨHZU-LOs@*bU4Urә;[cg~KjFt5Bcߦxsf m!:B8jq<Ѯ!9 @rYUǼYNwղ8. +JԶVɑKEW!G x#W5i>`˱灑ㅖ5;OieN8m>&h ԬY?y4A@]ʢ<ys\53Y[d>l] +ڿ0[5ZUIF96xՏOCCHAe%UBS0'YPǪxT + .a%Eai` ~jf7·X%ڵw0JuԊwJ^p8 %F +}fJ55vCby;onOks=0YND:'Ak]t1v8+inʬ'TٿXg# jZuSTw7u/z% +*e2: d7]~Xtu%<*0OaF֍axFm^$W4hFEErC.E~Kږ;r-ggA3(nCyT\dd6{2^O}mz<S 1Kd?,z +(0' |CuqTEb4 NYEǻ[SlM)"@@2#^ދӌ^+z4M@Gsў90  Lt_/)>3n@OLěy/ tz%K#ӫ]_s)(?Cӣ=A5kmuO${ |xj$[ŻKsC[/5ڕ @=OAVc:}Dk/~yL؋?~6&tvYޓL^`^*Kcc&0őNYzj df( {jmo,AĬdOW*ާNAn 5Sk#fTjsfװޱ(īJ6 `DN'bţr+Z\W h8+NH&y$%SR=DwpIJMIp̾`,:-gao]I闱(ŭ򺳱g#D /32/q"uxNdJ,:;A#]PV5%GZLD=;9SQN\u% +FLLuJJ(~qL*՛,L3ĸȊ,'rxJ2'<+`MV׏gluH9, |=%1ϓlk,'2"fP;)YxPv䘮H eו&!X ֖PSA5Ɏ'zJA&p*.ELdI6܍y;x]l@à|"1*z#qzCT<栣QH>L3\Z~dPyOYQ00yeEa)ωfplM_xLj w^yXI Β,q"O Gxm N^I|&gHd3MM3{xn g̵U]]]QY#IhWV0i7dН!:bOSA:(n! UU  KrDr+@8m`$Hja _O $KRV_g?5ݮ&W),K7hIl|;87&Qz~UW\zÏZtWP&>Z4ׂNj4O3n/jdNЙ7# g)(,CBX$tbz.%<\ZB&[ +{)-ޮ7ioU)\aoKp`ED3KcܮMoxs_?𻙻b+a75a+tKs-OGuxDwpbo3@&Gvtmw+j\dN)5$ϨAgӠH_-t/!MD#j@H*H|l E>'ڡ8(aH2;@1?Yz@'fvx=jZ)_lj38g`j/kؿDkc,N;d<6@r S Y >Y-F1Y_'J0~S\ڞ#o/M`PmG'8Ym}40!ht7/8t~7z>lGVh$Jl(?dsBn;~MCA޼1H)nH6~@K#G)A&}Lnϔ?*)e+գJo2Z{\`Y$flxKxIdkbcSx|M2>D0{/djDR]1Am. +$>qO{QZ- G $ 9ހ$Z?  :1*\P"p'SVIobE-rQ*Xy'2e*Ea +0B/Tx}~pP>剡"GHHQE } pV0.za% N!|=b(g.'h>@т>@!D~tm!+~%̓BR Ä (]r_hIP"`c^ ; +Q,H~PBXԠ4"RP^@lU/':CGY& –&٪%sAm8F fs;ESh<Zl%:I oFD"b!C@;oF`KzX0Gz lȢp 0w?&3~?~:lC˒`XypYJˏFJQUK>V⠱SQ>T@#&*>$Rf]籑^4@]A IDgVBܱk @sAw0u5"PHa%(.E |>vjILSGQ5 `!u "$89v((_u h/Ddc@瓬nQfo,<`;!2 E剬#̇YP , z5I@gM$aI$5$]){a Pҗ9I`rXyQ&~v~%t9 x>DXbu +"Pa]hJ'G'`!nF p2xdG`s kL֥BD|$^ + !Ų>^䌁KPddRay bfȣM4P`ASH惩Ьc.V!-0C/'{8N˺D#x`"+F恁0 k0)-A"Q 9RJR +nǷ/XieNz}X3'Ë5Ff8h:ou!itGz +!}.6 +.k_VB Xh%NX1ȋ5ʢ]ހL"H\l_+S +k +bO/%&,, +''] >0hO.X^A\{)I첸ע~Jh}D=.Hc CN;kЕ0`w/:HcФt{H"rJHy0TVؚ PG*U ҋ + ݠcGOXHLGHKZ Cl|[lܞ, /&A`]c4whe ڏ bn&xy!V@[990E~q)hPO`p{qi!G +p8 tX.^bZJ6\ud*À!P^Bν0x,QlXA]PJ!OqLF+-r޲%^ K*7KGcꫨv0 U_q=)zX.!\%l3.rpk~mQg[+t׈%)kUZsޟ\_Ld lO6%I!4$"G]gm3`̐<$!X/~ ĬZ@'FGaXI\d-?D3w x2#X:ebpxcY0N +g͂, v[4Z  e&1' B$5$9iOlet0 ?ߔG<*0} 9 0ؘi J|*gسNăUÉZQR0 (г`Pb_MC ЀwX~ N<|_`B[ŀ〢ulBZ| /~Kp1>_84֤ž sT`|->$ϕAe*"Z"|;@=kYAP/hM6A +QSdr/F_ p%Y!GoSz{ۮ2 V >""(e)rCiD^K((Fe9f.\Jq.#6ș h;0QvȸgB&@ha{eZCx[|0<` B +h9D^'! esHځoEȥ89R2 $ *Aps0%O{-k.+v{02oڟĩDG|w$ ʨ`t׫fm]^ekmyBz=XFl*׮eg0;[{8 4ƨ*"v4oS-&1]o6#hmzx6Ϳig_]|~߄7&{*p$0|krǮ~=-؟.~^+phŶ9f?eVjGo L7vٶL;T60 Rg^4fGC-9tVC@06`h>>~_RTZ_uVzK59 ~{%ٿCJpC:Vv? t76n1@M CII1 Xn Q+35{EqPu<wꀎ-LZ 7IOM lO-#)^n58hng?j;F~a;%Qϯnv|vٓ(|gbc[,NHOSQ6#\eΆu@yCJ]DAڏuPhZ?)9`+͂q:S5Jčxfӳݾct*!o` ֺxNj78.`G\͸cd?1B[D~S?dgJ۞9CA),W   +XDSeHd`Kd75Z,Rr }_h(y4*ϋQ2oM2b4ȵzvs;. A6D ~X@X|n;a _b{-yytyc<"QFLq4t}h,Xvwjୋ +h~~a.R[ NHv@jbۉD^aF;| S?xB!O)vQMzoZ$(H}`_ sIo`49_ +Mg5PgtG7p5 o7 x7[3o{G]1oN!v"Q uKfM'*5@ÒM,|5Ih^pKbw1.1?!/b0Uk#ҖX=|}|[p6ŎҟLTf-YQyPmٛvtV51}M3hXۮQ +Fi$fbAS%(%!9;ux /X3` +gՑ]w :1u?LMyd_6EP.*}DAC:?b6QPr?Ba +L|vaj8Ww.V_C.:(h<>n&L%)jZytZLL +mJ)a3iRmъOD,5p&\[pE.!Xwg>=WnBor^,Nz?Fr@v~a5^ߞ7WU}*mi=zSt{Q\/C*Aq{Z xҌfsCGm8)M.Uex3AViB6r݋X[zr{#ۖͲ(2fx6S)@@D3F$cZv8:5r +o{(ˏh7x#JI`U eȬxg q9ֽoNIWJ"%@dc|0QCz.cÉA}o 6d ) ĭ|\?.,Nqʩ81OyVa V q=]Ah7t)ྙ, +% )I]jw6 O/pyѬ*pԴ߻ %5A(8h +?=Bt!X+&uX̛TpgFqPumЙ}zQ#}=g{IvMu>H4mGՕ}Yч Դ_X_gS_3fMB |g&=Z3e3I;eKzlɛҥI1a;ݔJ*m| -_qlB7]g*s%=eqM㘛<ԸΎw# ?aR~ώm!4;wxRe0$w뽛%;D}xgNf<|u<1+Wgҹ*7yX'l$[tiJ͢#S)Ȕxg^,(* g|M|ӣygS;||aS vjO8R0t$]taXܘ›\M}vP Z"@.nHfq.An]xO\n}zzJL<\y/Ftu:0ӥ>mJ+znl7vvx^bo!k]klzB3淐L댔31tѪx"r:Eg4:{)9Im\OcClH|yP{}QcY oЫѤ4|RaUOM ;sbbWF351:>~|}2J1&-Ƽ72VmEmw(g|j^bWJScw0n9I>DoL&}8X^M}oe )roĸaMJ)j35wL4Ѧi3,ͺaġfy1}/,a1stdKZj;K{fXi2;˲\x;XTguOV:HޚɆaaqS.m'Kz%9<)GƔ1]w;[=ڞc+f&@}-~)尻/;}s{k랽uE>6ysP#bwviw&g%vu䴾N*[wF\gf9yyoƹ.9wL1 WUZ׮xmW\sw}:L #RqnԲݭrEqވU=I]O5z]0U 5!9qef Zt?x +|c"{6lS#*㚡>Z|Ef ZTlYPTC=9 +L^*,^[>ۇ7x֘d4ƽIoWϳO9|c;nFηw~ܾیޟKLGO&igh=yGȏ RI_9JϠԨT &ͭM!3?FFX3duB^2.ꌦЬMߘbrp:mمrx.ZюV?O}"^mGuIEc-zߛ-c))1gE}^?W`c|rw]uSv =՜'`xjŇ&,v&=N|ZzӤ%2LdiCldΐlS}oT9jԸkOaŪ۝~kOGcL2`e_u̾d-]6c_r-\vProA%mDʧkyiŤlbYx| +ܶh;P(6ӷ5՗])mSSSaIgFZ,4gT3;>Ag^~2򚮺+p5%~e5jC}?Ƈ@vAVOy?z+๫/ yFj4uWG3м4k!k9ُA|)m3?ڠxu,?7Bt4/V:w"y,:r?-cx\vlqe-|] yyq6u" -#Wg_*|Ė} ׹_Bbž4u}x}ʷna ΢$NAAMO%PcLD>s6:NKd㦗ihM1͔=Mݾ=Bj.֜vvtn1v&>VojTo {ܹ?ׇ^Zni˨gn. 9ovF] F3ջ]De0 8_)BJs7,[gj.hv+sqvQ &rfv[֪GTw%!ɋn*[@,7-ْOe# {9j<볧]y^O#8vajR|^Q8=>_<ʗ\~ɫDѪBU8K'SAyE!U3{TE;C{Te튩$TFReXF U&Esճ\)J`l +X :{׾iG-ޓ5W]6&+]1sZ-YϽ3ҏ ms.T~TÀfJD|إ?'an{<1eبONx7jf v[&cYSyӟoI߳˙X˻D:bMҾ1D/ٙ krۅy-ڹtZs +1=~k3hK)4NN)L +aNWΨU}"XI&Qv4~wLI?%'h5o~]2I6}39H4ӟSzc?>kD5ǍW-41%};Kgzy')Qͦ?' I65@ԇ3@kYJTR6mX >~~pܵz_bt7D?\MDYjʩ74>"wi"b|Diӑ\R?lj`9n;`*Xt*s"9&؄?qɝ "gfFXD(k5ol)]gew̩:k$a!8,f&̎  j砖_}s|TJݘ&L'˝%]Ìad(*emE8?SXuc: F5g3i?]8n2rbiƞŪN4OF8u8Tb^hgEPE"[7l$GZyni'IX_=N 7j\<|8…$OKQLqOx$rCH9I>Cw~ dfg>=]5b㉕w^ΘA<"sr}%F鴦Noܘ-k~e=ooIDĕetzdPnoL' +'"~B>vz# ljp&;`SW0 w!&e1P_rzF0Τ1z,WÉ Lh`%1ߘ4pPw}a`: ţ:ŝ $pK%>%,өG+ C-PiTgV$~|I(;Vr䈞njW*Z'FYivq'&u(n|^uj̵9DBbONƒeR[I/䘊gǤ ii^dž씜+-1u:@ڪK~4 <,4f-&Xc0I9Q鄲:W]F\x8Iͺ`efUϜk p;С'.k +׳x[!޲X.%G*]7>\B(;{]zpB[$i'd?IٶBR<^U7"5Emp]Y좃'Z{* ,%?qN4&Rs5ᬾXYvg%po<}TLb3LsW< Hk-O>_HT0t"ctɝ.|23@ȟX֢LTK:Y<#"TѴr=yl_":ssC5ɹm` -8) +ar"'_~W⏺ 6# ܧSsCj spݰwZ !ts*;?81;.GH}vlfuUIYN% C-ڢ=tLF O/G㵙`~(o܋ܮ:ڊ sR!ߘN,oG_Ҿ]yw)bLx}W7|wHqK7 \Mߗ{Xj@;ճwnFGU0 _9O:_0tqk`yct~i[0c 0j{:*^"h+f +:Q|D=jy>@sW̗7 Y[O:䐝h~.#YT*#Zs6z֎CSI.u:mqcb!?2] ?ſ]IcMO|R69L<0Xb`ߝ XJLiu7ےx3L$ؖ8ׄ|kGr܉{m7YL7&9'[*']x)ۑQM@:GRfc#n0wcWr0:E͊ǖ4ccc*J8\mޓx˸ߟ a':z_ցMKȢ# +/Ims<,0霉lK M1/JZv~G]B,\? dϾ{gOӹi&Ffcm8k- ȹ|E2)=tpp.npgJ&f_G3> =<*;3{e~W + +nfNg˫.MXӨda::1JCʗr]Xz"& iiZgEOwbJ] :[:|;ȠYFu qYhȣh䂉+mdhs\4R~b!rH,z#+a@5D.h)'C1gz <6 bc+_/cG9<^g[Hθd"8Rj2,r-tݎGYw֐_wh 3Ps,AZ!EP=3C(FI/$v{ZV|\£y cc_KlE"|7 !o&<C/ޚXi0fE`o7qhN/*>m +HX m_` w4 BZ^Vo>ҭǷVKSӗyXxMJiXcٞ9=<85)<;$ [ {OI.FJwkL1AT4=:c_ xAl$;$N(89㜊34DRLc51v]fh84CT^K.\d3y'<}~Flb߃W&њX'lإXr,ݶx)cDii?0e[DThbXIKqu$Џ՗ON”}gm:3mdf1ƒyhJl|θ:Ix?:'fzgJ(Vp"ީ{K?4fN`tR Cj҅E-RjZKKٹ_OaOϒQ!X#$ASA> +c.LәXjkg}wÅjN0Q38iQ$&0`+?VO oRwGªs8a 5wA,]=7cG(.&((+U\1T`~s\æϡl3.S/Ql[I^GvY7&7[{prxPMa5-v{ 5C{*~YSf/ OgV#G|O&;>_$ +1k=Qq9{/D"!~5Ir!&vzJ9uzyQcߘtvgϾVfLf6HVrL [bʻ6kg0Θ}fbh&1@߁#әn.Ÿ5;i![AhC[hx>(=+L@#:vG@kOOg73؝YqO=K'# g{uDHٮdx,Rc%R\(m0 NȎg86{Sh.O5eK=ǚ(b?#6p!VF`mjx_ T&К"/7ggNfoߦ xfFRh.4c2zWFto;tTž˲PGx¼Y~Ju:D6HKg'R@oLD-+3V`*)9="hI t0{qYEE9f^YQf\$j1њ\e6b-v倦-"n@aWhiR@ƻM/5֝ݿ<۬@[Dhc@oLc}&" 5=f㑨4MQ/d2z2~RZh%y>I} (/cYmpI,WEk%K୩<ٲ( 4po.c6%^4wD\1P#-Pu: +V t6G9;hދ tnw1@KTpB4 ,Dйݳk J(5n +%D@h}ߢNt q.W}4o8a{HuHi\Np~z!A2o#^#FMnXjz +Z!*4@OD <}Zv(8|~*mہ9yܱOǖGhI}bbc%ri|+m{tO_ӡb?L](s_e[Tby6֕{Pze)_Ib(˽m֙ v٧D?}Z<:h 2l>͆3PlzEEiW>X,Pl(E07Y@O(eޘ?kDVZ6(ZȦh +fu<ǟK-势eZ҆n橪?IkKúDԩ4a s#.ZhyXMYG2csъOE,{IedY4qcYYs |p-\t6E@%=QtS[\̬zjFPr~︘XȠ=؏avNFP3 xDo2?!B/I +y B[qR;G1AZ%5?3/1>Nv|7<_C>I +>k̟gX +gV-~$VugJYʽ~]OyIqq)O%EeK(zlQcka' eͬ葦]U+ ,3dp#WҴtb[nUx:bxp޻VF\&H"vFbQjn37b4PZ$%aw{ |a3rOiirnȞђ8qoӵ#z'㠎tgΤt/]/u):Е=Aq. t?/&[dfJR O(zD_$/ypB>'Y, 2N +rJ_q9%ÜUb`35UK7k7hzZÜPNK>+^wEY]Ysh1%y8u7&m3^af fpeR4,\mytXi UkLPuQvb$ߪ1޷H1D0l/}lMX䥜A9VRASɧNE lUڪL>}s؋̣-6:Yq-ԉNjY5 mEBArOSl8) m=,{"QQ< +]\ᓳ$SnymT@<LP,A #)>dHA1]@(-ђ{ۛղVP8 ,H~[A=!ϱkSdm;KA.#OZ۱R"%.`/ u^cp."pKz%ZR,(ɊQ +Ɋ"$ˢЂqC04Bf0I%T7N^A>pli+Nܘt"(Ȣx yrSiLAlJ9FT.Mkhc2>Z ޻G"/v",,ﭗЃMyh|^:+~F4zS=ݘ8xG#M9Fw Hٲ@SC|[ Oա* ? +~ )}]rO )m'ռ [g!oE]%X47oRYSVy7:a퉳ts/G|M?뽓/љ`:%*`iZ)+; )|zcR_ r_'cD\N&RЗ@%nnhxOD0JdzD;zX%ڍ$%iUZ_h0kR\/.bl??h~vIiscJV[6Y[sGt_Ɩ/y12K:3NBg-UB$+f \-K <(0k&9 ޏ6^~~{qE;75%vpgfu!ρ 6_]?yLw?ZY؅6l_e+`Qg?_tZ !K-} p?T/'UPYb cm(Ѕ}b ~t$$$8])H:a[)ҩa'jQ:%s(=$"\5sгQ\iH$8GuySPK)G_A1Qɧlz|暌QHaqwm ݜ=Z31\*F(\gb |wk,b-7&4r42t,毬$= npnsuV7s%]T7cOny _]VЉ*]C\Ae/tՂW)WRC\A'~PC\A'A rBU5ttZjq?X +g: +:l *j-/_ $Jvрd7mV/NM_HKZ:_Zm:v֊tUK1sR :S6>S<>Qrh'zd*U"WJ(I̡\U4IdD ܞ +Wc ׇdǫ:.n4 3! bN9iĘ-v۶zIjnOZfAU3*u&L"/wlԗZ6^U))WڷƪCu%}.Cgjy`# +Iرɚ]U`ȳDń_*q zJ.mE:-tR^NԅLsP#KtAuICqu58{'Oٛ5;{rsх(0ϧS5}k ur4i*qS2(QUwJ5r7*e<񀔏S>Iա>U&,w*R{w E+R{J߯T~NE*7*RQ+RQ/Qv % Dԫl.nPT +'-~+fF)z)B)W?(A%pQA)t|LQ2 ~RT6WUˉB{,Vq&z"Ȩ3a.vsWѸt:/r)w^,{=GQ p^8iljF-}eM=l5:˴!zbBPbRncŎEGT3G=CU5KJ}1ԒS{.:>4]Yj??Nzɍ/"Mwzr;tߋ\[M'j:N*&(^/?n|5T,^:'tpkVUIurB7龩ڧ9_SM'UK1j:X߫]j:)㆟;;tRt2ARn5qzcj:Ȇa5+;UM'g[n5vNԕxOEk~N:(\M'["ʁj:) ^Neg䗪oTIlV5Z%TIsuv]ut-^TX}u(.oW'o]haNg* 2!QMa +2UrHP* +4.'ܘJbU.+$H!+apDZLݑŝ#͕#s۲.5ws4߹NvZ%Uri+Ӕ |gsl2t͝jDq6Ew?掭}SNѦ \yII^gQMlriO]tAj2:<+F5ihQ0O\_PH"Cԑ 9Y [`CSe,u6~Ofa  +J%\s6t?9 +:Ӗѭ،e߯T>|+(p87tT/̮o@E%dz-;LSa결SQgr11V0.YR6Hz߫RrKU]fP+zr9ԣW*SN'_oI\vU> &Ey?^uQxۋRV)l??N8.WQC!U;62li(d wJ; %+{ou7)U>`WnS'vSON7|*p'KR{Ew]ÝSQ k_f:S7sn:t+W>?Brι|Cn^z +SGVTtv.v"&(΋eL7eLZ,Ѯi1-eLAN]E)dT趟VeȪeUj)bDWb~UELrDDM{aT~a(qXS7j\SnSŐrtW]I)ou~h}׎T0U=ܔf+o}04T=׸Jj\2# h|NFƍ)}h4 r5\ݗ}z)KLfb'A]TPwcZ?T%-z𶇏)ɢ2<.WGL&W* Ƣnc%rGYB=vz:x@i; c>#U9ڬw/ )7&D`s2OR&6|s V\4g R@oR t`%4y +2=w>qE{#}v!ێ__I|C =:B}&arڪZhU͕%Eumɴ-0}|dl!],)>+*>_.}$>ْ3{+9V(':5qN)"hMDIZBœؔB%I>Au>}my%M Z!KG՗1]Mݡ-n:>fV))Yy^Rlyɧѹ٣MRCլτ\~v65ƶ\J̥ɚ|XȔ,n]ߠ5^_ngoeqBVhՂ% +-V6] ,-𸾝T`֏)$Qs~'ִqWVe\v=h 7򇬪BZ]"ķV`Z*uY>ɰgyڋ>lHe"쨴 +== ^nb7;"J{vj]G~]6T-B|ד#( ?Z^[zY]&/kN >co,5@XNG-%HSPeC,ÎecNK'$N>)׺S'>$ylk$,tGT'=V%F|q%? -Oml`y`]qq< SZ8 I7S{a8XV/Fc,ð0stҫ001ٜ-m"3A6qԇA6Db#-lw}rvj 3&JB{Yss\X'L?[mZ?}c>1 $dz^g[☏ͭc>Y?99W J 6Wab߿dwi 5ޥ ۸8%b9Rh汐5&7- +dXn?ow](]zfq.(]}HV[VQ|1SMc+.[Giء=C>fѶi WyuX6-?=:WqRXWƆJDjy]I|${F{Yr_9>VI[| +;bW%2S/-Vy2/=o&>m0 Od5lUkv]'*{ 5Pj[Re=@ tRf´LCkYŕy*YV<[]}z]7S+y)2=˧k\9,=tW$VEN[tl2_*IY J5V*V3HwJ2"->yZfl[ -iGfmUJ&ӗ $f¸R㽤l}܃ftζijk.'|$0~V'Nݛ)+7)0lםm2N’q>esoMn붷+c yg~;Pݮl h u.}C7:f0XqKY|38u3\xW񒹌ij!,z&-qt11S–⩤KR>%5H͖T67|0IW}i q?1V(Iؔ8T^218?1VT0Ky5K ;.`d c,M(5olKyKJjWiFY_X7AUԧ=_:в 9;˦ه ť'rhEkQcM=$pTaDr/؇ q☴zٜFıeG#FжrՕLQ&}]{lEƆ#J͖U,[V' Ok[#0|--rCnۉ&pvYYcR-4-Rqz_M%1*T0g0ÜU7g}^qLS͑O,*JuZOiOʕJmEw=E%MM-g9ti:UCmM}³A#z.4&?*>ROџ +T>u|Kg.9zgˮ]7#kx9mQ~p仧ɇ*qՓOgq; 9wb$~>=2yhjzUqwU␔P5CLDC1RXQ[hhX RZ} I L)&G \O2I^_˃t'*K!*&M,7' += 0p1>XM2%iZ)cUb&XpMU=Ĥ))ɯiU{p6eJV7I̘DU'7SMAnk)I͐䍾-HJ'!//cUmIa#C'DG~:@~Z5Ր5̔1֍1q8TܜK!)rf""]5{ˤURk 0aW4W![I{x] X.&ӥ$DXss( )rfXa!VdBUoMa'rzf~$@Jws_ .Rʝ㻗[1" [&kRgfݴ#Y +.&;kEfa$ד(ʊS  `RiWQ3f2TފS2VżaZA DxQL!1 +B SLFǙ,dGҶ?W(+2baeô, T] Q4쎲t7%^]vV_nO|W qBpڋ'Ԑ+s$۱U?.%Â3sKR+\q&dU䑐zO1I$I#Ҩ&xe@$DۥU7I {0 D䐊s#;.V <`yJWכGUנ*lnu\4IA"&oTO_O#(I ݲ*&F/9S3$)Tu3!{FcÝD #T@<MxK_IRLJy-,haNفD/ŪdU%uXpItoCO* 7oǨxHI8hdI{<A!yqSU2y7h̝nx!2yFa _ NZft|?pC.lV@rpJ iqaU;qƜ2frv{ӽ+qHJL__kڟ* ikfuPwox.i(5#dbL㾾Wg0'r +JKfX&m^9I͡n1wG L+v957=0BJCZ$/"GidR1I_Qd{X) caDR4w=I^{5E19,̜ eƉR?P!kS+) fLI219?{Z=]J"f# Hɰ[Q:?,'MyDS3q=A-׺LFRFH* FHe5`_>S0i}^ذ]2|n4涃47Z;68$%,DN9HHiDͲo&HN#;_uȟ: #&1F`{ Ӡɪjr2dzZv'7@*7CRy}H"vSGM" 5yȪd?l>\'Wn,0'LW,[ נb矫z +aHKުf4V@],υC):[jHFo6IW T|fh0s/F/La؈Q!0I!rHujn*^?ԻtIiOjqfh},zC/*^b2htYH 4itlkO-UZei)nwN7ug22br21Iv?kNVar2hd psg&wwGG-PLpk_o.RT@y&܌GyN) 6EQLLFOzq{,jx""襘ԥ~Xa !otϵHy۟i)iz(&o_߿C4y)_CZ`3oB"wsI#@nY9q~ַ#!ުFٗ4diȄdߞj\4`rVOjq X$MFif2B 9ު$pK]uz8D^f7zw7>d&)/2ÀI냀*O80G`4De$sgcznz0B"G۲.~UcV:jԋ}+F"oU3brD}KTʕ'%kuBG2,mH`L$)$%n-Vf|D Gr9FIMA.70g'9|*29Ƭ`C&jFY?씩;Bo  i6V3E,`*m&!Y*7dR +ZNJÌ(#]rHF1[UMׇ͏YS3#19Tq/Ywշc +uv.0]S1?|TE{ I5 +cJ\L~ea"42a:u<;{Π'AլHIC 9^cn}O wE-C)8و4&){=3`rLCG/n`EBGbՊ#(џ yyȱ}~= _g!E7"PͨD 57d]e5߻.tY#hgpAogoDNiJO QpiɋGi7&% V54r\u+틯u_WÚgЌFoߎO19ɿh>}۩r 9o"by!&#!p@pZU8%y;1w-u͘U8ftMUe %L@zhb^ΜܜKQ kyyyPjn$Qc.%iL\yжQy4K䕈hX{C!IoňHXjxŷ{QŦ5ƍǻ=mr8̀ɟ>%Zr哑5q$Qisal&tRQsj&xŸ6:\WO D:ތ!zH$MNvaʕOAHrTa.gV{j+ɓ4ӽ7RäբtS桏DFD@Z{yfY LtWNմvnh0HȤ"1` ɑgp| oT,1"YzO;[1OQc$ϾyK~0 Twjfj1.&;՝IT]9C^CR8>5/U[%>^`Z$`j7z>$ȎOLɏtL&&gP;t$B/vp0hzUT7 aȺ<8J<[oFw7y7kW.V7E5=[1V3hHnɬ?0,`&pEpBcnp +RiqDf$q\<0-y:4շb4&GvNAẌ09tQr$5fDcnţ{TN#ra=BY8TVU]8'V578m9̺&|v0םsm}ceG f/hhbE^!E3jOd^R,QPߗ'p !@f^uN*0N3T#Om2~Ivt(a2i[U͘ljH"FwÚ]АA&&G4W-2,`J# W $:@!U砣ssx +3rvU֪HSwotŨ'hۭp#ϾMz*&#\/XVFE`fy[Z#zI!$R]y#R"~Vf\$ˬ&J%)}K=`2"i1v1fI+*^+$X# 5p1W" f$Vn-X߀tnL9|I-#$mkoxH8t<̀_wȟoI,&ͷS2Mel)c81Vvz tQ1)t"m,wL7 Ez@S$4;~_>(S֖А`j4&$%`r,]O70 ,bz Q^Qec8~= ;AX .C'$b{}/Sͫ!'yjݩ,VQ~Ƙuߺ,6ſ۔]-?zUvoD*9!ѪirV9āZOeߘ{,*nX&.&h/NCB譸?sU9?~9Lwf;='+eo$OqYzg춆[= 4`2"j?>!>5ʕ'Hkz0$G$w&xb9RjYzL{}|k !4&_>Ue}$'K`AOc$iAY(<&Ɗ?C@Rx2SvK0iL]!/YveyriGEELj`JKG=o_x@n8d1E%8{r壚'wgqQWxIAKUA0Uo]E'ouKГGΰ&#SfX+[CF@G  +'#O`V/`탞gC09rZv嘘TdI'L!8:xI'AL? |F"CIpv_<( +4=ؚZQ + .r eTg@3OI'@4+tJArf /6Z}{=wwP˛Г`J4˕Y|L3YncideaB>JA.vT$rv 0sxW= Nk,`jwIUqEѳ0AŚt8 :A孞_G$T8M=z?q)阗O&9<5Z} 8e DC.}l=JAF.&!)A''䟷˟!J2ʕ''U#j sלQlQ(ՌgQT5Ѭ06Cr\yRFT0thI } A +ϳ&}V \n +%8Iߕ4 QnA++ `7t1Y*.ުA͖8y 1`3DLjh8&ӣzvk8I!Ch'A0A^/!1Y RbW9I+YE=qX8}2qSj}sWBF)9uKIROolxn԰e{L!8|M)>m $3^'& jn)&$]&8$f{XLZ4X$Xƾ] 8h+dߌ#twW(c s>so@|&&*V5-JFoDqP8zcH rG"#yp| ߻"$B(G\>V=)B-8݀ 8i9JW"ϡ¹Ih zYfTNIɶ0YQL7Һ.sa(L&M+ܟkܿ,pEUs\!?_=v;3`21JA0 +=v` +na(4-|U5c)N5VaNG}]4IK S6n4IQv;0Q:|W5[J=`2*S'INjI(-o4dIH}|`c'rN%B(s|@w/J/r;8r UPD8o= /Asis;=j<`*8PqxdbSTWghqe'#?^܃2A 8sjaj0:w$ +u_>#3wL6x0N:q֫n+^oB(s]&]/QȾRcժ#!oI4Nn) 8;M]ހ LBB3rXUpLi%uu\0szS@p+ܟ}c@~ルnPi$l.o0ȁZZPГ' $&;(G<=yb2HͰ=\Oةf3qzt`9DR^t}퓰R:d1AOf+SҋYr&xu8"'>UN%ha~&g'y$zA|v^gTd6(!zv#bJpGtzք^ovviΔ,`oNy{ TS8G& QVJ8bQ~UX){ћ|êZFoD !K='쎅\y +^M(ΆV-X'w> vĜ?-PQBOf5e!\bTf6]O2!n' uB~0dGP^(=wg:i꿡_;qрI犬 ?K4Br=a;Ѱ"P<׻6a&$3x_]/SL)1o,*L=Wd OSUtg7*9>]&k¸ܿ,!1!|2-v&p"y͈&S'yD&փn n6Xja E(G $WDL~UP!Iev񓀳9.aPCFPBOfyaU9ߕBG攙Oe,rR d123M1@FE7 P$/z<%~z2&뗏{`U͇U$0. &:qzRГ$Mכٲl?|ҰʅUDLI#{X$o1enz`l^Ü&tz_G$R6GcГ (&٩&_#`2S/CTD : Q=" &+ݟ:y2 ==~7Tʯո:J'{Mpv;=`DqGBo5}(sc4^19ɯv~ħrLiw氠Qv`zR -V 5 +mG}z*߼,@*I#`gO˟!Ji' =Aq:xQBpti$$Q|$;DL~iXWv'n1 ň⎅&(G |ɡ4~V\!bS Q7XuB.sl>>A4IjPg[2$e>Wg=GQL'yRIc搰}d 8<޷;x@BJN:0KҧNM)8LgMָ@03٥I޹GrAB.1%19o?\'7onASDnB7NnTcAp2\J' W )s4z2b:Ld,yI՛=T葓AVkG&19UIܦB$Ĥca^z5EEx+ބ99W7 &$_K=(4>brv0.vf>|"&F^na7Qݶ0 zsIgC zwG&0^݂99Er)ov#%gbaU(Wp!vGhIIByDm H `T>"镮AOPLɿ9FB:Ae'Q)ȱqLFQyc.E )o=yU/ڮвDLkKeb=\T DZ^Sh&A:r?xsГ9<&i}'t(WԌh8z,:.  &?#CbN\ј=9$QߚwA<xC-I"Oo؍ &@Of?vPN)&!C~Nq%avTn" I^ja'SgP2I>5[ $q˳4D"4ŭiEX{^\醊&G427f\T ǙdND  W&-9Г$yh?&mٚ9z,'s k> NEQ^&A9,+j>VLaUY3[nVܦvw1 `Zs?} X)w{!&bz#_Ej{ۥ `2#mJ'9L]U\1'A0s>=#$)9<`rD&q&3ŒQaﱈnn\$_:}eݺ5oƜ'k7ې}qea Y=DvH9 = GބOyQ2y~]gR=I_w M"z$2NתVQLN-LkȚ0락|cI0ʯtH;Io(p{sw ʘ;Z^Ü&\fGP3޷;;e5ۮHI2j򏞔>sHz4VbҙЍ[ ΠNg띕$Wm1!0Gww `2s zMZ5NL뮅B0N`>ˬ%$eN=˕P寞Iop2`/8NyyZ'm .#,7M=Ĝ#Ys^O +v~ׅ &Dzs 8 znŭ[A (!Q7$e6'vKRLLF<%}VDd&S32qZ/0N:EZ U +g7:<#޷;H4Q^>Sij)II A8叨dDo&Y[ҵӓ<`Y_-&2J!1TpgwTYl .5V;Cun"$eUno +D$Q +੔1{%Vv2 +=ul!ġm-T6Ua -$j^o$dBJ3`{ 4L\Ǫh8ʘ;d$עL:G}*<`rXIzfʳTL*KqIGj8 '9YW;&b_>鋱rqg5VƼ3L#'L /GEtFE٭CO:FEI 7%R pej2+emLIђ;[ɍZ8쓎n )Ă hKqo!;K8m!4`2" k/n+2i&z,:6VaH30QfodL|Sf73Iu)82q 'C.vCO heGU`|pD۵4J(WjaogMr;O#a^tU`qԌ~<sed?)}|]S/z=qn += DDGn^'@ZFPrK^߁!aA@O:9 =iΠ1='#ov*g>_2SOq xqҡQDN 8Rc}AM!vXt"ISa>DQf8|FfPY!`2IC 89UhD'ox. ^ Lqy8#9FBg7ʘ; z r H*]9b9W'I^} 饦4=qT +rt=Yn'AL (3v19y(Wde̅(āqiH0x?qS$OyNa(FzCRf&_ +%/WNOpwS LG8LO* L%KGo=CMaLތ٣'idDV9/^ &_Bi8٭,6 +F? A.F'}>Ĝ#{l'}0-W4`Q3Pg7N_A<]dL#:TPvrI^arD!Y7I%x>Vf},,rV&2l f);9(OD޿,XJ0I䏟>4z,Y`TW˿ո~.r3# R\mߎr 슄8ĤsB'A 4^>2ޙ R՜lJ+rnEﱈL$bg6a-0fyt~G,!,c{UIDO9i!z?J^iHχ 5x\chdv4<ɋvn֍7a\M0k1UG5-v"`҉CO: zŰ1FsV-zgovwC^ Xha솧i`WAyv)yUp/NOɟ˟9! &0!#'{ȊRq8 (?_7 e&PQM?ͲoP4"쓎^v#rbY)Ḿ$LPoN[r>@%_FEA  @!"65Mv>"'y7=U4`f5v_71'vx 턥a7 H]\a"]V9o]!wR*A&_? `stǢ` @"Ham?`VM<`?)}ZOg;NcDnj 41;iFT8DϏD'Ŀ'b;,`e3=QQhULOzuݲʱ$fwr$$Y_o5]094I$-9viQsu"awo5 F6 )^o{$k,`˕CLS-Dq'~$'AGSt8MqZΔ$q C.&_ɓ҈6IwzE h:x8| *+;GE'Z,mAd !jdTUhDE[x@J8EuII.((N_YF/0=Y;Oh’ɁZ.J7)Y&z(m[cC(\^V!)HV%fV{qIɖ(> ’I=$PLr2mou ju|s.)mcBF2t; zk;4 DuAc&'-ODyǏ,~1v.)%{6y缧M_[ ےX\%JdbDZ-ﲭ}Ip_=mI:ik7i$y['qӦf'M#.qQINw`\`}p\o;s?{YB m {QƼ˰ \&ɗ<-e4d/VR\ cl LJR۳R +m#8Sx7WU~& I܄= NҗVfRS{(x<qRt 47*b'qZ`Ad=O6IF~`0\&J,yq18M{4R(+-wԔt"o JibX s`DOFGnvX{z>{GTQ2tR>WR~Jivm{^(e᠖Z|1 07b"I[ݒx*$u*nH`{Ձ[kmQݷFbkd1s߼hZhbv\LGŔR(Yu"o=c 89Z.Ko KY1^kMQ +B\K8L[ +;EKf[ҚWrQʿyȎnG6/sfX0+=XL-bm&Tu? ߦJYX|Xe_w 2G7ZvN1B&f4 #ʫu6d)M'bͻE=P}T&O2(3-ybgK#)OV^ MWJK#PJ > 0.?Eyp#sF[VqMQδĔtSєsX}C4J5}9U_rRʯ+m7(є ߦ yo(-ѳ3iIF}2{Qbo20kttwoj|2B^ .we؞;&66[ҼXCL)tsADs.܁zNd?2[F!,3!Rǯ 쒚LC{)M'⓸sC>h/2A{/Vn?h./·AҜI]0׻bJ~2܄S9fYN' W2(R0zwiq{-XnL/lOʢe&eӎ@) L-ma N勵N#Ey a@ rcV27J龕HJ]ڂb L1bJ>9V;[V@~ᦌ.}/I(eUJ%^Kyz]B$]-p蒯^}?ȁbE v̷cI/Wò eLUX~1 Z2b;_{0)kw1\hTy90wTRmQKWg.A#L}JM$D|)ݪAӼ+=,Rb;Cu伶Jd߷Kjɤ$M + +g'+]a>۠|V_v+eJo}2vVc0WeE0.XǾe)OVXkkRY<5RKmls9+W{1 xqrSJuԽEPvVI(fH7:.9ܜ:32F1A/:} qHU;$?Z_bRzH2->z-h Hl@&ދ(DEh ?}j(b<"ƘN 9 IL Kˤ"WZ=;YE_/X67!_qgUK`; RK-jqv<̉&8{PXB!l2NJ˽rkYJ3œ5&2Y늠wGd-jۑQYxr"'+9'ypP_ՠ|1*]j./Fdp ҒA`;Cum82e))~~!ڞ;e;aCμLJb(9Pc1d^oZQ0343Yb9^z;K{1ƋFzLo!\&UddIł3KLFtj8%c;O8>&%zr9ɼ v^}b),ZP,0b 8Ė'xE"wC XT)2 =L 2G/֡ bLEe4y|g&Z&O^ b;{u%iCwے9IrYR>"$ojLBRv d2"ZC&OBfons r=wD Q*puR &g>9)ZI%N:I&5ދЪA+eGJ0(DL8<ӈw[xJ,=`;ߨR&uɬ@RSR\)OVXkR Ks="fWE/~BG6 tR6Ljbָښ-dQ/`v5b{&o`;C*'Ah(ICe^l/ZX|1=:R<|a s *^k2i.vVHDe{&_\Ldr2re75TtWj|tf)[4`d>GQQQhJP5VIHf&=XGEˤz/f-/WJ2dKo`d~HrZצZX Q{k^d# bָ.i/k͕4A)#[ ' Fes9d-n%}xi|SD ?<UJw+6b&ATҌ(6J̢~5no$40#%ů?l'sk {r{q(fGx]SJwѶ\l_׎OHhd,I*6[8 /k0d :IHQDD~gᗛnr`JGc@#\f`; *4S L:ZDVd`bvr,7K>y[]YP}Y)Ld轘:sh e JGw XUmN{-XƢ"XeznOXFY2+Y{&+!HͳP8%WRr$cg%Лb%Лm܈hM!,TZɟ*scI/}pșv΂ދYJ=QlA)s~6UFpT'RKC <$Ho=@@,0MJ/R.5W3(gZ,u.}RK?+eD)ܷ<; +ƀ=a.uW.wZp1* UJ?2#ViWپJd)mSe['CX=yy +zcB&3s rQUFQxFɾؽÕLP܁+hn'3ZLjyn.7 +ɀmAd.Wb`&XՠɾXr8F/M7UrOffT%DDgi)_t@v2IG|Lf$~e8S9FI}rU }g ?}M^g/"D'jBIB;S_5OBs +xs_.|%o!ƞUeaR)ELlnK^QTTFml]n)9O2iE2%OtK[o(O ݳ/H[0I%T턐4,E]-w:JJLrKF2EK3q+r'3.s kL &X6:4cW7XouiU`2<֯&;Ȥ@—qP_iɧGʼnB&s),!ڨ?G<-d2_r;y +-D-!EiѪA3iwUy[X6in d2"nSeS-֖>ZBn#%Y9d&b O1Ĕ-t/%V v endstream endobj 30 0 obj <>stream +dI"![xi n/9Őנbvi΃# Wj+R?Gs{A.w-up;i{h[adv[e,yl#uVA)uCI۳Њ7@3èIq΀ދFC~B?WUo!gb(e/sC&+&ov6Jrr?6xſO- ~}\)@PyGǔRC#IXLcT|#%AX%B2Yb!2 p _a@&b[(RQ{1u2YaIȤ HT.moAL2en@>.3)[ՠܧ?|B)SxsAȤB;HE^z}yM d-uVY-\j/]f9_AB>xR&ctRuk2iig zi5VwYl.+.i(6f[& Й~cJ)a˨Zm4g?/BX +dO;..]&f]^$_(LbR_5/Warj,QJL@&s ^RtN&`@A'|;|u /IuPѷzjB}!d2gKA^4nrK'r1mPs6rS <9I}g N!E(~SeEe]uZ$Vx8+d2W(W/S2%_khfOk ʹkۡSwA /Bq Rkkі k| d$|B zh$5SL:[}e6w' .Ox=C!t ]Lu3|j2Q +Np<>R?$vM%,U`5* ?QʘL 4dŠ&SAe^4w}3SJtc C-Ehy+z "{Q*7jwȇBLdd2nދF2!¯Æe)_҅ovKկBIGNgS*yZU%> @jd5jbH ?WʷHU*2X-jzf< #27yh9H _hhLPv@KE_eCFNRz*Al %Jq#oDl=k+VGU +ypO@p<נ`;mM{;L*ee+Ƀq/xI]4EKoo`iU}N^flk 4LZEeV:^bڨÔ_qVʶ +[%r>W߼ֺG5Pz+rp8dS5&߆C *d2({Y; +zk20BWJ0l52 CEE3'.4yj,RnmHׯi@/ukg*L+t[EEjZ싥R6F9ϒ֊hIJ:x=UrB+~{:iJ)*:~砪|qU-̙IV,ɜ Zg {!~62k.H0)LQ`aKNaX5!ěa{ۭ +Le&ODPRhD̢zMI|VM2mC r6@&MGyMBE#`UL! + _CcJa^rP + MTFΐK2 8X_by~݃ty 2iz{8얮I/qJ!{5f%((A)*J龕mh @eGBfd/c8c JyABRJ.*ͬL%v %h[&7Iw3=m!z/PPj *Rz +e>ɖ->RjUF+7*3AȤI!pYw.z^%XJ٨|>[,|OXJ!&視7:EJ}eM)i2 4%%NyTKpPGW؎98D \ V\#VVpR]>qp x2Y\Œ1Q0{ՠx!tL!(e7< ̥ z*̛y HLzL~cUL^4ᦂ+³*OynͿG|c#drPLphx2%W[_b!<@~_鮶^)Y_qynGVڞ5ѦA$*Е<d +{QAas#6~=X*nWN[aGs>nWz?*:;&dɤ[/OILt; l b [ꪲ6xL{ Rl'$JTW *!΀)b[[EaNK/z/ɕQ!UϝRs9=g™G/ +½2ǀiGnmSYgFowK9 VH.2YH@@PVCE?t׻#Is;/. +Zj z!` +%o?PX-LA,yƋ/ƔRPGhC'oFfm]QC_iU1p(%8$ +"UAN|Zj^?(%0\&LS< +Qxa7^eGӱ y_8?Y'eˬ2 +@&p쨲t $/D9- w0A9WʷaEYy5zZJf`/%ker(DLb"IދqM~qs^<#ѓ7oE-d'Z=b9ݢ[Ƞ%I H~*g-y㬷uh8Ӑ#ydUR&)3J7" n TLTXɓy2 ҂ ^4^mȱQGYo=#ן G7$V )+o27C46ǀ +CGNlC'=t29c{)J=V ;4s74 2I^Ӹ2 2f)^X<’lPH㎆K@su*M^[' 8{K/a_"Z.| ݀8  Q +0qYO>r?ͭFOqN)e[7]Ɓ ޿[C36Q LwLz/ +031-]i+\)ŔRc6K:ˬ*kB E|wE̦zCW"0 VjU76g/K9mt=j{JpdC轨3WZ_ټJYc%JiS/>k2iкoV~C>'S لom`fbҡ(eH}RWJ-]dMچX?-DwSTؐ&Fe?A&A!3,x @8d T ґVASzm2e)CNڤ2Y Q+8*J LXc=BAEpSg0&@PyS'ԶMJ-fDB놣 C)PYf˽҃yuOfBT)UVz}k‹IޢB)I9]nRki蒯+dʷgf ]TY`t$QPQ`%(yv>@DeJdr(V ' Q ԋNyU}47:R(ޤ[듂(Ў簝PJ@<39$h"^L1KMXgdD)OR|YFL";eR|>IPB&uA'K\*Fb "7f C)A^Q6/Z9v Z5ug)OrTaj5zg^? ">M2 d dFE}J}砪J+ Y A$MJ HLA&A‹Hc[/&XELDK,3 ]uC܈"60Km h[`L! @Eݹ&/n6xqur8A(cuk gZKA$E!JJє锒akZe%M">Bj렔 G2)Vo=ދB/8Zs="JI>J)Z$ '7>o= /A轨7\l^a%2٢rDJiXzL$Shf,y4^4lZ;Nº#XFd|/ +B) L~>zuM +Q@'mxMzp~;17j!+e?ǻX]J(%2LB&A%oi ~? _ +; x+xhA}jd "_ L AE}$`~9,S؂$BnXAep^\|7@ qa;cْl4!I>}"^)F5cd$0轨 ]vV{}AHI~ށB%>/³DCGsA(bSD ø'V~[zfJYl)J;dP5z$f +`2Ȑ:{QKޗmd^mvI$Bf)+XV B=]UOc8{E2ug_Qa@Db]2Đ=’>uǁ16W_AIe)&?L^.c`0'm^DwX(Z:fh]J(%ȘD `h!O-I JAD){O"RzD)y!f.27B/y.\o>熞."O'_n*TYJ"4~gC&P8\kIFoCXPͻ >B +ɣhi S^2 +^T Z|2 .<#ҩK י 1TPT.\mѓX3AkYR"K wR&* +@v!uaCFE=ˣ{@d'x+RB) `{&c p!>9Ʃ ʍp7QPR"K d[)U!.$XΜ Z5HFG- Îy$x`@dhJ(Z "~oyIg$[Pk;]Lz/v&g_9nDD(N)$bNKW?'?)7 DMtpCJdLs=m҄h{:RfW_y>x ᓈM)*uUwovW[*kZaM|tt:ˁ!Ň7L H qf7o'tь1QG/C&rI?h ~z ]F1sD[-=!_>({?cO;{OS⟷ٿl_ǵ?K6Y[+mCL T9Ĝ9 vfZy*čmZg;۠@&rw{d(3*]rlj`kvu:#/9ۣ +yA(E?SãZP0HK|E;.T9N4PN2'n;S_pxsJGlyо$|O/Y_8Ĩۻ!UKf(VK2މ:p`̱؍ȝ`295F t9g,wE)A7uQ2B#q L>ڜ:?!1+m>U[n $Q!^4^Vy l +O"r&OxVW#%!8ΤTdՙ;gxL .ϳa4܄g;s{/b;sy +fN '}|6&f<%?\AA)^{Qc$m/h^JUJ$"ѣ= +&HQ (D c2fJIl{f&.v {/cfT J-fR,DHС8ޭD^r +(@(3dU 'mF>mDB6r< OQ +NBXNӍvAf^◯4Xn$"u:'ȋ9 `ne!FՠtIZ>ȍ6H]2v[ǯ 7aA'NtEF۔ ҕᐳ?Z|2DX"%sB轘ZؔaBnI'SA/\"HfQH!b#AȑD :>|~SeE?L@n%sB{/6[mR_LA2Aּ>'sRz/fX'P%ּ{wU$BPwXHL22NGDڴ6bPfMN'I%z/<9<'J7O"DEIWe.q.ALK!~ͮ>?-"{.8KQ/D9-a'=:Q5(9Xkͮޠ`c<>2-1r`v %Ʉf,y'bsQd|h[$H`vY!JL-]eU05[|+xh@d=q&:RyẌދ~ +] |2c"B+VSrFT =~'_z7"_qˁ$Ћ-x0=|fGg3g[:9"F-[vD cd"6_R[ ⓈX!@O.`%CߤyX'{]}srtᓈlA 2AW^L^ÒwZw. k-y_9>Z6EM@_& Yֆ#9i>['? '_oe3<| G$`&}ދI}2ڊKE5oA>?܍݈l/-!&z,#@ ŠB޹ߧXIQ,y*HLePu ~ֶ>R͓KI`8hDi0ƃ&C|a~QQ|d1?~-pF 7`a +C9>yaAQQ'擣I%&`:z\kp(2 U`Wh1wvQ Iث] Yc 2Ҍ"iщ$z/$2I9`qVCYa({QE!4nO:6zɺ"(%¸.z(ވAVA-JZW$/~zǯ']:ƻt$6ZLfSJ ++f>++=R)b!:& =$/(; jQ0~*g /3Ƌ?BF'IWÂI<pb9Ή''KNvDP)( +/D)/AxPhs|ȂE jkkc)J,y# tqD; +(Hf UC! n|'$B`#[F" 0-#NNKMX򦇻ɏOOnuvQ"E5^g=q7:nI +.(7v]'Kag%OmJ,E DDHN] '轘ە.OktwBw1E b)J$B`>GUsr +/D LZ5(,_D|aM%{֮-^)JҍnǺA${/TNLtK&A'S.}V9ةmhA (:,"＿> r ZM"ÇC.]u{ӝwX^(n9*@rH/yTNݒ:%VչHw9奄keQJphAwh$hrԢ {q(S\C}Cvw-PG|(yys(?- cQ-@E @vދs#=JOtA>D>X:wX9틉F޹(.Jh!AqQ;^e'AN%a(`;Ui0O},șzѣQHTD8qjn;ݎwQe{?߳՛W >(.JJ`m\n'w7OnS1i:f LQNp/WIp|+= DNA'AnB^vP4=xѠ+2.rWis,Z_}{+֊D."ʘ(A;K2`}6pU՛]+/Dɱ.Gd;Y@-J7hԿ*d_D?١]IyM:oR 2ɍ0vot~O/YSu7/[U)Z'{sh-2|Rwrsv0VB읏!5/!=?`},OFR妍pg8C1C3N;G/tw++dx{[rIo}ѺMwx*$&Z_ v'D$l?m1A^v9iw(5lrszϯve_^i|.OB~o-am7v!:E#&W7^2P$B2܄S)@~JC\8I_J^3~R΁E nwњWoVܴv(|Uv& .rԢ4:/Z'V? =v9w(qhe_cqğVHaMO"%aޮ`)YؒǩY$ g[/VFaŵ.w˽/yrn>%"S<9_z:$݄,_E>^9yr<=UWVܹr*VB{wϧ$RقXJ7k&zy:KIcZeSr#:@>B.|ON^5(,_ﴝqC<82v`t۳uKrO.x|)JLv?oR"/#9 -Ǜfm7vMs#َ>A%aϤ$רXN^ww8~#KY9WhsspbjZ +Q.^UA|_F1m|^gw  .51UYop1 8C@/T!3ใ,3sߙDyRJ#ڴn-N$S9IltD~G!#t'*z8"z;0ɁkKvr[Jv׬>'z&. hxL!yuK%kK W%o$UZ%2$U"J9,#X 9k/p]<^'v$`g Gί?yb<[O]w(*~*$/D DLlHu9>~ThJIiapIi6 XN3rO.())%>YU3ݒJELIƵ׏.]f-cO]W΢uItC':e' JiTU6) ~"Azkm +Do}v:zK;%l<3{?a܂;q0qd1v'o+nj^\H|rŲ'){' Jߊ:$s.yRDL~ o{f:I 薆CRvŃ䒵sٽUغg)J2T߼/br eyؖuU5| E]kK'q*1m|Э$0{)=C*Ҡ;'s婭6)2BI>4Xk҉l<1tHS\SM _K=?yFYJzʓ= 4>-ˏ֎F9VE ݵ2z*'>vNrD^O33U)\%-.wՠp19ΎH8G#NfH:}qmj% %}O^xcgVm[donv\iEh>y1WntYjuެ֖y;o(%"GOr|G 0;+e,sDrr˻lڅ}47.޾i?=0%ӆ#%IX~Ľ/%ygqͫk.V֥dME.9;9`䊻7\^vὼ,ha@d=qɉoE)9VYhj{vK}bͫnsX2v' >yQŒwwF’ ;'w]z^'/U=#2"4F E,_G}r{vʛ|YXd,E ,`e'?`gp>IP0̡1ˬ2Z.=A${Kuh˪{Ui/>~m?3$%ow_Pg{/>ӧڲ;B/*uawjnqƋk\M߄7Y7.^$KQA) <ި'KIPr4Ѝn^*/=r֝KjM$Nt;yr%~[X"q7\pǽUM{!}޺ ?^|<6IIO/!>x[( OhA vg}߿dR YVװC:/km,L&T/yNnz}?=Wo_[GnϼcRskͮ3 Ƕ_pOBɫ/$_y %NyjvSDsPȤ1ay9i@IbP }2wO&;o(KX@Lw r*E=@T+HQ&,yg~]lE7 %Cgi k-c ?[n涒 +{|ɛɹy[( -xO9MN3d+UjdR>Q} L#ח6>OrU̖O'$fRtQ\1ٳC^gʋJ%|[(O78_z'qVҺ.%o' ŒJ/yʺ/b e!+;9 >fZُ:ـ(}V'}&)dڲw[v4$1'z2h|jK'^j W>=ms邞JKn1% W|]]]kI( ){nxy'JׁUxa-?q6sJs՛}\蘓dpE?і{u鲵U?$߹i ;Ҫ;<9WArCފ7.]_}r٪: W%ɁOVNZLG'MW'|{ڍ_~hY.IZ [(vխ]pOէח#' 'y  +dMNrOM RriD{LmnNi-^_ɞ9irǦ5KI1d +s]FW[뺅Owg|;GWJv՛w^'ɗ+O^[v]\zw _'(ĉ]H^P&d0B)h+p)^ŅRiIIfU:#e)wmZsr=Ut;ؠ ;c9ejx'o]ᓅp  <3W:U-юo_'XQY jtҘz@17).~]T4r_5|rݢLɥk Iz˔r8w˖Shix' & Mt>~^A1`Ԭgyw~7вTaM2>EIhw0V2M34_e9_VB}Z|τ_)Y͓wK!G葜-T,\U]rOz}?e'$cRjO*̃kܯ=|ÕL=t#$Rn(u0>Sd>]Rzy'D7Byjnh.ge4">w׬zc}ɹw̽ Wo]M|8$?ûxO瓨Biэ!'gGS +; =7]T[;sD;6!yj[tr46Oj0%v6<9߽,!8v;α}>4{G:l+xn\n$vNI(^mƻw%yG2]PϬrW%%)rY}k ¦N9 }mtBˇo/e;E˖a-ϫHQ&`Uu[#|㛏.k]E&H/,6ٙzᏎ]&>ɻpL 4l6&|x> @dC)cЦ*N38m{V[͛L_)YrsYϞUNز$n{OC݄2܄I!)O^ +Gd~8!-[dR.amߴG7O֧?H.79Yhuk=MHO#޼7|@F=vN>RA0{U.G~ۜm+O8} ݸ_^G/hvCګϒtwx'L'ݱd?}V8OHq'Mך]g]eeOuUuZ~2"|NNm{(:eVy9"j:~]zsjks#|B_OΟeQߍIw{R7'gɛX_GcdLG,+h+h'ᐳ|'^#>95B ,=HN#Vh!t嬉B@ qp5>΋d܄N?^{zxRgSy2')o7T0eAMkheay? 6E.9dp-wT\r٪ū*z7| %'[l7:e$z޸*i2 IwD#K(_w[L Ө'}m= s覸]lZD jPJǣN>_y |dysC |r5'yI[&mN3Ar0ՅI Х{:N햾,wkǷc{ZWۥ솮z8z yKz܌g)wоE+0BF3 ޵]}džr^2tg˫$R +snt$z,`20Y],s$u{n(z9UR29Ds`Fn-38%$UB<ޒOoup]ЊQˉO.>O8ƻ\UpvCjT=ϞQ:z6.ٕrOwU8-Z;ZҾvO~ yGOMw^Q6]J|>Z_}R+i4iKuKF x8<$b_zpyew2nZo_[.F(:yeisq;L1;=êAp;bqܘqի{|i/X|ɚ;hz>YA/5yc&Q>^~GPM''v|.-0?Yk't6זm Rht^oRu@@:lQV\jcc++ޅ#agO d@vnp[K|rC4ҵf:#Z\EƑsJ[7g:Y0IV׷.}rmO.Zᓱ/]k@hjLo@iqQ83m)pTiˠ(oXGyrcww`ѥf3VBpœ&>rH]E|I? ~ R&Xncs{i9lkB@f]ݞ >P>R+x. +3$=dR\ow֭D,}v35M?}io*>L)4emWmeO<?1D wD9[Bdr㧝|%ҺG/(“w4/&mj϶P_Kܛ{DIđJɋ ;,#}<}c-;˽^MIGLن_mx]|^AYgU(/7K's{7-JXϪWZy6 wGCu:&&ֻ9C ^w-gI]ADnđssfTss{+K=|3eI̔~ܧqc՛}>x+HQ}wt eK'{K;\tly'y& +$?x{Uq"⓷Ts\h'ᓦ +vny$id$יU,yIIb֥|%Z B;t0po(6=R0a_͓aY]LtKGY>~#x,+mD##/(29\?ڡ:T)>`Jzgu•uIF$j;RrUNBOИw>ZSY^mIΦs&R9qsLj8>IAŒV4Z 8_yEk$ndU9'LMh\JrA3#!zyO5]vW{ʻ?|ӻ@Hb,$BIYa=K:-rCȞ| F)pRZ $l e{;a{XdK:H|ر-{ށZkA}@&N`#")z* +K+}r!y1~jvT<\R3Nrʇ7(e\ab\ ]<+y=~E59N'#$ǢHiΎؕ-[K~yuLF͢~rE?bzr!_Гqxg+682udshcR_<ԾF@<~{׍W)Ma?X2ӓ9֟5zux{RÚ;/UOuEOLI~Q#9F8{H]vZz]{;'~A v%JƏv@ιAX}61rzjM' =V3>C oь} $One<ڷi ?LħCvˑ渕&fᚳ\u'g]~Г~Г^|mW$a&IӨ,ŷ,Z %8Dž%Xӵ{Oގ28䏝y֟,6G %R2pM4cɏoť擌fd$hLES>M]<7PmHazr›]xً|AO:~;x,E3YRͤnROɘ{~-m$/vRԀ!7kiݝW,o&/b-?Sl (+pfޯOsm]rAG aqR!I9%yUi9?cE?1=9g$-R%54$%{>].0nR3֘s_Z6/Xwwr9;XMo|۳W$qbs̰ҔN%, ֑5v63ThɉД]k1=k d\-i9}N\㕋;JN[HX2+g᜝w t8bR^&0?<(ۘC84o+֟26p +՜}`zr߽go[y'RS%rHAyg3=y_O + SOZ-&er"3qpΒj/Wbrә)g}v K.Ȼ_q4[M$mi-?W2*5rd[mA{INl CAr_| of$h_{:EGf(lю?ŋ) =?Kd=} +:qp $e$܆'3՞,4e?/䦴f더cxsSޓ_~ۢkqz.ϪKQEy͢VĜɵcyr'> s *[*tܭ];nLv8D:ӗR:οzhx7qamI:fp8F2C #)=\a:}=".l_q׌7Ef(L9!N1>H؟ k' } T=IC_*_n4NX΢4nV[ozœ]bM/_RIDեRCgam0<()zEc\xc"QE_jY!x.oQl,[h~ GTr,MO)KK{M_|0 +ԓk"I/>Y_&bsIFCc6'kˮB6's^]>?xW^uݍL}΅#k/Ĝ_|?t̾ $%+U#SN|ahs[<[c"iJNd-8Uz|YLO۠'lJUd%p4]Q-OFr3u- 3yݷ_~pͣi[-k^ +)w:+v[mXjv׬uM!]5k\tdb'od\3'S]xm&=I'/6l9"vU`s_`(,UޤK=a">7龋ux 7𽠾ˆ۲Rd#*(Ԍȝ~"Kb!Rލa'(e;vQ v6EڢkL6gi31 =vܩTvz#'l+))坩ƶ.Rs]=w/k.1Q{iP+jx!J&<ʖP"UcQG:=ec:#ВVĸ9\&&'EX]xRbi: p\~oW,xbzc8iqN-ƥ eÜiWb]6gL,ޭ}'E{…(t2ڴbuəl$%{% +Ye&$0-. ՙR(5=񇋖n~^reSՖ/ݿSbXʘ;JG~Rnn!*Wz +>ݲ-Wtk[y… 'x[F tUM7 տ-UH=3z\;/榠dz7_jY+Kv j[G-TjʓG=>LQOx4v0rf]~ Г^\O >- HR2i4/ iKH CuAks}`~=Ϋn麋Fi.Bk^J#D)'-l Mj,8>ޛURXR alϕd`GB_~J]zE'b8N\|mƎoyp2^/ l") hv|;D<ֿ!%Y9={.͝W_cLc6w*&rW}-l#1#zW /MRTGOsT!6'tSL;HJ P_I[>&I=1 3~qOnYtᕷ*/#i/6zf'.)saitG1Zapr:J[V2{._N]ӌNafY-nCR +!mYHyϸ:(g_i䤾~`O.+̳y=97۳Vʟ/qU-OvrxHyR9>A,adla's DfJT'.|/V 8 @b)oԵ-R귛T*w/ +/9;^P[|m7]pQxn_KerZf@I_Xцf]9>pQs3Qv=8Ɉt:-IbΓ\]J?SVaD*{Ba>L >x_Oޯ/Wzu|^Jv22p7gT$<;!sssewJI&eHO't1[$"$6K<7S0/yk=|)L/>u>d~/H9b/=Qb#;0yWs'ceZ?bz =%R?I|BX))[8? >Fy) Y嵲v:Cl8;!- !¸!Zvnn#=g^"$'žx`ҧk4[PB){ ,U;"0s9$Y8Mz Nc6>1HjGSHU^6m M&)Wb ax2;:ՆIN\OX-\zҩ'Oj` +CRVT?גPUtR&,r6M2]i +A4$¯&jޖM]~bv/|0`b/) >cr^Hㅲ<4SJTȍdZrJGN +{3q'xdAj?D4`Tb,)Rޱ@iΚKt8+BDD)C9bf2 aI]kϡd.eJzҹX:Uڤx@kIV"ȉX } g !F)2xcN^C' n5[Itkb0!rŠX?đ:% ] +ER!]y%|!ԓ-YLOj zҁ`= IJ3>!|IӤ*+)AȰ;{cz~UxGtќ$') =ŋ'7Hy⒘Izڞ k-6 +(|%lɌd21>ȦZa=Xⶓr$!A`|LQ}6(D2=XD1"9_74!뭹| 5'ܪhÁtM.1:.Pq|yr"zsY3q;C;ٹnʏ7j,'vﬓ%ࣰL$XN>{e6wIٝ/W`tz!S=I&&i2%gBL:j8'K>n;i1p(іJفs}8eht j)^%Dq{0$w#et⨘"Q;⃆̗-#pH!"f"VCԓM*;kKLOX =d'-lS&ڒ)oS0zMas|x94qK ag')V?zanQѓ"i&"m$$`*YWnGRV!?۸Փ5IG8FpH%IJڋ9{`6X>FrrȐƑG9L;HX⇾+p*==ԗl6!!)ocw7$ex?5M._HSf;%cdVN1U +-O` D×)oBctrEr0X~<!uŁTG*zKA2g@Tx4C&4}iX >^HS0yK<(%-[rG(KuVhK$bn@F3O<8Y0_nn$eXSJ&)VCIad?'})Fdz K8|`4 w9ֿ)0LεdV} II>箱|Ιl5DҎA ?s/,N˃['BDTR5R޶rsάZ%MsDڔ'2IONt +E@ !I iQVr; z +f )ÅI,y,S/]F xvyR,NI/ 6uLQRv3Jk߃vŔbcW^lӹeI',ccMRSOL+rߦDeO\vSJuaQvx&AbآOMJmMPW~ b{N%ct؟c:#SJ&|x˜ew&9'֧`3LT)N%]d?՜1ĶRlK:=RŊ(%'әbcՓ V?KI.5f-%ӖQQ]OdX =i;Ji?v8B1b&Jy< 8 6, IBRvJ~sn͚כQc[Idda8-o~#۹[Pp$F)w pg:b8F2Dy(S;;`d %ӓ n)绡'MPHE8B:-aҥ+_nY2Ҝ1)6f=w]M]C;ctIiJ_8qTKm\OR!NhŃ%W<  Y !)'snaMcadiľ(HmqP-Ƒ'LPiΒc&)C|Η!|vcDт}v ՗AfA0΅M KR"址xё*$x|z5E)k6o ;ٙIiy|NI,A_28xcIS`+$6ct )'DRv+wʗ}>iwl}1Q(8Q%e[mF|21:dCRb ._bz)S|qRRn@2RRzy)< eGd\$w ;&SI&D|.˟.Fg7 ER./: IV\]=LR SʕRO} b\p"3TavZxX:L7 1"-A<ir˟?jHK&͍ٖQe:Ob8n8X|G n3Q}(-)ezCbE+ =)ГvXv2N8C`;{ 4Q#$ec`׮VI?cp5׵TSI1@!$e[eH )4tKonʄћSTӇy{xحtyR T2XV.16hA|ԐvTEs$_׮;Dֻs:X ۣ5dh|N|I@"bZr\atѳÔ2WfђV:sS|:=lғaHP=dnM",J,I& Dy$ĻDȕZlw0=ٜ5ꪡg']\O +?L'EoݪҤR1/v@k%"JsMd Bz23ГV.cK"8F@\n@B䟝?fH+V/XBSjHɄ%og~*̛cG7$eH;/B+K$7Q:qGۺi@pcz4䱇2uSZ[F}[.O##~ +(с >~:w4ۭ4VHv!#ȕu~TB:WC0yY6ƍޯ- a),EQ}A\{u3X,cO3:qP&p.ECcDF[8׵fQUdWre3<!M׫빑 0­?(2s(rTvh"Pz31œ]t^lBg7yP:?V'ХڵrJ^94d2W}LB- 9ĄhšI9Qjя=iڱ?6A`4h4װ(P.W2d19,8fXy>J *,-P 6Fg$;z< =i3q +/v >Nȓ\FxGjTK+\cUE"&˖ӧbr˅b>l7$ _;D=i:/86 lM#ʖ5dk(ן +'X2 =tcHʘU)/t5Г,G3Q'/?#ȺuRJi*r +208 Zvcq;P{ܖhHNH|Q.P{$5ۡ'X|,wQd(U4|yU!RN grztGo!̾>FQQ6{Lmh/B$zLyԨʓ[dzkȣ<8ŌXR2 Wws"!HQa)xlR6zrI+0`-ovm*f Y6DVCASXrq"KmмBdķonZ!&!)chSc& fuMNtBKU%o4+#?$\`Xf;:S &)D%GmNgߝ  oHX,c#\yGPUxn9/MV 9$& N/,uUD,Otx_)4 _4®6B虐^O=2mo15~"bTEfu+RΚ$e䨪ɽDv$娜*%UN@%'%d~HUTٞý"26UIbҬ3.D5΅ё#7jQJHh-ݤX| !#|*rζ\C'WOf²1:plPrTx-9!{ARFaqk $a9/mYU֥' NNq%r;zw]crߐ#9ɢR>͉zmG5|\cjHϮ|UE'8#89X2aM,с7$e(sMt @' te$"WKe\Bgblq1%„eGNc?BRF-Uq*?V8ZȈ@U9Sn ڦؚ굲M<"*"Yr{.E1K)tHIʶ\ߑM LR҉$%1Ffg = ")UiTYΫ"m_L/q]TzNң}gAeԟȊdҤ9Yj )xd4 @4̓OR:rlD~㎕Ԭ#kG˅_tU?nt<JH@|9ߔCX]7=- Hd$2@iUK%pr42 +Nkaޜ wtӑG{*"JH ڨ=7]!~Q|E4ל2 NԒ){S] vkaX +w|@D)ྔ EXa/n_ww+ %7EsMOʽ"k\b|v\jH{k+m7]Ba)(b;1 rJhtH NH^~g"t@gtͺ"P`L,s(Z"/"2FrEʗ*{HBJ9r@1)I&r=-T:r%Yulir2rp"4]q c ,}Ƅe[&tEbj)WߘڱX$UtǘFUdWܚ%{7"H]CǗJui Z90%31:"J~71I)$PH6Al >6d~DsMwܖ#7ڵrٲēCzrj5K/,ѹcB2Uߖk©֖RP){ nVSL ”2g=کMp`W*2Ө,[FUS+1@aNˈIGtې5>CD5$$xp4@|77UGk֐*>?oY0wt3op*ct%%8)jϹ_J%⺺7 !#-#QU4㐉7q(8zM";z4љD[ph;@R%Q>tXFg7fW]۲"@:;zb=.M]O )H;Q SCҏS,$崄 z +]Œ,h3*4g*uʕM?|22zrr3nXAXF|yrct )3zKVRd@4$%PFtvOґ+5ilMR)D#c)&/Ӡ'h 2D1:}CR{OBy0M)SVݬbF'QadNԒ%{7H+TEZ'+WCL:!wtP/74vo$f蜄I񊐑=T٘]+/JgCCZ#&J>LOt*kpGGd̛H!HR ~D*1Ka;DXٕ'7TY "mk &Ē \%}d'I)TÞ?<VRHhGQ;#9B@@m"`9Pa6hcK!#mXb;G)B|(bup%JRDkR,:;+{ +c"P@mH:!'|dol44Q_pŹll$%fb|&LWBpCEB(BcNRe)(r4{R-??DoR +6XHb +7>psߐZ_[w7pot F.+$%3a)Z‡س?Ii&aϦz&JGN +RDtl9-ǗJui B W;zڞ'rbN(}ߦe[XT+>%)'>Ctv $zr5+1 ,(jpGOΝn!쀤,t)le^3VV7(V d2LWS +oɦb=2eGȹo!;=ֿf|D܂sڱ8$%G|['ћc Uk0]DCXf(MjKڑ&j +q$AE)icl.KR[93v:(09=N(a a5=A1:!)}|7]z`E)uMГD Ǟuwǘ)/,*TbCVB%"J)jxY<5t=)AM4ހ;'xKX&;zoHJX*,$ֹ&QUt &1Ise„ew<ݜ-CRžݤBxX\{u٧k9Dvy+%'a٨]=ct>ޖᏐ'y(|ƬJ Lc@zZ X;6ğ;zW>hHPzF"'EʻQwJ (*09&"8i^ 3΄esXct 5GIxo4/K]$CRFvhQmMA䱥u64-CjaYFbaܷ[*,蜾 '9ww&]uu*W7'zmU,b%ctIDep6Pk$AR[hY?)I2§{ L#,&J>TON(ѳ@8 IY,QHJRnw7d'2%$%QEטyWjIHM,l^Cz3%hN63sBt!ʦtڹD]]ؚz01ɔ9 sGRpG\L sߐZʮM3I9YR 5 ]9Ĉ5͉^ 1 +#[=JI痔Es˧+m<ٍ7ǛTT,[O9OLaIK*ZEB(os4%evoaD٦Emf +BO +N/k<8V;H;-box;cM9\R,{Cs*)rȈgbEL'b' @PKþ~"Kj)rD>U8JNi|ϭt)095ټôL 8AXW4pVBC竍Z?a9XROWr TyPpr+D z KX\GSQk&)^ҁҘ+9@LyԮ~`~~{G,;ƴ +RZ:@ʗ2i3'Rܢl'1.My(MTRQD6,,{ + J&>(ٝ<7 LΗ|"&m@7cᱯ;:s.k)~@Jg:s)iϲO7Ę5(q*WPq;zG5o[ĉvZk6>sJ*dǗIuiN6fKx3X-̄nhct )$>/Z%L#J=% AX@} +djx0yM,^C +Z51zlxMYjO2I0 nP5[/nsT$qXEzLXR}(f&@w,Y1:2Ιvx2̚Fj8ft尽֛j @"S&tE'$,O bNPF)F`b Kl%QEB !J,ibdz'"NٱsGSsq/)ꑬzy $o7)lvSS4[*y e9Ah>\49I7>`T<8u-9SE6=0"-G\@yp|D(sL~.g.]{~ig$ϓ$CSR_OWZՇ.K♜GRk7>`\M,~sKjEҖ}&A~^9* H_r,M`}Ҧ\$]7/y$'%f%͘4+INNv%%%''=Bқ-}J~wKi7'}i%Iuz3<4̙$# 'q CLUY9kR`D =H%Sp2 f*Dږtˑ5ctH*m&)}TUF&#WuJ^)6oHsA%s$9=$ ]$=&' IWvPq6WVًRų<LZ$g=0f-ct!)n>sA{d|4#?uE M>?eJ:팤{=$q&ӣPRh"r:6Jݜ1I #J@}\,{stE6 D*"ЅBX&# Fhd#S9t{]uys2i3$x3gq +[@*m,!!)k2)ɮty`=V^9z==$qׯ-s5DSS3Uo4k)@ЯL$e[pR׼ԤY3I1HdV@"9CPʑE]XUũ9{Se] pb2pGL19'!) B O-k\7Od&iIO!]"ldh( ȱ5*T:Oygna9O`*Wa!ч @ pGRle`IJQ#%&KR9#)ifpr1tU)%uAc! tzmSpr$@M,CQ\ +:XYy<(aTΚYUTC>]aamoL0l=WΗC,R:]uɹNb" XjkmT8 +x;З׌<^g +3-%'+bI Ocz7/z s" 8 +eCeܙOCBRX7'(47+AARR4)D QN\+"&˖>ωlݣv]|J|SC2b2PUx TFt:mg큱96&UEp)4BdC^LԐ.yӒ>Ywf&g']$OOp%PevGLQFoZ1{u+eTN)Co1ŘcrCZRÆ{¾[Lff]XWf˭UO>;.N3P$tlF$%Rؒtl}{sj֡`0*#"_4%s8÷no\4* x=]X_xY}Gn}⮚g~~mՎ]*?Yew?7>sf9]_U&%ERLӞvE/^:\!rDј[?a=ӍO2H&= .+]Tϫ꿯 jqŁ';?|^;ށOSߛ;g3'Bqƙ7o^_R&Tm54G&t тg,eiC4jR7<12Ÿ&٥ϯz1}8tez7roEү`8?㓯3=yG8HwJ3f`cJ*WRR|ECZ E?E)[\PWr%SV?jWK*wod?B/{?yS72XA>I(o<90*_Г#LΣ"&Ry?S/\\m38B7* 3)udC1F*eϳҋ5}j[⻯EO䦙n2E&&?@r 8P  D4B^] + 9{JOkQtp[{otS9QKѥ%Wmnc|a1}~I?.R(h|ӈ1qM T⨢qzr*zRmQdg>It`wt&KP9 @ %1-_ܒ7k.1/tm?}'cU[D4oDޠL4Qc,3A!''-&h'ڱvk06XkrDQ㊢?Z" mћsn}_+ן-?nR}Tx$| ]#|QՓwrct͗+c9MW\O LF:1Ec`7gN\&J|cw/;2I.xgЎw^);"Ȥch*bX# [rE]Lg* 7/r?i%&FpbQþ;/hHF3ȾxV<?/n"J?uOWToPR[ɾݝ+^EI1"Q8vE#X"DI|S +I ѵnrKIIt$A2}f.1~ϐ}?V?jkJybU-7Js:#Ì*'''&]Ib$& J}.;krSPE е굱.^6Hwwk~iH)i&)%}CT<@Yzy8?o>WK*1gRF뵜GOF|%R޾ )S5nT*tEpF䣇:_Fݦ}7͞[_ti]E_T?lxŁH1!Ҽ=^Z|+hӞ;=9m4ʢդ>ܚ2(e:/1n;Ⱦ{:=/z*y9ϛ;>o~}ɕ^<@+_ίܵz^|#|!n&ΗC"a-uFFhz2fzR@LzrB +uyZ]ZM//_!!8 ĈӢcJ'u֞EF/L.\L~r)?[+Tݤb}B/:F3;n 'CII̙VI!S9ҨHy &Qw׮mD!nehiӾ{ 1fCڇoOQ6wŕ{-凶3h +F}7׊12`r'Gד<8iԍw(ADڊUֿAG+qnҐ^=>bɾ٥U3^ʭܽr#\i=E'btГɤ$mtkd˧k)V_pa>|֛bKypm <z3"ơQVTzaߝ5duQ+Tqi*e|kk;/IQ}y(Q@OXV9.,v^+>p79gr 'XÌÊO/<%=빠>K>Ú'Ỹ4%beR/]R{^)fϗkݣ8x#%@Oɘ{Nx}$#J1 T"hrNՒDHކ+cwB݅mی_YʗWzurh>nz #;_.@O(.Zў= y$%'Ip)b:FKz۴烈\@jXK(+؝5o˫vdSˁ'i[[~J&$ڥH#OIΗ"FEU'O{zROZs$΃LΗM[LWOi}ƾ1nEsL^./*C1>gڮWO#Y4MӘ1qԎiU@OaL+9s+9)>(p~Iɚ21aV@#zJG~[Ӫ^̭hzWihӾh)f ldX2U&&aC9MW\.{rcLOa5["w‹#$_)ؽbxh;|ڐ}wn@O +=I[gi)R8[X9w:qp 3)ΚC 6./O)F`̮o{yJE0c"eGFaD#W'[K[wGZ)>r t9,s +Np6fǴ᫓L gOd41 ܌uȏbƚ':̗ݛ+Њd߽@Q2}T"ӍΛ?"t#D#H4' IxWNWK+p"V^9441i/BE3D#9xg(+[tQݖjq?ɾ{cc|{XRF|žc_0Ip=$'IlgK%(&hrOx50ׂ:_w0WafzsΣΗҫ6PiT[jq?Vx6(dC+ /ef Id=ެ%mŤX\Rzr_~ +Zrp4d_mY84%Ⱦ1?NuWm?}W4e&+woaruK!ďߡ"aݦMtYO*\O +fk=]Q|fdΤ>}s)(b |O+%{7|g~}Eu>zgyWF釩Kŷ_,{û@Q1q}7G^h $A5hPϮdtnr|4]qTfJimDڟ)ica\wƜeǸڇoyU/fS$TAn}hӥEq/! 'x}_o;Nǯch~ؕѓ⭩MvS 9D Ilyy5${I +N +2S9(!@FNMe9+{/?տ޵탽{˴e$Ax_ftܱXʙݐACHt'2S:rR ;/Yϫkzj~NmWT{ٽ=;{>:=hO_{oʾ{ %Dѓq4Ez3x%$Q+pW!OdRF{zz +:CH_sT%[dzwogb_W>O=>ܷ/~. .{=Qՠy +>β9K>]>]񺵆tͷn٨tv55mww]L[ncb?:^`û?{}q{=ɐ,8~ %vwc9on{nƔ$:%6rH=(^ +tas۶mzJ*xo^O$/?9"mvfƙ,L|xj$w,t0y(`<Sl*=i7mR5Q[6+|p]t|o5|=*L^nLv]K=LJkKדX%% 1 H4-WDGgYuY>tCA% JI9s`CA%I pi&#'/1~ZzEwbWm| }iûۻ?}KCaf%#-Qu @"zm8A]2޼T 5bvS_Í3J|i|_.VPΠvCGk/nP*|P8Ӗo*BG+U$')_rGM_OC:FWH`/6jsfsa_>| ?_5 {^`J|^h@XRd?ط/$ՓB:2t͚ۖ%;WqM]QA2 +#@'EbFFt pAVnjAzxꞭb0Qy@OO"m}駟~}/*s5_rǍW7XM>A|˟^d ~E:{k/=c5ײԳ{ks&8,/owk,{gN6w } g+] _EU3Qkmg4]i}Cθ_5 =sGv=oW{ {ÃlRݢ8ό KOU8g<(>>'[w[Հ @8 PB +%@Bc܀GI@dl5wclq{l|3wSI73=!}m#:eN}129!1wY\tW]=>k/Lzfx{KGl!\GL 7sǥkbny~D˨OoDr7D-V+_~gRD 0-$nXsH= ,zY,7.6)'^3'ŬƊynn, XX[5IY.+G:՛usG?᧿O?r޿Lsy\W!_̇\VUz9顱&%DBVaUOQ𧼇Uxѕ% +cT FJbSi }E3s F+?(\4T2i!nxKXXm$ E|rMƭxt<0μvʼnOg̷x*Z0}1#5v+1g2hNfeх;<5s%;zQ'qkJ.i՞ +#Uրtuy9{gQΛrLo ]Q틼id4_`^{tB¸ λ庫ͯS{Rud?Y4].2ﱞZǚcxN&S1K2g&W0>9,)Fv^?=ܿrVΛY7p}ˀnqwyḎo%tyok~uO=O:&s0.xНtֱMJ9oP'i`pPaƚ[;XQxLx yʋ$kzYFjNK򘿗.La\>>ǒ?ǦnA⹛0D +,i9n?&X^Ͷl1q~fu$Z{0EcOw]%?uN 6]!//^QHKsSk]`.a3%fn:?C QwC-6,7#pU: Q^ŜܬH} ʊ8+gSObJ!]]Iޤ<  ABJzk8vL7pF˛wv/Ʈ^ȇC̴Df b{Ug`ʒ{|l[*'G|=C{@XZ`7m^N27r[J _{>0s~@-DZeq2fsֳ)9qZ9oEsIDu QŠT϶`Ğ=P߲?D}Ƈ[F̌G(Y6 +V')'sj'ɶx7툅ҕϋrMޤ) 'fߌHL^ov^]#•yEtnƲ}3V/n1O-4^n {f+I$hMVzrqf& dʼnl+ݾܖHoo<9us>j QG%*+cÒܕ~LqO8 +4u}oOٞJOb5fC$ēݏ >aމ"hC!wV,q?y6Z%!,[/+c:Z+|n*S* w%Hp7,7D|mHycճB}Ia3śXG;hH@풧r_*(߲e"v*&>=AKŞO=nj/1Y?j4 +azy SXa_{ɉ܍ ww=3'K@2EuEiAb)*k Hok^-.n.u,l/'ֱ-RqVs]9XQx+MЇ sȸޡLJ粃P^.U›w2jH +QeUGO[ +޾4'Y*2JgNA림w2\(^]}Ըm>9,,@uXM OfGfOod%8 -+--%%K.?3YX]^M rҍN˝ &Nn&B;/LG&| ?J}"E_M=sO_7hF̠=๙U҃>^D}ˠggeCԱZi},na} g_校ۼ^nWAX /wOjմkDCVoQ 5@sΖ8+s#yad}ț 2-~䧕*W͟(g;Nz#^RT d=[|Sq!X/VfUnҗU(~YKx'#[&H~̺7#sR|5$Hd uByXg,\?j2&wtI RMqWQBk`[jv/F|z;x{+!5E9/NYܱ %Oz5pm,_p/U*Y&YUJJ?a> lTr$ybV]*{~_xU99y'77z97f ,E'.7,9D}Ni6ݬ[ď>ډ['$TLUz14Mc&ri\Dt1zVi`:jt,gl謺tOY8gEt7\tҸ<Ւ r*lOࠓ"kb$܉۽RvLNvIFM]җ|<|L/+'kZ]'_Նgq]F|Km2z$kfGD.egQBY͍ qLDm}vsLJ5[Cniy6YIȝx8c'B*'GTT K#6|˕f0O{✏n,w t Zpvit]6 $"JmOIZsEԑEa$#Dq~Mo^orIFeZ/WI+#|Lv5V!:&U]'ݰ M7MY+Q^lR ʝ^䳻Jyk"dn()ĿLsQ v+r33K}~\ H_Ƭu^u wz$'ugƃǎg&.ǙMX%04/cq&zpAlZ{ߖY9Fz&8&ś{ }orPǛwrN`@zv*kC2Wf.?%m>nLaM7X̙ddQ޻ΤZxalMIM+kFq)Q _x|G7yY452(0kQ_&ŃC? {\?͗.ZdZ8{ +o,g}Z>"ҟv #+Jo|uk#4ڝc^X1Kŀ(B!̽tLt IkżQ8[EDy!eN-f3rd^{Rb mU/3xs y{jvՀH,X)[t!Aig/p#+į'ę?{^W{ +#1 }Už̲ _cq? m+2}/I 7&}d!}y(Oeb7~kJ +#XZJ_ZYȀeXQ5 t&={19]ܖFwrN&=p=p#Lw2Lsˑz.ʫ_|A_1XYV&?kՂYe܏}iU{wwĎTQ )If#@#oY?E4@cNVR_ƀXuUޫ-|K%./fk|>kt-akÒM3o^^D>nKM:0%i]y{7nkJ?1qNmbe%inpՀt<*V%keynqY~˘X8-]s\Q8{ka_*wK[K/qw璼ikf+qpp˄EI$V-}BL/~ /ɗkΫr볬 ]g!5]49+`lן q ځ,a_3/NJE\1/gXViN3W_[ Bo,7@R{@ziwj HgN=!b+VC("w]xy03s_Y%yl3GXNZ/8' p 2]9?y}EEEMqW\kOefd +(}/L.^_7@[QY+-e2n)j )u+!-y<32޺![6Ӫ,a>g>//xEnKSQi20/1d<p2P +pH=e".e{ )vn,9ŀM^WvR.f_ծod88]ynj,?ԗYV7pFQrrZrQbU k5S@ACfBLb[ɞGJkQZ#8>u_J >ܨ@f.m16] aw +?aQP2=`ܸ঵+ +NaSǩ_OGb<݋r¡tᢞ~qϮtf[t(03%`SVxQ ߯ Mm +n_(0=GjyOfeQ}ZƮ5[U'6d,1[8߽~SZGbߏ{rf@pz/7y U6@USM=, fW 1{^)?j1#On޸ܜM\Ra ]KlV ~!_\6=s8]H;_/jC9L=0cPIc6bVw.Nm:r٤Y+ubӯyȀ9\VG/kM*}3ImYUEvd͝v]qCx탯ʹjM|(Ο&SԶ5\ubBo߯NC{a֣F6yVAXW_&Iwp +a=`.o:{k-;S[LփE?N ؘqMs*g1rHVvD0P +Iد%Oŝjn1EWƮۍhex.Tql/#SدWM1~*[>ycrS"hm2w7Bc-vwpՉM +ɗ9{{jn1,w-,u,'!$3>vS}-ši<$uW6,VB_c7n1Z7_kĦoN5=ӬͩlTZaB~S*#MRnha?οuk5o}$EdljA#/[7 [ޯ7EԁM[ZGOBØnĭװh0ɹk5#P{մo/ +~"DC}M=>:ȓm-}goM2L~~׿WhVYCJ!vq[+݈4{7<$?rf^:5c=o,!.{kĢ34+Wgwq)n5$?WW תP>n9[YXtqoXV0‘~cn[!2bFjeL*rpoy 0l_{#C*Hfo+#7Qؕ4CH]^U\Lf7C+2IP~{N7 k|ߗ~΃|&6ݠSCFPn?W t0cU1gs H_^H=db)5 +`.NZ:!Ups60YMt׷&5U٧򙜯+ɰBmZ.j{6^hC!B^o3w[4dc P؃r.0q:;C:vcvqh.{u&M^}h đ.q<1g(KxHcpdGT3>Fe}2 Eп0G=Ƽ2{XMgŢ {¥l`cv+֋DпXt(- ^J}^BO N0kA,-6D )8𼇲P6Ʀޠ!]_U]nn [=0mZW8l]ƽ/0:Z+?AZuث? <4CP:T#< c{e:_U(ׇcXH88w?# +GۯA{H|%uD <DϾ?C+56}TkxūeY ]T>HK~rWkbApѳOv{mX7MҘIUcٿ}d"ݵhf'{?٪rQItC4v2b[- !mycNGLb(r/7$k 'R^іaONS~wY7*>_&Jߘ&lw;hfTJ{&1On"Hq2n7~:v?E=ĘBu(T[CI/^^xj'¢)!!^TnD5x:JuܯUWvZbHL=jĦSp잣耸4H]yHWMJ&Ʊ4b&3oS[wǦk:({C=$nr$ݏkovggXZd=||mM%7ZwhKۨh{>ু/jԃj_j |(!8/1?d h3iO=ۥ4%7 o7 [8zaCCDI-ހv'7Bo@3nKLF:/f A}/K 7 B0 r.:s6 6)3߳z1ն6= .G٤)KQh h{D$p) W[[{. n$ǢtLpT!L[ϳZrJ]ý}(Sf;S@_Aƹy( +rGqMYxnkVm\l1Y=JթJ?}߳Ak d++on3L]o[سh*irg.  D33VOI*;C&B$J{vE^Ξchao~Bv Ozyt9< ٽƁ?_OMl2W܅Yb2F"wۨcí+a@b}?ks6gjQo :,zӛ.a`D%m78r>,zaҦr#㻑цEo;뭣Ɓ¢o̔o^[ +J!4|d\ǿDnD LnGJn~%ǁ@Ta3JX|)`\rZSI7@nĭt>J1tF4i.}!7y/%" ĢF,Px%RɭTr#6@q@7,F*G(#܈[|JCJ*7"&{>b/Lf:VnS9p*8t~?FsT ph^nub-q$#P-i.%o6=|Ï?;vq@ezs-j &@e*3*?W SI_;:>I?NaဢX4Mo a5Ŀb"a/1v9ŦY Zh (Cw/e5_nx%P~{tz3%>X箄րX6܃M~\Klh Ebƕ9^-mR`g"? 1)caJԀF'۩wTo˂Ħ"Pvs/_Xawma՛Aztj, $MpB nȶ 59?3 }#hvUobi89Lo8\qw+W }azqI>CߎAo\qe:i+AT@[@7$~Fq0I|xM Ǧ{K7wϫ:b#(q_HaSYoxzK(@3j#1cc8 +h{S#-:W>ǡoJhi N>tzsC'1?ytVo=Q{<<@bSYohM.W&"~Ƴ J66=pz+.iq{dW{I>HaOxFW7P(E恞*P*(%Ej4fxBەőn4~8H!126\JwZrqڀzb*MMn4ǦX&ܶu*^J æz(M2uqx(MJM}%@Ml/Tn"};EC:Il޸=(b]0oRy;0 E׍RBn<(91(MR[{7S%01bHyj-c%-y^urb.kW XtyˍY m:6#ܘھ7$Pf/* " 4n)@},ˍKw"RTǦ^+D2({ܛ7&!84M:`ވܕ@p@a, eZL mAp@YlzMJz/Ԅm^7ټXZrt9 +m@p@IZyj֍twp$P y#\p(E7&yџ*j8P ?)0~LbBp@+ 2!@Z6DaoR`3!8!JXIqg iqSԷo~cOG}>Z n.@nl:zcA+,ƢQ;V$@f,\EP/}@&FEZ&2P_p9q7?Jo$}sz鍽킅Rbӕ4I1ɥ.꧛ވ9hv{mo I%}M;&NkV ~nH?ita.M' 8 Ro|O;ȅC] 8 6XxaOF7~w@,fv Lp ! -/]E  JZ;I ȃMؼsz{ HC{cb2~wz$T_H1 3Q^$¦i7 HECR!7 6-3t՛I84[jCE2{_Uoy d]fSwü`ꍽN`zʍeNp}8¦p=1I 6>HOfa_#: ¦7y 6-誥 ·3dX-rA7 6y7 6n Mrfx-62vl7 \N 5V!MA HM7'i3H p'tt@ fހtXtfW$7 }ӣLr0o@>*; $W1i#8\s zdSA-ʻ۵Go&9K$eǘ81q7 -6=rn& =ia endstream endobj 31 0 obj <>stream +:yǑ bm:wlGyqhq.]ڷBo2jڥ& wHCӵ[ؘ "&0rΗIDL"-c 0H ۣ}{wڱCG&/@b~}wԡ)8I 1LoԿw.c+!w!d= اgfbTכAfc  ԯgNb)7 56zAwazS$ ȍMf<%оcM2xZG  \G^iѴ\3q'tCYm ¼ٱ釣F Ч3p1 + 2I!$ش#&ewpO-cӣōE(S#c֑t)1(M_:Mg8HH6瞒8t@޽DD yȥG mLo{S{2Ґjz)#Л%&&I # Eo?u!Lo;+7܀ % v?84clRܐ@R< )NC?<7ݣkXLԖIi9Էww=wH'}6zSF r+(6pI )Lo'5&~`7QA)=v+IyvRFߗ7^%Lr0o@VN|to짆wM_Orh ?ӛ !@ ѿO̾:$c2ճs8I6 hE?WN cF8\opCSz(L{.q@,?Л7/a߳8TB1wr.7'zVo܅=zt$ԛAb8t|nBԖpP"-:0ɿpH?vۮ) o o@#l:Ror'o@'l몮۷pf#cN;ws!y:a;0gޘ}{7]Po& +-AV]th/\bO:.b79}p'^8b< w{+ I KLrN"-Z?[TsCH7$whM_^Ɠ0o@32&UtæΏPor:qvtP 'O IJƃqL2d ~Oo܁-1+4plSF7CeLU Ja$SlAE ӐMo184h {No̻}c0]+܈!Lo7H7<Zc OV]tĦvh . b7%6Џȵ3I0BbVo&qeIzBo :qlp@ +C1x ZaІ3ygmXJi[Nٚ]eA; fmh+1w2 D56m.ReX6 wD7][x 辋 +C~N6mu0o[[p2vI8M L}%qhvN4ep'p]'8ij3HNajx +MLo`SgvEHE+ok!yr%N:6{-1[Ap&ycM_*i0oĢZN tC+:z,Z7iC2:pl?܂{9 +Iq:s7#o +Ya{^݂I#̂%Fj.æUp?<sW8K)c砞 zΟOpGDLib&& ;8Ǣ-IE`5ceLr`g2 tNX8{E8tnX8$8LpSq\JN/ }ax)e疗R%YRzHb@#`:2 "4ҔVvy'`h =~ogah=qG!^dh=pYp&9k8Ew\ҢA7EiL㈘H,:3H Xlv(i1XA=Xl%Y7_Ji_xyzl<$38OJ) "Rp4Zw7Wprax4A:-i4yH$,ǤY& q_b@Gfv1#B @`)9& p(hL2kc8t_ @qh|sSM< MƱ(-II1(Z0}QI-:}J7q_߽I&.܆ f&9& ̈́)qMT84JJ?}&d7 ͅ;ye-@2͆'ynT#J< %@ʏ~סQo +Wp^cL`hLp6qem_4hLu)JZT}!`'WAh9LF{o 7!cw8n-JxB {>!7&{'=_ 'Jo?$Ep#?$g킁 \0wC10pJ$ vDL6=p*L+8ƒE8!:4o7M\lApNk8tσC @顳:C~ao6xݧ7X)ܹK$YK3{9s9νz7 2O!@|JOpp;Q tEH98'ɷz@DrpOP{ 8'l P37Y{C |'_ҽs9&PVS㭹QJŗh@@x N0Ǜ$ߤ#@x e4 %'Wȧ.ڽ+-wr08P""wzxdXW!ހ +}MbFF|7vn%P<ܨ]98sp0߆Ș܍1y2ǧ$ಾES\_7ްzw7$#龻7@;c7 =w@_p3N dpGS}N$t+P{ Ԇ~Ñ/Tpaf4 g;wQ=yYP.X!c`@y鳨=tdgn]9ҙ~ΘAAn#9vp޼37S](JR _~>#P,tg%'i{K="8/SNͥdU Fp_{%̏yȏ lⴓC.(YPQ,|9w`b@m16t=9J|ppΐ_"I93i)?2Iڷ/b9@ëXto ciHGpq d+:.5 l PwU|y;r"Vsz1@gK57YGpv=ɡ%pnl4L|q$J|L'Jг78${g&z '!~x7N~f=]bsLO4(үΔ›Q)\ddo0?rf + ct,+@pf$yʀ/_9bGf|X +_l}8rr'_j-AUoif~tn=R],%_q"p)v՛nYN+y`#3L)CMئB&I;#”  r) 3 ZGސ44 GHANOprFYɠtp%m>hʄ”~'0DoN927KCMR `bt_V\D鷱=d+lҲ{6,Øu9/|/Ks<o1btft2 ȣɜPv}Ҳ{n]JIs奙 #T S})f{c#g_ B6LD鑙ES'@Q)[p]j-S_6C #C^65d89\*s յqnnUr@ɬ;[- :c0ӚcuDpΠn w=sp_`+ du{ 01rlB7VڟBC:dX +?gOBP涋mL=C) +~КVQGKf ytETmTdE8Y?^MՓ$8qJ\02&VQG_<26OGݴoX &9&Lz<9p(dl^K/r3"]0^2܋|% ?~ЛN-"ŖΟc#Ǣ#KS~69>QtG` oca+C o޾5olah/pnix %*O A^+cenGziYJS/ܨ _;8w}=M$>+gWTQ,7ҀHn d]޷ye< Rnp7S +G&ǀx47L:0{[ixgyrlKs4?yx9r4.|)6;08y it ei7 ba(s;SOms{sCE{]-.irms8ITx#L>7/ lHR졥±[y77`p+y3뎟릜%]!⽽^kahfտ>FYNp`koqɽ}'p(O\xMM2H;8fף/<XBB>L~ (fǬ=(x dl /"+D- s(Jf_3IbLl[i;8d馽P CdZ<}l7q}DX1R[i=pZeE\>5g&H0ZNB*AfcJ /#A S +WE>!pr@͍˿r׮1H^ҋ/P6dd2T\ 6#ܥ*#FƏI]ç/঍?/0iml3R +Mڐr#rM7AԱc}m߸᧫V2(&C@S +_Zv׿Xnt8<]>xG~~݆9_u!ԍd~Z@.]Zaz1M †8/xs3ݵ 1qK]17|s|@X +G#_o/-m5YQgM ңKf}]\{Ւ>X" Lƈ0y0psDB9z|(1/ bJS_JCqZ3V6 /+ՆgF/-)6*t5fMsRs"Kc(N4S_>U$P&)+mE GceQk\~']6Tgmm6Լ^Wc5g*cbE Ćx:)>n%ӶZפmЬ7g袲YzGsW`.#-ɘ7+Fkmj}|֛#W?k¦FCAQ]rCF˺ڼx}A`lN6}[Mb[fLQe5E&;Őܬ.]ї9یMٵm%re|v`-Ԣj-2R樾 +C2l27kʲB]_zuEkFV\L6ڠQw>j0#ݽ˴5EZr%}n\bj{RuD93rx G^r0&ϤꯏfΡ@ݗѮh rfENMݘST4 +mIT:VQ +}Vowö^5ݍ{cs"fjZL}wQc02c;ӝ>Rl[)qW6z]P"~`s+[EbZBDQnSMC(ΑXߝ:؝[d2csbm֖ ߥ,mj0QoӒX3@ggT*+ kkʛu9jg8^ng2R' )UUҟѕnHoo.p4$GMΠFh2s\^m1e^#<tNZ`TimYPG>t ~TP:-Jԓ+\e6ZU*SSuԷv)6Z,EI}v^ұ/МߝC40w#d*]Ѣn+ ڢWeO16UeFVk]Uݥ+Փf!r؃&ܙs͚5GPF[SRBY.ĤkY-Ime)U&92ͨn.6W-3[Zcu ZmkIF[\e'yP'+RB兆h&+ٸ^Zҥ5e)v}JSTȭv9QNhlNXƩ]ָ3Ra6%SJ][i[M9efBJwŕJ +"'9h,dRLQZJӔjcIAǪ|٘֘ڣcIi)-2IUV:*q[< = +p*EwmlعU{O쫀mش*0L1YU_{̻˳/T Vɭ +xTs4> +LL*\q3Q5 J,(I endstream endobj 15 0 obj [/ICCBased 19 0 R] endobj 6 0 obj [5 0 R] endobj 32 0 obj <> endobj xref 0 33 0000000000 65535 f +0000000016 00000 n +0000000144 00000 n +0000047649 00000 n +0000000000 00000 f +0000163121 00000 n +0000593503 00000 n +0000047700 00000 n +0000048109 00000 n +0000048283 00000 n +0000163420 00000 n +0000139682 00000 n +0000163307 00000 n +0000049181 00000 n +0000048344 00000 n +0000593468 00000 n +0000048620 00000 n +0000048668 00000 n +0000139717 00000 n +0000160473 00000 n +0000163191 00000 n +0000163222 00000 n +0000163494 00000 n +0000163800 00000 n +0000165099 00000 n +0000187851 00000 n +0000253439 00000 n +0000319027 00000 n +0000384615 00000 n +0000450203 00000 n +0000515791 00000 n +0000581379 00000 n +0000593526 00000 n +trailer <]>> startxref 593722 %%EOF \ No newline at end of file diff --git a/old-ui/design/chromeStorePics/promo1400560.png b/old-ui/design/chromeStorePics/promo1400560.png new file mode 100644 index 000000000..d3637ecc8 Binary files /dev/null and b/old-ui/design/chromeStorePics/promo1400560.png differ diff --git a/old-ui/design/chromeStorePics/promo440280.png b/old-ui/design/chromeStorePics/promo440280.png new file mode 100644 index 000000000..c1f92b1c0 Binary files /dev/null and b/old-ui/design/chromeStorePics/promo440280.png differ diff --git a/old-ui/design/chromeStorePics/promo920680.png b/old-ui/design/chromeStorePics/promo920680.png new file mode 100644 index 000000000..726bd810a Binary files /dev/null and b/old-ui/design/chromeStorePics/promo920680.png differ diff --git a/old-ui/design/chromeStorePics/screen_dao_accounts.png b/old-ui/design/chromeStorePics/screen_dao_accounts.png new file mode 100644 index 000000000..1a2e8052c Binary files /dev/null and b/old-ui/design/chromeStorePics/screen_dao_accounts.png differ diff --git a/old-ui/design/chromeStorePics/screen_dao_locked.png b/old-ui/design/chromeStorePics/screen_dao_locked.png new file mode 100644 index 000000000..6592c17e4 Binary files /dev/null and b/old-ui/design/chromeStorePics/screen_dao_locked.png differ diff --git a/old-ui/design/chromeStorePics/screen_dao_notification.png b/old-ui/design/chromeStorePics/screen_dao_notification.png new file mode 100644 index 000000000..baeb2ec39 Binary files /dev/null and b/old-ui/design/chromeStorePics/screen_dao_notification.png differ diff --git a/old-ui/design/chromeStorePics/screen_wei_account.png b/old-ui/design/chromeStorePics/screen_wei_account.png new file mode 100644 index 000000000..23301e4bf Binary files /dev/null and b/old-ui/design/chromeStorePics/screen_wei_account.png differ diff --git a/old-ui/design/chromeStorePics/screen_wei_notification.png b/old-ui/design/chromeStorePics/screen_wei_notification.png new file mode 100644 index 000000000..7a763e5df Binary files /dev/null and b/old-ui/design/chromeStorePics/screen_wei_notification.png differ diff --git a/old-ui/design/metamask-logo-eyes.png b/old-ui/design/metamask-logo-eyes.png new file mode 100644 index 000000000..c29331b28 Binary files /dev/null and b/old-ui/design/metamask-logo-eyes.png differ diff --git a/old-ui/design/wireframes/1st_time_use.png b/old-ui/design/wireframes/1st_time_use.png new file mode 100644 index 000000000..c18ced5e2 Binary files /dev/null and b/old-ui/design/wireframes/1st_time_use.png differ diff --git a/old-ui/design/wireframes/metamask_wfs_jan_13.pdf b/old-ui/design/wireframes/metamask_wfs_jan_13.pdf new file mode 100644 index 000000000..c77c9274a Binary files /dev/null and b/old-ui/design/wireframes/metamask_wfs_jan_13.pdf differ diff --git a/old-ui/design/wireframes/metamask_wfs_jan_13.png b/old-ui/design/wireframes/metamask_wfs_jan_13.png new file mode 100644 index 000000000..d71d7bdb4 Binary files /dev/null and b/old-ui/design/wireframes/metamask_wfs_jan_13.png differ diff --git a/old-ui/design/wireframes/metamask_wfs_jan_18.pdf b/old-ui/design/wireframes/metamask_wfs_jan_18.pdf new file mode 100644 index 000000000..592ba8532 Binary files /dev/null and b/old-ui/design/wireframes/metamask_wfs_jan_18.pdf differ diff --git a/old-ui/example.js b/old-ui/example.js new file mode 100644 index 000000000..4627c0e9c --- /dev/null +++ b/old-ui/example.js @@ -0,0 +1,123 @@ +const injectCss = require('inject-css') +const MetaMaskUi = require('./index.js') +const MetaMaskUiCss = require('./css.js') +const EventEmitter = require('events').EventEmitter + +// account management + +var identities = { + '0x1113462427bcc9133bb46e88bcbe39cd7ef0e111': { + name: 'Walrus', + img: 'QmW6hcwYzXrNkuHrpvo58YeZvbZxUddv69ATSHY3BHpPdd', + address: '0x1113462427bcc9133bb46e88bcbe39cd7ef0e111', + balance: 220, + txCount: 4, + }, + '0x222462427bcc9133bb46e88bcbe39cd7ef0e7222': { + name: 'Tardus', + img: 'QmQYaRdrf2EhRhJWaHnts8Meu1mZiXrNib5W1P6cYmXWRL', + address: '0x222462427bcc9133bb46e88bcbe39cd7ef0e7222', + balance: 10.005, + txCount: 16, + }, + '0x333462427bcc9133bb46e88bcbe39cd7ef0e7333': { + name: 'Gambler', + img: 'QmW6hcwYzXrNkuHrpvo58YeZvbZxUddv69ATSHY3BHpPdd', + address: '0x333462427bcc9133bb46e88bcbe39cd7ef0e7333', + balance: 0.000001, + txCount: 1, + }, +} + +var unapprovedTxs = {} +addUnconfTx({ + from: '0x222462427bcc9133bb46e88bcbe39cd7ef0e7222', + to: '0x1113462427bcc9133bb46e88bcbe39cd7ef0e111', + value: '0x123', +}) +addUnconfTx({ + from: '0x1113462427bcc9133bb46e88bcbe39cd7ef0e111', + to: '0x333462427bcc9133bb46e88bcbe39cd7ef0e7333', + value: '0x0000', + data: '0x000462427bcc9133bb46e88bcbe39cd7ef0e7000', +}) + +function addUnconfTx (txParams) { + var time = (new Date()).getTime() + var id = createRandomId() + unapprovedTxs[id] = { + id: id, + txParams: txParams, + time: time, + } +} + +var isUnlocked = false +var selectedAccount = null + +function getState () { + return { + isUnlocked: isUnlocked, + identities: isUnlocked ? identities : {}, + unapprovedTxs: isUnlocked ? unapprovedTxs : {}, + selectedAccount: selectedAccount, + } +} + +var accountManager = new EventEmitter() + +accountManager.getState = function (cb) { + cb(null, getState()) +} + +accountManager.setLocked = function () { + isUnlocked = false + this._didUpdate() +} + +accountManager.submitPassword = function (password, cb) { + if (password === 'test') { + isUnlocked = true + cb(null, getState()) + this._didUpdate() + } else { + cb(new Error('Bad password -- try "test"')) + } +} + +accountManager.setSelectedAccount = function (address, cb) { + selectedAccount = address + cb(null, getState()) + this._didUpdate() +} + +accountManager.signTransaction = function (txParams, cb) { + alert('signing tx....') +} + +accountManager._didUpdate = function () { + this.emit('update', getState()) +} + +// start app + +var container = document.getElementById('app-content') + +var css = MetaMaskUiCss() +injectCss(css) + +MetaMaskUi({ + container: container, + accountManager: accountManager, +}) + +// util + +function createRandomId () { + // 13 time digits + var datePart = new Date().getTime() * Math.pow(10, 3) + // 3 random digits + var extraPart = Math.floor(Math.random() * Math.pow(10, 3)) + // 16 digits + return datePart + extraPart +} diff --git a/old-ui/index.html b/old-ui/index.html new file mode 100644 index 000000000..9dfaefbb3 --- /dev/null +++ b/old-ui/index.html @@ -0,0 +1,20 @@ + + + + + MetaMask + + + + +

+ + + + +
+ +
+ + + diff --git a/old-ui/index.js b/old-ui/index.js new file mode 100644 index 000000000..ae05cbe67 --- /dev/null +++ b/old-ui/index.js @@ -0,0 +1,58 @@ +const render = require('react-dom').render +const h = require('react-hyperscript') +const Root = require('./app/root') +const actions = require('./app/actions') +const configureStore = require('./app/store') +const txHelper = require('./lib/tx-helper') +global.log = require('loglevel') + +module.exports = launchMetamaskUi + + +log.setLevel(global.METAMASK_DEBUG ? 'debug' : 'warn') + +function launchMetamaskUi (opts, cb) { + var accountManager = opts.accountManager + actions._setBackgroundConnection(accountManager) + // check if we are unlocked first + accountManager.getState(function (err, metamaskState) { + if (err) return cb(err) + const store = startApp(metamaskState, accountManager, opts) + cb(null, store) + }) +} + +function startApp (metamaskState, accountManager, opts) { + // parse opts + const store = configureStore({ + + // metamaskState represents the cross-tab state + metamask: metamaskState, + + // appState represents the current tab's popup state + appState: {}, + + // Which blockchain we are using: + networkVersion: opts.networkVersion, + }) + + // if unconfirmed txs, start on txConf page + const unapprovedTxsAll = txHelper(metamaskState.unapprovedTxs, metamaskState.unapprovedMsgs, metamaskState.unapprovedPersonalMsgs, metamaskState.unapprovedTypedMessages, metamaskState.network) + if (unapprovedTxsAll.length > 0) { + store.dispatch(actions.showConfTxPage()) + } + + accountManager.on('update', function (metamaskState) { + store.dispatch(actions.updateMetamaskState(metamaskState)) + }) + + // start app + render( + h(Root, { + // inject initial state + store: store, + } + ), opts.container) + + return store +} diff --git a/old-ui/lib/contract-namer.js b/old-ui/lib/contract-namer.js new file mode 100644 index 000000000..f05e770cc --- /dev/null +++ b/old-ui/lib/contract-namer.js @@ -0,0 +1,33 @@ +/* CONTRACT NAMER + * + * Takes an address, + * Returns a nicname if we have one stored, + * otherwise returns null. + */ + +const contractMap = require('eth-contract-metadata') +const ethUtil = require('ethereumjs-util') + +module.exports = function (addr, identities = {}) { + const checksummed = ethUtil.toChecksumAddress(addr) + if (contractMap[checksummed] && contractMap[checksummed].name) { + return contractMap[checksummed].name + } + + const address = addr.toLowerCase() + const ids = hashFromIdentities(identities) + return addrFromHash(address, ids) +} + +function hashFromIdentities (identities) { + const result = {} + for (const key in identities) { + result[key] = identities[key].name + } + return result +} + +function addrFromHash (addr, hash) { + const address = addr.toLowerCase() + return hash[address] || null +} diff --git a/old-ui/lib/etherscan-prefix-for-network.js b/old-ui/lib/etherscan-prefix-for-network.js new file mode 100644 index 000000000..2c1904f1c --- /dev/null +++ b/old-ui/lib/etherscan-prefix-for-network.js @@ -0,0 +1,21 @@ +module.exports = function (network) { + const net = parseInt(network) + let prefix + switch (net) { + case 1: // main net + prefix = '' + break + case 3: // ropsten test net + prefix = 'ropsten.' + break + case 4: // rinkeby test net + prefix = 'rinkeby.' + break + case 42: // kovan test net + prefix = 'kovan.' + break + default: + prefix = '' + } + return prefix +} diff --git a/old-ui/lib/icon-factory.js b/old-ui/lib/icon-factory.js new file mode 100644 index 000000000..27a74de66 --- /dev/null +++ b/old-ui/lib/icon-factory.js @@ -0,0 +1,65 @@ +var iconFactory +const isValidAddress = require('ethereumjs-util').isValidAddress +const toChecksumAddress = require('ethereumjs-util').toChecksumAddress +const contractMap = require('eth-contract-metadata') + +module.exports = function (jazzicon) { + if (!iconFactory) { + iconFactory = new IconFactory(jazzicon) + } + return iconFactory +} + +function IconFactory (jazzicon) { + this.jazzicon = jazzicon + this.cache = {} +} + +IconFactory.prototype.iconForAddress = function (address, diameter) { + const addr = toChecksumAddress(address) + if (iconExistsFor(addr)) { + return imageElFor(addr) + } + + return this.generateIdenticonSvg(address, diameter) +} + +// returns svg dom element +IconFactory.prototype.generateIdenticonSvg = function (address, diameter) { + var cacheId = `${address}:${diameter}` + // check cache, lazily generate and populate cache + var identicon = this.cache[cacheId] || (this.cache[cacheId] = this.generateNewIdenticon(address, diameter)) + // create a clean copy so you can modify it + var cleanCopy = identicon.cloneNode(true) + return cleanCopy +} + +// creates a new identicon +IconFactory.prototype.generateNewIdenticon = function (address, diameter) { + var numericRepresentation = jsNumberForAddress(address) + var identicon = this.jazzicon(diameter, numericRepresentation) + return identicon +} + +// util + +function iconExistsFor (address) { + return contractMap[address] && isValidAddress(address) && contractMap[address].logo +} + +function imageElFor (address) { + const contract = contractMap[address] + const fileName = contract.logo + const path = `images/contract/${fileName}` + const img = document.createElement('img') + img.src = path + img.style.width = '75%' + return img +} + +function jsNumberForAddress (address) { + var addr = address.slice(2, 10) + var seed = parseInt(addr, 16) + return seed +} + diff --git a/old-ui/lib/lost-accounts-notice.js b/old-ui/lib/lost-accounts-notice.js new file mode 100644 index 000000000..948b13db6 --- /dev/null +++ b/old-ui/lib/lost-accounts-notice.js @@ -0,0 +1,23 @@ +const summary = require('../app/util').addressSummary + +module.exports = function (lostAccounts) { + return { + date: new Date().toDateString(), + title: 'Account Problem Caught', + body: `MetaMask has fixed a bug where some accounts were previously mis-generated. This was a rare issue, but you were affected! + +We have successfully imported the accounts that were mis-generated, but they will no longer be recovered with your normal seed phrase. + +We have marked the affected accounts as "Loose", and recommend you transfer ether and tokens away from those accounts, or export & back them up elsewhere. + +Your affected accounts are: +${lostAccounts.map(acct => ` - ${summary(acct)}`).join('\n')} + +These accounts have been marked as "Loose" so they will be easy to recognize in the account list. + +For more information, please read [our blog post.][1] + +[1]: https://medium.com/metamask/metamask-3-migration-guide-914b79533cdd#.7d8ktj4h3 + `, + } +} diff --git a/old-ui/lib/persistent-form.js b/old-ui/lib/persistent-form.js new file mode 100644 index 000000000..d4dc20b03 --- /dev/null +++ b/old-ui/lib/persistent-form.js @@ -0,0 +1,61 @@ +const inherits = require('util').inherits +const Component = require('react').Component +const defaultKey = 'persistent-form-default' +const eventName = 'keyup' + +module.exports = PersistentForm + +function PersistentForm () { + Component.call(this) +} + +inherits(PersistentForm, Component) + +PersistentForm.prototype.componentDidMount = function () { + const fields = document.querySelectorAll('[data-persistent-formid]') + const store = this.getPersistentStore() + + for (var i = 0; i < fields.length; i++) { + const field = fields[i] + const key = field.getAttribute('data-persistent-formid') + const cached = store[key] + if (cached !== undefined) { + field.value = cached + } + + field.addEventListener(eventName, this.persistentFieldDidUpdate.bind(this)) + } +} + +PersistentForm.prototype.getPersistentStore = function () { + let store = window.localStorage[this.persistentFormParentId || defaultKey] + if (store && store !== 'null') { + store = JSON.parse(store) + } else { + store = {} + } + return store +} + +PersistentForm.prototype.setPersistentStore = function (newStore) { + window.localStorage[this.persistentFormParentId || defaultKey] = JSON.stringify(newStore) +} + +PersistentForm.prototype.persistentFieldDidUpdate = function (event) { + const field = event.target + const store = this.getPersistentStore() + const key = field.getAttribute('data-persistent-formid') + const val = field.value + store[key] = val + this.setPersistentStore(store) +} + +PersistentForm.prototype.componentWillUnmount = function () { + const fields = document.querySelectorAll('[data-persistent-formid]') + for (var i = 0; i < fields.length; i++) { + const field = fields[i] + field.removeEventListener(eventName, this.persistentFieldDidUpdate.bind(this)) + } + this.setPersistentStore({}) +} + diff --git a/old-ui/lib/tx-helper.js b/old-ui/lib/tx-helper.js new file mode 100644 index 000000000..de3f00d2d --- /dev/null +++ b/old-ui/lib/tx-helper.js @@ -0,0 +1,27 @@ +const valuesFor = require('../app/util').valuesFor + +module.exports = function (unapprovedTxs, unapprovedMsgs, personalMsgs, typedMessages, network) { + log.debug('tx-helper called with params:') + log.debug({ unapprovedTxs, unapprovedMsgs, personalMsgs, typedMessages, network }) + + const txValues = network ? valuesFor(unapprovedTxs).filter(txMeta => txMeta.metamaskNetworkId === network) : valuesFor(unapprovedTxs) + log.debug(`tx helper found ${txValues.length} unapproved txs`) + + const msgValues = valuesFor(unapprovedMsgs) + log.debug(`tx helper found ${msgValues.length} unsigned messages`) + let allValues = txValues.concat(msgValues) + + const personalValues = valuesFor(personalMsgs) + log.debug(`tx helper found ${personalValues.length} unsigned personal messages`) + allValues = allValues.concat(personalValues) + + const typedValues = valuesFor(typedMessages) + log.debug(`tx helper found ${typedValues.length} unsigned typed messages`) + allValues = allValues.concat(typedValues) + + allValues = allValues.sort((a, b) => { + return a.time > b.time + }) + + return allValues +} -- cgit v1.2.3