Oleg writes down the history of the days he lived. For each day he decides if it was good or bad. Oleg calls a non-empty sequence of days a zebra, if it starts with a bad day, ends with a bad day, and good and bad days are alternating in it. Let us denote bad days as 0 and good days as 1. Then, for example, sequences of days 0, 010, 01010 are zebras, while sequences 1, 0110, 0101 are not.

Oleg tells you the story of days he lived in chronological order in form of string consisting of 0 and 1. Now you are interested if it is possible to divide Oleg's life history into several subsequences, each of which is a zebra, and the way it can be done. Each day must belong to exactly one of the subsequences. For each of the subsequences, days forming it must be ordered chronologically. Note that subsequence does not have to be a group of consecutive days.
In the only line of input data there is a non-empty string *s* consisting of characters 0 and 1, which describes the history of Oleg's life. Its length (denoted as |*s*|) does not exceed 200 000 characters.
none
0010100
3
1 1
5 2 3 4 5 6
1 7
111
-1
0
1
1 1
1
-1
0101010101
-1
010100001
-1
000111000
3
3 1 6 7
3 2 5 8
3 3 4 9
0101001000
4
5 1 2 3 4 5
3 6 7 8
1 9
1 10
0000001000
8
1 1
1 2
1 3
1 4
1 5
3 6 7 8
1 9
1 10
0101
-1
000101110
-1
010101010
1
9 1 2 3 4 5 6 7 8 9
0101001010
2
5 1 2 3 4 5
5 6 7 8 9 10
0100101100
2
5 1 2 3 8 9
5 4 5 6 7 10
0110100000
-1
0000000000
10
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
1111111111
-1
0010101100
2
3 1 8 9
7 2 3 4 5 6 7 10
1010000
-1
0001110
-1
0000000000011001100011110101000101000010010111000100110110000011010011110110001100100001001001010010
22
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
7 9 24 25 26 27 28 29
7 10 13 14 17 18 23 30
11 11 12 15 16 19 22 31 32 33 34 35
3 20 21 36
3 37 46 47
9 38 39 40 45 48 57 58 75 76
17 41 42 43 44 49 50 51 54 55 56 59 72 73 74 77 80 81
9 52 53 60 71 78 79 82 83 84
7 61 64 65 66 67 70 85
5 62 63 68 69 86
3 87 88 89
3 90 91 92
5 93 94 95 96 97
3 98 99 100
01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010
1
245 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 ...
0010011100000000
8
3 1 8 9
5 2 3 4 7 10
3 5 6 11
1 12
1 13
1 14
1 15
1 16
# A. Zebras

from collections import deque
# Deque (Doubly Ended Queue) en Python. 
# Deque es preferible a una lista en los casos en los que necesitamos operaciones de adición y 
# extracción más rápidas desde ambos extremos (lef and right), ya que deque tiene complejidad de tiempo O(1) 
# para las operaciones de adición y extracción en comparación con la lista que tiene O(n).
# append():- inserta un elemento en   el extremo derecho de la deque (equivalente a un enqueue).
# popleft():- saca  un elemento en el extrermo izquierdo de la dequ (equivalente a un dequeue).
s = input() # se lee la cadena s de entrada que representa la historia de Olaf. 

almost_zebra = deque() # cola que va guardando las secuencias zebras
zebra = deque() # cola que va guardando las secuencias que si se le agrega un '0' se convierten en zebras



for index,c in enumerate(s): # se itera por cada caracter de la cadena
    # El método enumerate() agrega un contador a un iterable y lo devuelve en forma de objeto de enumeración. 
    # Este objeto enumerado puede usarse directamente para ciclos  o convertirse en una lista de tuplas usando el método list()
    if c =='1': # Si el próximo caracter de la secuencia es un '1' 
        if not zebra: # if la cola donde estan las secuencias zebra esta vacia no es posible dividir el string en subsequencias de zebra
            break # se rompe el ciclo pues ya no es necesario seguir revisando
        else: # sino es porque hay al menos una secuencia en zebra
            old_zebra = zebra.popleft() # se saca de la cola la proxima secuencia de zebra
            old_zebra.append(index+1) # se agrega la posicion del '1' a la secuencia  los dias de la historia de Olaf se numeran a partir de 1 por se se pone index + 1
            # Al agregar  '1' a alguna zebra pasa a covertirese en almost zebra '010' + '1' -> '0101'
            almost_zebra.append(old_zebra) #  se agrega la secuencia a la cola almost zebra

    else: # en caso contrario es porque es un '0'
        if almost_zebra: # si la cola  almost_zebra no esta vacia
            old_almost_zebra = almost_zebra.popleft() # saca la proxima secuencia de la cola
            old_almost_zebra.append(index+1) # se agrega la posicion correspondiente al '0' a la secuencia los dias de la historia de Olaf se numeran a partir de 1 por se se pone index + 1
            zebra.append(old_almost_zebra) # se agrega la secuencia a la cola de zebra pues una casi zebra termina en '1' y al agregarlo un '0' pasa a ser una zebra.
        else: # en caso contrario no hay secuencias en la cola almost_zebra por tanto se forma una secuencia ['0'] que tambien es una zebra
            zebra.append([index+1]) #  se agrega la posion del '0' a la secuencia y luego se agrega la secuencia a la cola zebra

if not zebra or almost_zebra: # si no hay elementos en la cola zebra o quedan elementos en la cola almost zebra  es porque no es posible dividir la cadena en zebra y almost zebra
    print(-1) # se imprime en consola -1 pues no se puede dividir la historia de Olaf en zebras
else: # en caso contrario se encontro una forma de subdivir la historia olaf en zebras
    print(len(zebra)) # se imprima la cantidad de subsecuencias que subdividen la historia e olaf en zebras
    for z in zebra: # se itera por cada subsecuencia zebra
        temp = [str(i) for i in z] # se convierte a string cada intero de la subsecuencia que representa la posicion de los elementos en la cadena que forman la misma
        print(len(temp), " ".join(temp)) #  se imprime por cada subecuencia zebra su longitud y cada uno de sus elementos separados por espacio (el join es muy comodo para hacer eso)
