exchange_cnt = 0

def insertion_sort(w_list, g):
    """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """
    global exchange_cnt
    N = len(w_list)
    for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v


def make_gap_sequence(n):
    """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """
    seq = []
    k = 1
    while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
    seq.reverse()   # in place なので効率が良い。
    return seq

def make_gap_sequence_2(n):
    """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """
    seq = []
    k = 1
    while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
    seq.append(1)
    return seq



def shell_sort(w_list):
    N = len(w_list)

    # N から gap sequence を決める。
    # どう決めるかで効率が変わってくるのだが、どう決めるかは難問。
    # gap_sequence = make_gap_sequence(N)
    gap_sequence = make_gap_sequence_2(N)

    for g in gap_sequence:
        insertion_sort(w_list, g)
    
    return gap_sequence


n = int(input())
w_list = []
for _ in range(n):
    w_list.append(int(input()))

gap_seq = shell_sort(w_list)

print(len(gap_seq))
print(*gap_seq)
print(exchange_cnt)
for i in w_list:
    print(i)
 exchange_cnt = 0 exchange_cnt 0 def insertion_sort(w_list, g):
    """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """
    global exchange_cnt
    N = len(w_list)
    for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v insertion_sort """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """ global exchange_cnt N = len(w_list) N len(w_list) len w_list for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v i range(g, N) range g N v = w_list[i] v w_list[i] w_list i j = i - g j i - g i g while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
         j >= 0 and w_list[j] > v j >= 0 j 0 w_list[j] > v w_list[j] w_list j v w_list[j+g] = w_list[j] w_list[j+g] w_list j+g j g w_list[j] w_list j j -= g j g exchange_cnt += 1 exchange_cnt 1 w_list[j+g] = v w_list[j+g] w_list j+g j g v w_list w_list g g def make_gap_sequence(n):
    """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """
    seq = []
    k = 1
    while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
    seq.reverse()   # in place なので効率が良い。
    return seq make_gap_sequence """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """ seq = [] seq [] k = 1 k 1 while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
     True gap = 2 ** k - 1 gap 2 ** k - 1 2 ** k 2 k 1 if gap > n:
            break
         gap > n gap n break seq.append(gap) seq.append seq append gap k += 1 k 1 seq.reverse() seq.reverse seq reverse return seq seq n n def make_gap_sequence_2(n):
    """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """
    seq = []
    k = 1
    while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
    seq.append(1)
    return seq make_gap_sequence_2 """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """ seq = [] seq [] k = 1 k 1 while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
     True gap = n // (2 ** k) gap n // (2 ** k) n 2 ** k 2 k if gap <= 1:
            break
         gap <= 1 gap 1 break seq.append(gap) seq.append seq append gap k += 1 k 1 seq.append(1) seq.append seq append 1 return seq seq n n def shell_sort(w_list):
    N = len(w_list)

    # N から gap sequence を決める。
    # どう決めるかで効率が変わってくるのだが、どう決めるかは難問。
    # gap_sequence = make_gap_sequence(N)
    gap_sequence = make_gap_sequence_2(N)

    for g in gap_sequence:
        insertion_sort(w_list, g)
    
    return gap_sequence shell_sort N = len(w_list) N len(w_list) len w_list gap_sequence = make_gap_sequence_2(N) gap_sequence make_gap_sequence_2(N) make_gap_sequence_2 N for g in gap_sequence:
        insertion_sort(w_list, g)
    
     g gap_sequence insertion_sort(w_list, g) insertion_sort w_list g return gap_sequence gap_sequence w_list w_list n = int(input()) n int(input()) int input() input w_list = [] w_list [] for _ in range(n):
    w_list.append(int(input())) _ range(n) range n w_list.append(int(input())) w_list.append w_list append int(input()) int input() input gap_seq = shell_sort(w_list) gap_seq shell_sort(w_list) shell_sort w_list print(len(gap_seq)) print len(gap_seq) len gap_seq print(*gap_seq) print *gap_seq gap_seq print(exchange_cnt) print exchange_cnt for i in w_list:
    print(i) i w_list print(i) print i def make_gap_sequence(n):
    """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """
    seq = []
    k = 1
    while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
    seq.reverse()   # in place なので効率が良い。
    return seq def make_gap_sequence(n):
    """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """
    seq = []
    k = 1
    while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
    seq.reverse()   # in place なので効率が良い。
    return seq make_gap_sequence w_list = [] [] w_list def make_gap_sequence_2(n):
    """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """
    seq = []
    k = 1
    while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
    seq.append(1)
    return seq def make_gap_sequence_2(n):
    """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """
    seq = []
    k = 1
    while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
    seq.append(1)
    return seq make_gap_sequence_2 exchange_cnt = 0 0 exchange_cnt n = int(input()) int(input()) n def insertion_sort(w_list, g):
    """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """
    global exchange_cnt
    N = len(w_list)
    for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v def insertion_sort(w_list, g):
    """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """
    global exchange_cnt
    N = len(w_list)
    for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v insertion_sort gap_seq = shell_sort(w_list) shell_sort(w_list) gap_seq def shell_sort(w_list):
    N = len(w_list)

    # N から gap sequence を決める。
    # どう決めるかで効率が変わってくるのだが、どう決めるかは難問。
    # gap_sequence = make_gap_sequence(N)
    gap_sequence = make_gap_sequence_2(N)

    for g in gap_sequence:
        insertion_sort(w_list, g)
    
    return gap_sequence def shell_sort(w_list):
    N = len(w_list)

    # N から gap sequence を決める。
    # どう決めるかで効率が変わってくるのだが、どう決めるかは難問。
    # gap_sequence = make_gap_sequence(N)
    gap_sequence = make_gap_sequence_2(N)

    for g in gap_sequence:
        insertion_sort(w_list, g)
    
    return gap_sequence shell_sort
