output_description: Print the minimum number of operations required, or `-1` if the objective
  cannot be achieved.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 ... A_N
      B_1 B_2 ... B_N
attempt: import sys
  
  readline = sys.stdin.readline
  
  
  class Segtree:
      def __init__(self, A, intv, initialize=True, segf=max):
          self.N = len(A)
          self.N0 = 2 ** (self.N - 1).bit_length()
          self.intv = intv
          self.segf = segf
          if initialize:
              self.data = [intv] * self.N0 + A + [intv] * (self.N0 - self.N)
              for i in range(self.N0 - 1, 0, -1):
                  self.data[i] = self.segf(self.data[2 * i], self.data[2 * i + 1])
          else:
              self.data = [intv] * (2 * self.N0)
  
      def update(self, k, x):
          k += self.N0
          # self.data[k] = x
          while k > 0:
              k >>= 1
              self.data[k] = self.segf(self.data[2 * k], self.data[2 * k + 1])
  
      def query(self, l, r):
          L, R = l + self.N0, r + self.N0
          s = self.intv
          while L < R:
              if R & 1:
                  R -= 1
                  s = self.segf(s, self.data[R])
              if L & 1:
                  s = self.segf(s, self.data[L])
                  L += 1
              L >>= 1
              R >>= 1
          return s
  
      def binsearch(self, l, r, check, reverse=False):
          L, R = l + self.N0, r + self.N0
          SL, SR = [], []
          while L < R:
              if R & 1:
                  R -= 1
                  SR.append(R)
              if L & 1:
                  SL.append(L)
                  L += 1
              L >>= 1
              R >>= 1
  
          if reverse:
              for idx in SR + SL[::-1]:
                  if check(self.data[idx]):
                      break
              else:
                  return -1
              while idx < self.N0:
                  if check(self.data[2 * idx + 1]):
                      idx = 2 * idx + 1
                  else:
                      idx = 2 * idx
              return idx
          else:
              for idx in SL + SR[::-1]:
                  if check(self.data[idx]):
                      break
              else:
                  return -1
              while idx < self.N0:
                  if check(self.data[2 * idx]):
                      idx = 2 * idx
                  else:
                      idx = 2 * idx + 1
              return idx
  
  
  N = int(readline())
  A = list(map(int, readline().split()))
  B = list(map(int, readline().split()))
  
  inf = 10**10 + 7
  C = B + [-inf]
  res = 0
  T = Segtree(
      list(range(N)), N, initialize=True, segf=lambda x, y: x if C[x] > C[y] else y
  )
  cnt = 0
  while True:
      res += 1
      idx = T.query(0, T.N0)
      B[idx] -= B[(idx - 1) % N] + B[(idx + 1) % N]
      C[idx] -= B[(idx - 1) % N] + B[(idx + 1) % N]
      if A[idx] > C[idx]:
          res = -1
          break
      if A[idx] == C[idx]:
          cnt += 1
          C[idx] = -inf
      if cnt == N:
          break
      T.update(idx, B[idx])
  print(res)
  
problem_description: Statement
  
  There are N positive integers arranged in a circle.
  
  Now, the i-th number is A_i. Takahashi wants the i-th number to be B_i. For
  this objective, he will repeatedly perform the following operation:
  
    * Choose an integer i such that 1 \leq i \leq N.
    * Let a, b, c be the (i-1)-th, i-th, and (i+1)-th numbers, respectively. Replace the i-th number with a+b+c.
  
  Here the 0-th number is the N-th number, and the (N+1)-th number is the 1-st
  number.
  
  Determine if Takahashi can achieve his objective. If the answer is yes, find
  the minimum number of operations required.
samples: [{"input": "3\n    1 1 1\n    13 5 7", "output": "4\n    \n\nTakahashi can achieve his objective by, for example, performing the following\noperations:\n\n  * Replace the second number with 3.\n  * Replace the second number with 5.\n  * Replace the third number with 7.\n  * Replace the first number with 13.\n\n* * *"}, {"input": "4\n    1 2 3 4\n    2 3 4 5", "output": "-1\n    \n\n* * *"}, {"input": "5\n    5 6 5 2 1\n    9817 1108 6890 4343 8704", "output": "25"}]