let parse_optional ?(pos=0) ?len buf =
    let len =
      match len with Some s -> s | None -> String.length buf in
    let uint16 pos =
      Binary_packing.unpack_unsigned_8 ~buf ~pos +
        Binary_packing.unpack_unsigned_8 ~buf ~pos:(pos + 1) lsl 7 in
    let from () = String.sub buf pos len in
    dbg "from: %S" (from ());
    let rec build ofs acc =
      let error e = fail (`wrong_auxiliary_data (e, from ())) in
      if ofs >= len then return acc
      else (
        if ofs + 2 >= len then error `out_of_bounds
        else (
          let tag = String.sub buf ofs 2 in
          let typ = buf.[ofs + 2] in
          let check_size_and_return n r =
            if ofs + 2 + n >= len then error `out_of_bounds
            else return (r, n) in
          let parse_cCsSiIf pos typ =
            begin match typ with
            | 'i' ->
              signed_int ~buf ~pos >>= fun v ->
              check_size_and_return 4 (`int v)
            | 'A' -> check_size_and_return 1 (`char buf.[pos])
            | 'c' | 'C' -> check_size_and_return 1 (`int (Char.to_int buf.[pos]))
            | 's' ->
              check_size_and_return 2 (`int (
                Binary_packing.unpack_signed_16
                  ~byte_order:`Little_endian ~buf ~pos))
            | 'S' -> check_size_and_return 2 (`int (uint16 pos))
            | 'f' ->
              let f =
                Binary_packing.unpack_signed_32
                  ~byte_order:`Little_endian ~buf ~pos |! Int32.float_of_bits in
              check_size_and_return 4 (`float f)
            | _ -> error (`unknown_type typ)
            end
          in
          let pos = ofs + 3 in
          begin match typ with
          | 'A' -> check_size_and_return 1 (`char buf.[pos])
          | 'Z' ->
            begin match String.index_from buf pos '\000' with
            | Some e -> return (`string String.(slice buf pos e), e - pos + 1)
            | None -> error `null_terminated_string
            end
          | 'H' ->
            begin match String.index_from buf pos '\000' with
            | Some e -> return (`string String.(slice buf pos e), e - pos + 1)
            | None -> error `null_terminated_hexarray
            end
          | 'B' ->
            check_size_and_return 1 buf.[pos] >>= fun (array_type, _) ->
            signed_int ~buf ~pos:(pos + 1) >>= fun i32 ->
            check_size_and_return 4 i32 >>= fun (size, _) ->
            (if size > 4000 then error (`array_size size) else return ())
            >>= fun () ->
            let arr = Array.create size (`char 'B') in
            let rec loop p = function
              | 0 -> return p
              | n ->
                parse_cCsSiIf p array_type
                >>= fun (v, nb) ->
                arr.(size - n) <- v;
                loop (p + nb) (n - 1) in
            loop (pos + 5) size
            >>= fun newpos ->
            return (`array (array_type, arr), newpos - pos)
          | c -> parse_cCsSiIf pos c
          end
              >>= fun (v, nbread) ->
          build (ofs + 3 + nbread) ((tag, typ, v) :: acc)
        )
      )
    in
    match build pos [] with
    | Ok r -> return (List.rev r)
    | Error (`wrong_auxiliary_data e) -> fail (`wrong_auxiliary_data e)
    | Error (`wrong_int32 e) -> fail (`wrong_auxiliary_data (`wrong_int32 e, from ()))