Problem:
Score : 500 points

Problem Statement

Given are two strings s and t consisting of lowercase English letters. Determine if there exists an integer i satisfying the following condition, and find the minimum such i if it exists.

Let s' be the concatenation of 10^{100} copies of s. t is a subsequence of the string {s'}_1{s'}_2\ldots{s'}_i (the first i characters in s').

Notes

A subsequence of a string a is a string obtained by deleting zero or more characters from a and concatenating the remaining characters without changing the relative order. For example, the subsequences of contest include net, c, and contest.

Constraints

1 \leq |s| \leq 10^5

1 \leq |t| \leq 10^5

s and t consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s
t

Output

If there exists an integer i satisfying the following condition, print the minimum such i; otherwise, print -1.

Sample Input 1

contest
son

Sample Output 1

10

t = son is a subsequence of the string contestcon (the first 10 characters in s' = contestcontestcontest...), so i = 10 satisfies the condition.

On the other hand, t is not a subsequence of the string contestco (the first 9 characters in s'), so i = 9 does not satisfy the condition.

Similarly, any integer less than 9 does not satisfy the condition, either. Thus, the minimum integer i satisfying the condition is 10.

Sample Input 2

contest
programming

Sample Output 2

-1

t = programming is not a substring of s' = contestcontestcontest.... Thus, there is no integer i satisfying the condition.

Sample Input 3

contest
sentence

Sample Output 3

33

Note that the answer may not fit into a 32-bit integer type, though we cannot put such a case here.

Solution in LuaJIT (2.0.4) (judge verdict: Runtime Error)

local DBG = false
if not DBG then
    assert = function()end
end
local function dbgpr(...)
    if DBG then
        io.write("[dbg]")
        print(...)
    end
end

local function dbgpr_t(tbl, use_pairs)
    if DBG then
        local enum = ipairs
        if use_pairs then
            enum = pairs
        end
        dbgpr(tbl)
        io.write("[dbg]")
        for i,v in enum(tbl) do
            io.write(i)
            io.write(":")
            io.write(tostring(v))
            io.write(" ")
        end
        print("")
    end
end

local function dbgpr_tp(tbl)
    dbgpr_t(tbl, true)
end

local function str2tbl(s)
    -- limit of #s is approximately 999959
    local t = {string.byte(s, 1, #s)}
    local a = string.byte('a')
    local char = string.char
    for i=1, #t do
        t[i] = t[i] - a + 1
    end
    return t
end

-- E
local S = str2tbl(io.read("*l"))
local T = str2tbl(io.read("*l"))
--dbgpr_t(S)
--dbgpr_t(T)
local function search_s(n, c)
    for i=n,#S do
        if S[i] == c then
            --return i
            return i - n + 1
        end
    end
    return false
end
local lookup = {}
lookup[0] = {}
for c=1,26 do
    lookup[0][c] = search_s(1, c)
end
for i=1,#S do
    lookup[i] = {}
    for c=1,26 do
        if c == S[i] then
            lookup[i][c] = search_s(i+1, c)
        else
            local prev = lookup[i-1][c]
            lookup[i][c] = prev and prev - 1 or false
        end
    end
end

if DBG then
    for i=0,#S do
        local tbl = lookup[i]
        dbgpr(tbl)
        dbgpr(i)
        io.write("[dbg]")
        for j,v in ipairs(tbl) do
            io.write(string.char(j+96))
            io.write(":")
            io.write(v and v or '*')
            io.write(" ")
        end
        print("")
    end
end
local cur = 0
local ans = 0
local i = 1
while i <= #T do
    local c = T[i]
    dbgpr("!", "i=", i, ans, "c=", c, "cur=", cur, "#lookup", #lookup)
    local step = lookup[cur][c]
    dbgpr(i, ans, c, cur, step)
    if step then
        dbgpr(cur, step)
        ans = ans + step
        cur = cur + step
        assert(cur <= #S)
        i = i + 1
    elseif cur ~= 0 then
        ans = ans + (#S - cur)
        cur = 0
    else
        -- cur == 0
        print("-1")
        return
    end
end
print(ans)