module Main where

-- import Debug.Trace

{-
 - Next lexicographical permutation algorithm
 - by Project Nayuki, 2016. Public domain.
 - https://www.nayuki.io/page/next-lexicographical-permutation-algorithm
 -
 - Computes the next lexicographical permutation of the specified finite list of numbers.
 - Returns Nothing if the argument is already the highest permutation.
 -}
nextPermutation :: Ord a => [a] -> Maybe [a]
nextPermutation xs =
  let
    len = length xs
    revSuffix = findPrefix (reverse xs)  -- Reverse of longest non-increasing suffix
    suffixLen = length revSuffix
    prefixMinusPivot = take (len - suffixLen - 1) xs
    pivot = xs !! (len - suffixLen - 1)
    suffixHead = takeWhile (<= pivot) revSuffix
    newPivot : suffixTail = drop (length suffixHead) revSuffix
    newSuffix = suffixHead ++ (pivot : suffixTail)
  in
    if suffixLen == len then Nothing else Just (prefixMinusPivot ++ (newPivot : newSuffix))
  where
    findPrefix [] = []
    findPrefix (x:xs) = x : (if xs /= [] && x <= (head xs) then (findPrefix xs) else [])

-- debug = flip trace

permutationEqual a b = all (==True) (zipWith (\a b -> a == b) a b)

solve :: (Int, Maybe [Int], Int, Int) -> (Int, [Int], [Int]) -> (Int, Maybe [Int], Int, Int)
solve (idx, Nothing, pi, qi) (size, ps, qs) = (idx, Nothing, pi, qi)
solve (idx, _, pi, qi) _ | pi /= 0 && qi /= 0 = (idx, Nothing, pi, qi)
solve (idx, Just permutation, pi, qi) (size, ps, qs)
  | permutationEqual permutation ps = (idx + 1, npermutation, idx, qi) -- `debug` (mconcat [show permutation, show npermutation])
  | permutationEqual permutation qs = (idx + 1, npermutation, pi, idx) -- `debug` (mconcat [show permutation, show npermutation])
  | otherwise = (idx + 1, npermutation, pi, qi) -- `debug` (mconcat [show permutation, show npermutation])
  where
    npermutation = nextPermutation permutation

main =
  read <$> getLine >>= \size ->
  fmap (map read . words) getLine >>= \ps ->
  fmap (map read . words) getLine >>= \qs ->
  let
    factorial n = product [1..n]
    (_, _, pi, qi) = foldl solve (1, Just [1..size], 0, 0) [(size, ps, qs) | d <- [1..factorial size]]
    result = abs (pi - qi)
   in
   if permutationEqual ps qs
      then putStrLn "0"
      else putStrLn $ show result
