import Control.Applicative
import Control.Monad
import Control.Monad.ST
import Data.Functor
import Data.Function
import Data.Monoid
import Data.Maybe
import Data.List
import qualified Data.Foldable as Foldable
import qualified Data.Set as Set
--import qualified Data.Sequence as Sequence
import Data.List.Split
import Data.Bits
import Data.Char
import Data.Ix
import Data.Ratio
import Data.Ord
import Data.Tuple
--import Data.Array
--import Data.Array.Unboxed
import Data.Array.IArray
import Data.Array.MArray
import Data.Array.IO
import Data.Array.ST
import Data.IORef
import Data.STRef
-- import System.IO.Unsafe

-- templete
readInt = read :: String -> Int
readInteger = read :: String -> Integer
readDouble = read :: String -> Double
getInt = readLn :: IO Int
getInts = map readInt . words <$> getLine
getInteger = readLn :: IO Integer
getIntegers = map readInteger . words <$> getLine
getDouble = readLn :: IO Double
sjoin :: (Show a) => [a] -> String
sjoin = unwords . map show
cond :: a -> a -> Bool -> a
cond t f c = if c then t else f
apply2 :: (a -> a -> b) -> [a] -> b
apply2 f [x,y] = f x y
apply3 :: (a -> a -> a -> b) -> [a] -> b
apply3 f [x,y,z] = f x y z
apply4 :: (a -> a -> a -> a -> b) -> [a] -> b
apply4 f [x,y,z,w] = f x y z w
fnBin :: (b -> c -> d) -> (a -> b) -> (a -> c) -> a -> d
fnBin op f g x = op (f x) $ g x
fnTuple :: (a -> b, a -> c) -> a -> (b, c)
fnTuple (f,g) a = (f a, g a)
replace :: (Eq a) => a -> a -> [a] -> [a]
replace x y = map (\z -> if z==x then y else z)
modifyArray :: (Ix i, MArray a e m) => a i e -> i -> (e -> e) -> m ()
modifyArray arr ix f = readArray arr ix >>= writeArray arr ix . f
dictCompare :: [a -> a -> Ordering] -> a -> a -> Ordering
dictCompare [] _ _ = EQ
dictCompare (f:fs) x y = let c = f x y in if c==EQ then dictCompare fs x y else c
binMap :: (a -> a -> b) -> [a] -> [b]
binMap f (x:xs@(y:_)) = f x y : binMap f xs
binMap _ _ = []
splitRec :: Int -> [a] -> [[a]]
splitRec _ [] = []
splitRec n xs = let (y,ys) = splitAt n xs in y : splitRec n ys
infixl 7 `divCeil`
divCeil :: Integral a => a -> a -> a
x `divCeil` y = (x+y-1) `div` y
-- templete

type Board = ((Int,Int,Int,Int),(Int,Int,Int,Int))

move :: Board -> [Board]
move ((0,b,c,d),(e,f,g,h)) = [((b,0,c,d),(e,f,g,h)),((e,b,c,d),(0,f,g,h))]
move ((a,0,c,d),(e,f,g,h)) = [((0,a,c,d),(e,f,g,h)),((a,c,0,d),(e,f,g,h)),((a,f,c,d),(e,0,g,h))]
move ((a,b,0,d),(e,f,g,h)) = [((a,0,b,d),(e,f,g,h)),((a,b,d,0),(e,f,g,h)),((a,b,g,d),(e,f,0,h))]
move ((a,b,c,0),(e,f,g,h)) = [((a,b,0,c),(e,f,g,h)),((a,b,c,h),(e,f,g,0))]
move ((a,b,c,d),(0,f,g,h)) = [((0,b,c,d),(a,f,g,h)),((a,b,c,d),(f,0,g,h))]
move ((a,b,c,d),(e,0,g,h)) = [((a,0,c,d),(e,b,g,h)),((a,b,c,d),(0,e,g,h)),((a,b,c,d),(e,g,0,h))]
move ((a,b,c,d),(e,f,0,h)) = [((a,b,0,d),(e,f,c,h)),((a,b,c,d),(e,0,f,h)),((a,b,c,d),(e,f,h,0))]
move ((a,b,c,d),(e,f,g,0)) = [((a,b,c,0),(e,f,g,d)),((a,b,c,d),(e,f,0,g))]

f :: IOArray Board (Maybe Int) -> Int -> [Board] -> IO ()
f _ _ [] = return ()
f arr step list = sequence (map sub list) >>= f arr (step+1) . concat 
  where
    sub :: Board -> IO [Board]
    sub s = do
        c <- readArray arr s
        if isNothing c then writeArray arr s (Just step) >> return (move s) else return []


main = do
    arr <- newArray (((0,0,0,0),(0,0,0,0)),((7,7,7,7),(7,7,7,7))) Nothing :: IO (IOArray Board (Maybe Int))
    f arr 0 [((0,1,2,3),(4,5,6,7))]
    ds <- map ((\[a,b,c,d,e,f,g,h] -> ((a,b,c,d),(e,f,g,h))) . map read . words) . lines <$> getContents
    forM_ ds $ \d -> readArray arr d >>= print . fromMaybe (-1)





Measured memory_bytes: 145108