output_description: If a tree with n vertices that satisfies the conditions does not exist, print
  `-1`.
  
  If a tree with n vertices that satisfies the conditions exist, print n-1
  lines. The i-th line should contain u_i and v_i with a space in between. If
  there are multiple trees that satisfy the conditions, any such tree will be
  accepted.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      s
attempt: #!usr/bin/env python3
  from collections import defaultdict
  from collections import deque
  from heapq import heappush, heappop
  import sys
  import math
  import bisect
  import random
  
  
  def LI():
      return list(map(int, sys.stdin.readline().split()))
  
  
  def I():
      return int(sys.stdin.readline())
  
  
  def LS():
      return list(map(list, sys.stdin.readline().split()))
  
  
  def S():
      return list(sys.stdin.readline())[:-1]
  
  
  def IR(n):
      l = [None for i in range(n)]
      for i in range(n):
          l[i] = I()
      return l
  
  
  def LIR(n):
      l = [None for i in range(n)]
      for i in range(n):
          l[i] = LI()
      return l
  
  
  def SR(n):
      l = [None for i in range(n)]
      for i in range(n):
          l[i] = S()
      return l
  
  
  def LSR(n):
      l = [None for i in range(n)]
      for i in range(n):
          l[i] = SR()
      return l
  
  
  mod = 1000000007
  
  
  # A
  def A():
      return
  
  
  # B
  def B():
      return
  
  
  # C
  def C():
      n = I()
      v = LI()
      d = [defaultdict(int) for i in range(2)]
      for i in range(n):
          d[i % 2][v[i]] += 1
      if len(d[0].keys()) == len(d[1].keys()) == 1:
          if d[0].keys() == d[1].keys():
              ans = n // 2
          else:
              d = [list(d[i].values()) for i in range(2)]
              ans = sum(d[0]) - max(d[0]) + sum(d[1]) - max(d[1])
      else:
          d = [sorted(list(d[i].items()), key=lambda x: -x[1]) for i in range(2)]
          if d[0][0][0] != d[1][0][0]:
              ans = -d[0][0][1] - d[1][0][1]
              for i in range(len(d[0])):
                  ans += d[0][i][1]
              for i in range(len(d[1])):
                  ans += d[1][i][1]
          else:
              ans = -d[0][0][1] - d[1][1][1]
              for i in range(len(d[0])):
                  ans += d[0][i][1]
              for i in range(len(d[1])):
                  ans += d[1][i][1]
              ans2 = -d[0][1][1] - d[1][0][1]
              for i in range(len(d[0])):
                  ans2 += d[0][i][1]
              for i in range(len(d[1])):
                  ans2 += d[1][i][1]
              ans = min(ans, ans2)
      print(ans)
  
  
  # D
  def D():
      return
  
  
  # E
  def E():
      s = list(map(int, S()))
      if s[-1] == 1:
          print(-1)
          quit()
      s.pop(-1)
      if s != s[::-1]:
          print(-1)
          quit()
      n = len(s)
      ans = [[1, i + 2] for i in range(n)]
      s = s[: n // 2 + n % 2]
      m = (n + 1) // 2
      k = 0
      for i in range(len(s)):
          k += s[i]
      if k == 0:
          print(-1)
          quit()
      if sorted(s, reverse=True) != s:
          print(-1)
          quit()
      for i in range(k - 1):
          ans[i + 1] = [i + 2, ans[i + 1][1]]
      for i, j in ans:
          print(i, j)
  
  
  # F
  def F():
      return
  
  
  # G
  def G():
      return
  
  
  # H
  def H():
      return
  
  
  # Solve
  if __name__ == "__main__":
      E()
  
problem_description: Statement
  
  You are given a string s of length n. Does a tree with n vertices that
  satisfies the following conditions exist?
  
    * The vertices are numbered 1,2,..., n.
    * The edges are numbered 1,2,..., n-1, and Edge i connects Vertex u_i and v_i.
    * If the i-th character in s is `1`, we can have a connected component of size i by removing one edge from the tree.
    * If the i-th character in s is `0`, we cannot have a connected component of size i by removing any one edge from the tree.
  
  If such a tree exists, construct one such tree.
samples: [{"input": "1111", "output": "-1\n    \n\nIt is impossible to have a connected component of size n after removing one\nedge from a tree with n vertices.\n\n* * *"}, {"input": "1110", "output": "1 2\n    2 3\n    3 4\n    \n\nIf Edge 1 or Edge 3 is removed, we will have a connected component of size 1\nand another of size 3. If Edge 2 is removed, we will have two connected\ncomponents, each of size 2.\n\n* * *"}, {"input": "1010", "output": "1 2\n    1 3\n    1 4\n    \n\nRemoving any edge will result in a connected component of size 1 and another\nof size 3."}]