contract Maps =

  record pt    = {x : int, y : int}
  record state = { map_i : map(int, pt),
                   map_s : map(string, pt) }

  entrypoint init() = { map_i = {}, map_s = {} }

  entrypoint get_state() = state

  // {[k] = v}
  entrypoint map_i() =
    { [1] = {x = 1, y = 2},
      [2] = {x = 3, y = 4},
      [3] = {x = 5, y = 6} }
  entrypoint map_s() =
    { ["one"]   = {x = 1, y = 2},
      ["two"]   = {x = 3, y = 4},
      ["three"] = {x = 5, y = 6} }
  stateful entrypoint map_state_i() = put(state{ map_i = map_i() })
  stateful entrypoint map_state_s() = put(state{ map_s = map_s() })

  // m[k]
  entrypoint get_i(k, m : map(int,    pt)) = m[k]
  entrypoint get_s(k, m : map(string, pt)) = m[k]
  entrypoint get_state_i(k) = get_i(k, state.map_i)
  entrypoint get_state_s(k) = get_s(k, state.map_s)

  // m[k = v]
  entrypoint get_def_i(k, v, m : map(int,    pt)) = m[k = v]
  entrypoint get_def_s(k, v, m : map(string, pt)) = m[k = v]
  entrypoint get_def_state_i(k, v) = get_def_i(k, v, state.map_i)
  entrypoint get_def_state_s(k, v) = get_def_s(k, v, state.map_s)

  // m{[k] = v}
  entrypoint set_i(k, p, m : map(int,    pt)) = m{ [k] = p }
  entrypoint set_s(k, p, m : map(string, pt)) = m{ [k] = p }
  stateful entrypoint set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
  stateful entrypoint set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })

  // m{f[k].x = v}
  entrypoint setx_i(k, x, m : map(int,    pt)) = m{ [k].x = x }
  entrypoint setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
  stateful entrypoint setx_state_i(k, x) = put(state{ map_i[k].x = x })
  stateful entrypoint setx_state_s(k, x) = put(state{ map_s[k].x = x })

  // m{[k] @ x = v }
  entrypoint addx_i(k, d, m : map(int,    pt)) = m{ [k].x @ x = x + d }
  entrypoint addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
  stateful entrypoint addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
  stateful entrypoint addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })

  // m{[k = def] @ x = v }
  entrypoint addx_def_i(k, v, d, m : map(int,    pt)) = m{ [k = v].x @ x = x + d }
  entrypoint addx_def_s(k, v, d, m : map(string, pt)) = m{ [k = v].x @ x = x + d }

  // Map.member
  entrypoint member_i(k, m : map(int,    pt)) = Map.member(k, m)
  entrypoint member_s(k, m : map(string, pt)) = Map.member(k, m)
  entrypoint member_state_i(k) = member_i(k, state.map_i)
  entrypoint member_state_s(k) = member_s(k, state.map_s)

  // Map.lookup
  entrypoint lookup_i(k, m : map(int,    pt)) = Map.lookup(k, m)
  entrypoint lookup_s(k, m : map(string, pt)) = Map.lookup(k, m)
  entrypoint lookup_state_i(k) = lookup_i(k, state.map_i)
  entrypoint lookup_state_s(k) = lookup_s(k, state.map_s)

  // Map.lookup_default
  entrypoint lookup_def_i(k, m : map(int,    pt), def : pt) =
    Map.lookup_default(k, m, def)
  entrypoint lookup_def_s(k, m : map(string, pt), def : pt) =
    Map.lookup_default(k, m, def)
  entrypoint lookup_def_state_i(k, def) = lookup_def_i(k, state.map_i, def)
  entrypoint lookup_def_state_s(k, def) = lookup_def_s(k, state.map_s, def)

  // Map.delete
  entrypoint delete_i(k, m : map(int,    pt)) = Map.delete(k, m)
  entrypoint delete_s(k, m : map(string, pt)) = Map.delete(k, m)
  stateful entrypoint delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
  stateful entrypoint delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })

  // Map.size
  entrypoint size_i(m : map(int,    pt)) = Map.size(m)
  entrypoint size_s(m : map(string, pt)) = Map.size(m)
  entrypoint size_state_i() = size_i(state.map_i)
  entrypoint size_state_s() = size_s(state.map_s)

  // Map.to_list
  entrypoint tolist_i(m : map(int,    pt)) = Map.to_list(m)
  entrypoint tolist_s(m : map(string, pt)) = Map.to_list(m)
  entrypoint tolist_state_i() = tolist_i(state.map_i)
  entrypoint tolist_state_s() = tolist_s(state.map_s)

  // Map.from_list
  entrypoint fromlist_i(xs : list(int    * pt)) = Map.from_list(xs)
  entrypoint fromlist_s(xs : list(string * pt)) = Map.from_list(xs)
  stateful entrypoint fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
  stateful entrypoint fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })