// Original C++ solution (slower):
#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <iostream>

#include <istream>

#include <iterator>

#include <limits>

#include <list>

#include <map>

#include <memory>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>

#include <random>

#include <tuple>

#include <iomanip>

#include <cstring>



using namespace std;



typedef long long ll;

//typedef pair<int,int> Pint;

//typedef pair<ll, ll> P;

//typedef pair<ll, pair<ll, ll>> P;

//typedef tuple<int,int,int> T;

typedef vector<ll> vec;

typedef vector<vec> mat;

#define rep(i, n) for(ll i = 0; i < (n); i++)

#define revrep(i, n) for(ll i = (n-1); i >= 0; i--)

#define pb push_back

#define f first

#define s second

//const ll INFL = 1LL << 60;//10^18 = 2^60

const ll INFL = 1LL << 60;

const int INF = 1 << 30;//10^9

ll MOD = 1e9 + 7;

//ll MOD  = 998244353;

vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};



ll max(ll a, ll b){return (a > b) ? a : b;}

ll min(ll a, ll b){return (a < b) ? a : b;}

ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x;

    k /= 2;

  }

  return res;

}

ll pow_mod(ll x, ll k){

  x %= MOD; x += MOD; x %= MOD;

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}

ll inverse(ll x){return pow_mod(x, MOD - 2);};



//最大公約数

ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



//最小公倍数

ll lcm(ll x, ll y){return x / gcd(x, y) * y;};



//コンビネーション

const int MAXcomb = 200010;

ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];

//facはn!,finvは1/n!

//invは逆元

void COMinit(){

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for(int i = 2; i < MAXcomb; i++){

        fac[i] = fac[i-1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;

        finv[i] = finv[i-1] * inv[i] % MOD;

    }

}

ll comb(int n, int k){

    if(n < k) return 0;

    if(n < 0 || k < 0) return 0;

    return fac[n] * finv[k] % MOD * finv[n-k] % MOD;

}



ll kai_mod(ll x){

  if(x == 1) return 1;

  return x * kai_mod(x-1) % MOD;

}





ll N, Q;



vector<ll> E[200010];

vector<ll> ans(200010);

vector<ll> query(200010);



void dfs(ll now, ll from){

  ans[now] += query[now];

  for(ll to : E[now]){

    if(to == from) continue;

    query[to] += query[now];

    dfs(to, now);

  }

}



int main(void){

  string S, T;

  cin >> S >> T;

  vector<ll> X[30];

  rep(i, S.size()){

    X[S[i] - 'a'].pb(i);

  }



  rep(i, T.size()){

    if(X[T[i] - 'a'].size() == 0){

      cout << -1 << endl;

      return 0;

    }

  }



  rep(i, S.size()){

    X[S[i] - 'a'].pb(i + S.size());

  }

  ll now = -1;

  ll ans = 0;

  rep(i, T.size()){

    ll x = *upper_bound(X[T[i] - 'a'].begin(), X[T[i] - 'a'].end(), now);

    ans += x - now;

    now = x;

    now %= S.size();

  }

  cout << ans << endl;















}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <iostream>

#include <istream>

#include <iterator>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>

#include <tuple>

#include <iomanip>

#include <climits>

#include <fstream>

using namespace std;



typedef long long ll;

typedef unsigned long long ull;

//typedef pair<ll, ll> P;

#define rep(i, n) for(int i = 0; i < (n); i++)

#define revrep(i, n) for(int i = (n)-1; i >= 0; i--)

#define pb push_back

#define f first

#define s second

#define chmin(x, y) x = min(x, y);

#define chmax(x, y) x = max(x, y);



//const ll INFL = LLONG_MAX;//10^18 = 2^60

const ll INFL = 1LL<<60;

//const int INF = INT_MAX;

const int INF = 1 << 30;//10^9

ll MOD = 1000000007;

//ll MOD = 998244353;

double EPS = 1e-11;



vector<ll> dy = {0, 1, 0, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, 0, -1, 0, 1, -1, 1, -1, 0};



void pres(double A){printf("%.12lf\n", A);}

void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}

ll cnt_bit(ll x){return __builtin_popcountll(x);}



ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x; k /= 2;

  }

  return res;

}



ll pow_mod(ll x, ll k){

  x %= MOD;

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}



ll inverse(ll x){return pow_mod(x, MOD - 2);};



ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



ll lcm(ll x, ll y){

  ll res = x / gcd(x, y);

  res *= y;

  return res;

};





//コンビネーション

const int MAXcomb = 2000010;

ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];

//facはn!,finvは1/n!

//invは逆元

void COMinit(){

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for(int i = 2; i < MAXcomb; i++){

        fac[i] = fac[i-1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;

        finv[i] = finv[i-1] * inv[i] % MOD;

    }

}

ll comb(int n, int k){

    if(n < k) return 0;

    if(n < 0 || k < 0) return 0;

    return fac[n] * finv[k] % MOD * finv[n-k] % MOD;

}



const int MAXkai = 200010;

ll kai_memo[MAXkai];

ll kai(ll N){

  if(kai_memo[N] != 0) return kai_memo[N];

  if(N <= 1) return 1;

  return kai_memo[N] = N * kai(N-1) % MOD;

}



ll disit(ll s, ll base = 10){

  ll res = 0;

  while(s){

    res++;

    s /= base;

  }

  return res;

}



//素因数分解O(√n)

vector<pair<ll, ll>> MakePrimeList(ll x) {

    vector<pair<ll, ll>> res;

    for(ll k=2; k*k<=x; k++) {

        if(x % k == 0) {

            ll cnt = 0;

            while(x % k == 0){

              x /= k;

              cnt++;

            }

            res.pb({k, cnt});

        }

    }

    if(x > 1) res.push_back({x, 1});

    return res;

}



bool existS[26], existT[26];

vector<ll> E[26];



void solve(){

  string S, T;

  cin >> S >> T;

  rep(i, S.size()){

    existS[S[i]-'a'] = 1;

  }

  rep(i, T.size()){

    existT[T[i]-'a'] = 1;

  }

  rep(i, 26)if(existT[i]&&!existS[i]){

    cout << -1 << endl;

    return;

  }

  rep(i, S.size()){

    E[S[i]-'a'].pb(i);

  }

  rep(i, S.size()){

    E[S[i]-'a'].pb(i+S.size());

  }

  ll ans = 0;

  ll now = -1;

  rep(i, T.size()){

    ll ne = *upper_bound(E[T[i]-'a'].begin(), E[T[i]-'a'].end(), now);

    ans += ne - now;

    now = ne % S.size();

  }

  cout << ans << endl;

}



int main(){

  cin.tie(0);

  ios::sync_with_stdio(false);

  solve();

}


// Fastest known solution for this problem: