type Jugs = (Int,Int,Int)
type Path = [(Int,Int)]

type State = (Jugs, Path)

start :: State
start = ((8,0,0), [])

successors :: State -> [State]

successors ((a,b,c),path) =
    let ab = min a (5 - b)
        ac = min a (3 - c)
        ba = min b (8 - a)
        bc = min b (3 - c)
        ca = min c (8 - a)
        cb = min c (5 - b)
        ss = [(ab, a-ab, b+ab,c, path++[(1,2)]),
              (ac, a-ac, b,c+ac, path++[(1,3)]),
              (ba, a+ba, b-ba,c, path++[(2,1)]),
              (bc, a,b-bc, c+bc, path++[(2,3)]),
              (ca, a+ca,b, c-ca, path++[(3,1)]),
              (cb, a,b+cb, c-cb, path++[(3,2)])]
    in
      [((a',b',c'), path') | (amount,a',b',c',path') <- ss, amount > 0]

search :: [State] -> Path

search (s:ss)
    | fst s == (4,4,0) = snd s
    | otherwise = search $ ss ++ successors s