Problem:
Score : 400 points

Problem Statement

In this problem, we only consider strings consisting of lowercase English letters.

Strings s and t are said to be isomorphic when the following conditions are satisfied:

|s| = |t| holds.

For every pair i, j, one of the following holds:

s_i = s_j and t_i = t_j.

s_i \neq s_j and t_i \neq t_j.

For example, abcac and zyxzx are isomorphic, while abcac and ppppp are not.

A string s is said to be in normal form when the following condition is satisfied:

For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.

For example, abcac is in normal form, but zyxzx is not since it is isomorphic to abcac, which is lexicographically smaller than zyxzx.

You are given an integer N.
Print all strings of length N that are in normal form, in lexicographically ascending order.

Constraints

1 \leq N \leq 10

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N

Output

Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order.
Output should be in the following format:

w_1
:
w_K

Sample Input 1

1

Sample Output 1

a

Sample Input 2

2

Sample Output 2

aa
ab

Solution in Lua (5.3.2) (judge verdict: Accepted)

local read = setmetatable({}, {__index = function(t, k) local a = {} for i=1,#k do table.insert(a, '*'..string.sub(k, i, i)) end local r = io.read local u = table.unpack or unpack return function() return r(u(a)) end end})
read.N = function(N) local t={} for i=1,N do t[i]=read.n() end return t end
string.totable = function(s) local t={} local u=string.sub for i=1,#s do t[i] = u(s, i, i) end return t end
string.split = function(s) local t={} for w in string.gmatch(s, "[^%s]+") do table.insert(t, w) end return (table.unpack or unpack)(t) end
local function array(dimension, default_val) assert(type(default_val) ~= 'table') local n=dimension local m={}if default_val~=nil then m[1]={__index=function()return default_val end}end for i=2,n do m[i]={__index=function(p, k)local c=setmetatable({},m[i-1])rawset(p,k,c)return c end}end return setmetatable({},m[n])end
local function open(...) for _,t in pairs{...} do for k,v in pairs(t) do _G[k]=v end end end
----
open(table, math)
local A = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
local N = read.n()

local ans = {}
local build = {}
local function count(s)
    return #s
end
local function pop(s)
    return remove(s)
end
local function push(s, a)
    insert(s, a)
end
local stack_data = {}
local stack_frame = {}
push(stack_frame, {["a"]="d"})
push(stack_data, {0, 0})
do
    ::entry::
    --print("entry", count(stack_data), count(stack_frame))
    local i, mx = unpack(pop(stack_data))
    --print("i,mx",i,mx)
    local j, lim, f
    if i == N then
        insert(ans, concat(build, ""))
        --print("going to branch_end")
        goto branch_end
    end
    j = 1
    lim = mx + 1
    ::loop_start::
    --print("loop_start")
    if j>lim then
        goto loop_end
    end
    build[i+1] = A[j]
    f = {}
    f.a = "r"
    f.i = i
    f.mx = mx
    f.j = j
    f.lim = lim
    --print("recursive")
    push(stack_frame, f)
    push(stack_data, {i+1, max(j,mx)})
    goto entry
    ::respawn::
    --print("respawn")
    goto loop_start
    ::loop_end::
    ::branch_end::
    --print("#stack_frame", count(stack_frame))
    local upper_frame = pop(stack_frame)
    if upper_frame.a == "d" then
        goto done
    elseif upper_frame.a == "r" then
        i = upper_frame.i
        mx = upper_frame.mx
        j = upper_frame.j
        lim = upper_frame.lim
        j = j + 1
        goto respawn
    end
end
::done::

for i=1,#ans do
    print(ans[i])
end