output_description: If it is impossible to have a non-decreasing sequence, print `-1`. If it is
  possible, print the minimum number of operations required to achieve it.
  
  * * *
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
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  
  import itertools
  
  N = int(readline())
  A = list(map(int, readline().split()))
  B = list(map(int, readline().split()))
  
  
  class BinaryIndexedTree:
      def __init__(self, seq):
          self.size = len(seq)
          self.depth = self.size.bit_length()
          self.build(seq)
  
      def build(self, seq):
          data = seq
          size = self.size
          for i, x in enumerate(data):
              j = i + (i & (-i))
              if j < size:
                  data[j] += data[i]
          self.data = data
  
      def __repr__(self):
          return self.data.__repr__()
  
      def get_sum(self, i):
          data = self.data
          s = 0
          while i:
              s += data[i]
              i -= i & -i
          return s
  
      def add(self, i, x):
          data = self.data
          size = self.size
          while i < size:
              data[i] += x
              i += i & -i
  
      def find_kth_element(self, k):
          data = self.data
          size = self.size
          x, sx = 0, 0
          dx = 1 << (self.depth)
          for i in range(self.depth - 1, -1, -1):
              dx = 1 << i
              if x + dx >= size:
                  continue
              y = x + dx
              sy = sx + data[y]
              if sy < k:
                  x, sx = y, sy
          return x + 1
  
  
  def Inversion(seq):
      # seqは、1,2,...,Nの順列
      N = len(seq)
      bit = BinaryIndexedTree([0] * (N + 1))
      inv = N * (N - 1) // 2
      for x in seq:
          inv -= bit.get_sum(x)
          bit.add(x, 1)
      return inv
  
  
  INF = 10**9
  answer = INF
  for I in itertools.combinations(range(N), (N + 1) // 2):
      J = [j for j in range(N) if j not in I]
      ODD = [(B[i] if i & 1 else A[i], i) for i in I]
      EV = [(A[i] if i & 1 else B[i], i) for i in J]
      ODD.sort()
      EV.sort()
      ind = [0] * N
      seq = [0] * N
      for i in range(0, N, 2):
          seq[i], ind[i] = ODD[i // 2]
      for i in range(1, N, 2):
          seq[i], ind[i] = EV[i // 2]
      if not all(x <= y for x, y in zip(seq, seq[1:])):
          continue
      ind = [x + 1 for x in ind]
      n = Inversion(ind)
      if answer > n:
          answer = n
  
  if answer == INF:
      answer = -1
  print(answer)
  
problem_description: Statement
  
  We have N cards numbered 1, 2, ..., N. Card i (1 \leq i \leq N) has an integer
  A_i written in red ink on one side and an integer B_i written in blue ink on
  the other side. Initially, these cards are arranged from left to right in the
  order from Card 1 to Card N, with the red numbers facing up.
  
  Determine whether it is possible to have a non-decreasing sequence facing up
  from left to right (that is, for each i (1 \leq i \leq N - 1), the integer
  facing up on the (i+1)-th card from the left is not less than the integer
  facing up on the i-th card from the left) by repeating the operation below. If
  the answer is yes, find the minimum number of operations required to achieve
  it.
  
    * Choose an integer i (1 \leq i \leq N - 1). Swap the i-th and (i+1)-th cards from the left, then flip these two cards.
samples: [{"input": "3\n    3 4 3\n    3 2 3", "output": "1\n    \n\nBy doing the operation once with i = 1, we have a sequence [2, 3, 3] facing\nup, which is non-decreasing.\n\n* * *"}, {"input": "2\n    2 1\n    1 2", "output": "-1\n    \n\nAfter any number of operations, we have the sequence [2, 1] facing up, which\nis not non-decreasing.\n\n* * *"}, {"input": "4\n    1 2 3 4\n    5 6 7 8", "output": "0\n    \n\nNo operation may be required.\n\n* * *"}, {"input": "5\n    28 15 22 43 31\n    20 22 43 33 32", "output": "-1\n    \n\n* * *"}, {"input": "5\n    4 46 6 38 43\n    33 15 18 27 37", "output": "3"}]