exchange_cnt = 0

def insertion_sort(w_list, g):
    """一般化した Insertion ソート

    通常の Insertion ソートは gap が 1 固定だが、ここでは、
    gap を引数 g で指定できる。

    当然、g < len(w_list) でないといけない。
    """
    global exchange_cnt
    N = len(w_list)
    for i in range(g, N):
        v = w_list[i]
        j = i - g
        while j >= 0 and w_list[j] > v:
            w_list[j+g] = w_list[j]
            j -= g
            exchange_cnt += 1
        w_list[j+g] = v


def make_gap_sequence(n):
    """gap sequence を作成

    とりあえず、Wiki にのっていたやり方のひとつを採用。
    N ^ 1.5 のオーダーになるという。
    """
    seq = []
    k = 1
    while True:
        gap = 2 ** k - 1
        if gap > n:
            break
        seq.append(gap)
        k += 1
    seq.reverse()   # in place なので効率が良い。
    return seq

def make_gap_sequence_2(n):
    """もうひとつの gap sequence の作成方法

    Wiki にのっていた Shell によるオリジナルの方法。
    これだと最悪の場合、N ^ 2 のオーダーになってしまうようだ。
    """
    seq = []
    k = 1
    while True:
        gap = n // (2 ** k)
        if gap <= 1:
            break
        seq.append(gap)
        k += 1
    seq.append(1)
    return seq



def shell_sort(w_list):
    N = len(w_list)

    # N から gap sequence を決める。
    # どう決めるかで効率が変わってくるのだが、どう決めるかは難問。
    # gap_sequence = make_gap_sequence(N)
    gap_sequence = make_gap_sequence_2(N)

    for g in gap_sequence:
        insertion_sort(w_list, g)
    
    return gap_sequence


n = int(input())
w_list = []
for _ in range(n):
    w_list.append(int(input()))

gap_seq = shell_sort(w_list)

print(len(gap_seq))
print(*gap_seq)
print(exchange_cnt)
for i in w_list:
    print(i)

